Les cookies assurent le bon fonctionnement de nos services. En utilisant ces derniers, vous acceptez l'utilisation des cookies. En savoir plus

Les croquettes du Chat en iot

Sauvegarder: J'aime

Partager:

Difficulté:

ou comment maîtriser l’alimentation d’un chat particulièrement rusé à base d’ESP8266+LUA, de grove gesture et de node-red


Si vous avez un chat à la maison, il vient forcement vous tourner dans les pattes en miaulant dés que l’on s’approche de la gamelle. Et comme vous n’habitez pas forcement seul, il fait ça avec chaque personnes de la maison. Comme il est mignon et que les miaulements sont particulièrement énervant, chacun donne à manger au chat.
Comme nous ne voulons pas que le petit chat tout mignon devienne un gros matou qui prenne toute la place sur le canapé, j’ai mis au point ce magnifique objet qui nous permet de suivre l’alimentation du chat.
Le principe est le suivant :
– dés que l’un d’entre nous donne à manger au chat, on “note” la quantité de croquettes données.
– selon les moments de la journée et les doses déjà données, le chat à le droit au pas à une nouvelle quantité de croquettes


Cet objet est de la même famille que http://ouiaremakers.com/mes-refrigerateur-congelateur-en-mode-connecte/


Le principe de fonctionnement est de créer un objet (la boite en carton)
– qui transmet un message mqtt dés qu’il détecte et interprète un mouvement de la main devant lui.
– qui affiche le texte envoyé par mqtt


Et de mettre “l’intelligence” dans un raspberry pi qui exécute node-red et envoie les messages mqtt.


Toutes les sources du projet (et bien d’autres) sont sur https://github.com/FredThx/nodemcu_iot


Il y a quelques années un premier essai de régulation de l’alimentation du chat avait été tenté : https://youtu.be/Kgjeanw8S8Q . Malheureusement lors d’un jour d’absence, le chat a tout bousillé pour manger tout le stock!!!

Matériel :

Budget : Non défini

  • J’ai utilisé:
  • – un module nodemcu (à base d’ESP8266) : 5€
  • – un écran LCD avec interface i2c : 2€
  • – un module grove gesture (détecteur de mouvement de la main) : 14€
  • – boite en carton
  • – des aimants pour coller la boite au radiateurEt par ailleurs un raspberry pi pour faire serveur mqtt et serveur node-red.

Etape 1 : Le module NodeMcu (avec de l’ESP8266 dedans)

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…

Etape 2 : Ecran LCD

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

Etape 3 : Grove gesture

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

Etape 4 : Montage électronique

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

Etape 5 : Code lua

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

Etape 6 : Programmation du module

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.

Etape 7 : Mosquitto : un serveur MQTT

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

Etape 8 : Node-red

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…

Etape 9 : Flux Node-red

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.

Etape 10 : Le carton c’est si bon!

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.

Etape 11 : Les gestes

Etape 12 : Conclusion

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
– …

Sources :

http://www.seeedstudio.com/wiki/Grove_-_Gesture_v1.0, http://nodemcu.com/, http://frightanic.com/nodemcu-custom-build/, http://www.luteus.biz/Download/LoriotPro_Doc/LUA/LUA_Training_FR/Introduction_Programmation.html, https://github.com/nodemcu, http://flows.nodered.org/, http://noderedguide.com/, http://bekti.io/automatically-start-a-node-js-application-on-raspberry-pi/, http://mosquitto.org/, https://github.com/FredThx/nodemcu_iot


Sauvegarder: J'aime

Partager:

Recevez une fois par mois les meilleurs tutoriels Déco dans votre boîte mail


Ces tutoriels devraient vous plaire

Réaliser des photos thermiques à partir d'Arduino
Grande horloge numérique avec télécommande IR
Gestion thermique automatique de PC

Découvrez tous les tutoriels partagés sur Oui Are Makers

Powered by Oui Are Makers