Si, comme moi, vous ne pouvez pas installer des câbles dans toute la maison pour automatiser différents appareils, il est parfois essentiel de chercher des alternatives tout aussi efficaces.
Dans mon contexte, je voulais savoir si mon portail était ouvert 
ou fermé 
. Cependant, je n’avais qu’une seule gaine reliant la maison au moteur du portail. Cette gaine transporte l’alimentation du moteur et de la borne de recharge pour la voiture électrique, alors difficile d’y passer un cable qui sera connecté aux entrées digitales de mon IPX.
J’ai donc envisagé une solution sans fil. Ayant un ESP8266 à disposition, je voulais tester sa complexité d’utilisation et sa fiabilité.
J’ai décidé de relier la sortie « warning » du moteur du portail à une entrée (IO) de mon ESP8266. Pour déterminer si votre moteur est compatible, je vous suggère de consulter la documentation et de rechercher une sortie active quand le portail est ouvert (ou fermé). Si une tension est présente sur cette sortie, pensez à utiliser un relais pour protéger l’IO de votre ESP 
Maintenant, il reste à faire en sorte que l’ESP envoie une requête M2M à l’IPX pour modifier l’état d’une entrée virtuelle.
Voici l’intégralité du code de mon ESP
#include <ESP8266WiFi.h>
#include <ArduinoOTA.h>
#include <Debouncer.h>
#define WIFI_SSID "<nom_du_wifi>"
#define WIFI_PSK "<mot_de_passe_du_wifi>"
#define V4_HOST "<ip_du_ipx>"
#define V4_PORT 9870
#define VI_ON "SetVI=1" // commande pour activer l'entrée virtuelle #1
#define VI_OFF "ClearVI=1" // commande pour désactiver l'entrée virtuelle #1
#define DEBOUNCE_MS 277
WiFiClient client;
Debouncer debouncer(D1, DEBOUNCE_MS);
void setup() {
pinMode(D1, INPUT_PULLUP);
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_PSK);
WiFi.waitForConnectResult();
debouncer.subscribe([](const int state) {
if (client.connect(V4_HOST, V4_PORT)) {
client.write(state ? VI_ON : VI_OFF);
client.stop();
}
});
ArduinoOTA.begin();
}
void loop() {
ArduinoOTA.handle();
debouncer.update();
}
En moins de 30 lignes de code, l’ESP est capable de gérer :
- La mise à jour du code via WiFi, évitant ainsi le déplacement avec un ordinateur portable ou la nécessité de brancher un câble USB pour les mises à jour ou le débogage.
- La gestion efficace du « débounce », un enjeu courant lors de la conversion d’un signal électrique en ON/OFF.
- La mise à jour d’une entrée virtuelle sur mon IPX.
Je ne vais pas faire un cours détaillé sur l’ESP, mais voici une explication de chacune des lignes de code.
#include <ESP8266WiFi.h>
Inclut la bibliothèque nécessaire pour utiliser la fonctionnalité WiFi sur les modules ESP8266.
#include <ArduinoOTA.h>
Inclut la bibliothèque qui permet la mise à jour « Over The Air » (OTA) de l’ESP8266. Cela permet de téléverser un nouveau code sur l’ESP8266 sans utiliser de câble USB, en utilisant le WiFi.
#include <Debouncer.h>
Inclut la bibliothèque Debouncer. Un « debouncer » est utilisé pour éliminer les faux déclenchements d’un bouton ou d’un interrupteur (rebonds).
#define WIFI_SSID "<nom_du_wifi>"
Définit la constante WIFI_SSID avec le nom de votre réseau WiFi.
#define WIFI_PSK "<mot_de_passe_du_wifi>"
Définit la constante WIFI_PSK avec le mot de passe de votre réseau WiFi.
#define V4_HOST "<ip_du_ipx>"
Définit l’adresse IP du serveur IPX.
#define V4_PORT 9870
Définit le port sur lequel votre serveur IPX est à l’écoute. C’est le port par défaut du M2M.
#define VI_ON "SetVI=1"
#define VI_OFF "ClearVI=1"
Ces deux lignes définissent les commandes à envoyer à l’IPX pour activer/désactiver mon entrée virtuelle #1.
#define DEBOUNCE_MS 277
Définit le temps (en millisecondes) pendant lequel le debouncer attend avant de considérer qu’un bouton est vraiment pressé ou relâché. Pourquoi 277 ? Juste parce que c’est le nombre premier le plus proche de 250. Pourquoi 250 ? Car après quelques tests, il s’avère que la sortie est stable après « seulement » 250 ms.
WiFiClient client;
Crée un objet client pour se connecter à des serveurs via le WiFi.
Debouncer debouncer(D1, DEBOUNCE_MS);
Initialise un objet debouncer sur la broche D1 avec le délai défini précédemment.
void setup() {
Fonction setup qui est exécutée une seule fois au démarrage du microcontrôleur.
pinMode(D1, INPUT_PULLUP);
Configure la broche D1 en mode entrée avec une résistance de pull-up.
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_PSK);
WiFi.waitForConnectResult();
Ces lignes configurent l’ESP8266 pour qu’il se connecte à votre réseau WiFi en mode STATION (aka. client du réseau WiFi) vu que l’ESP pousse l’information à l’IPX.
debouncer.subscribe([](const int state) {
if (client.connect(V4_HOST, V4_PORT)) {
client.write(state ? VI_ON : VI_OFF);
client.stop();
}
});
On s’abonne aux changements d’état de notre IO D1 via le debouncer. Dès qu’il y a un changement d’état, la fonction anonyme (lambda) sera appelée.
Cette dernière se connect à l’IPX et si tout se passe bien envoie la bonne commande (en fonction de l’état state) puis se déconnecte (stop) afin de ne pas gaspiller de ressources sur l’IPX.
ArduinoOTA.begin();
}
Enfin, pour terminer notre setup, on démarre le service OTA afin que l’ESP soit à l’écoute de demande de mise à jour.
void loop() {
ArduinoOTA.handle();
debouncer.update();
}
Dans la fonction loop qui est exécutée en boucle une fois le setup terminé, on traite les demande de mise a jour OTA et on met à jour l’état du debouncer.