Mon installation domotique

Boite aux lettres connectée

Wifi et MQTT
avec un ESP8266-01s

La boite aux lettres.

<

Suivant le modèle (porte latérale ou basculante) elle est équipée :
- soit de 2 ILS ou d'1 ILS et d'une barrière Infrarouge
- d'un module avec un esp8266-01s et une alimentation 12/3,3 Volts , le tout dans une boite plexo.
- pour le volet ; lors d'un mouvement l'ILS ou la barrière IR met à la masse GPIO 0 du ESP8266-01s
- pour la porte ; lors de son ouverture l'ILS met à la masse GPIO 2.

esp1a

Les diodes de la barrière IR

Chez Aliexpress , l'intitulé : Détecteur de faisceau infrarouge DC5V, 4 Euros avec le port
https://fr.aliexpress.com/item/32998692609.html?spm=a2g0o.9042311.0.0.27426c37SgrASN
Les spécifications sont données pour 5 Volts mais la barrière fonctionne correctement sous 3,3 Volts

Distance de détection: 1m
Tension de travail: DC5V
Courant de travail: 200mA
Courant de sortie: 16mA (peut se connecter directement au relais)
Sortie: NPN (normalement ouvert ou fermé suivant le modèle)
Angle de l'émetteur: ligne (infrarouge)
Angle du récepteur: < 10 °
Temps de réponse: 2ms
Température de travail: -25 ~ 60 °C
Environnement de travail: intérieur (non étanche)
La tension entre VCC et sortie est de 0V, et lorsqu'il y a un obstacle,
la tension est de 5V

esp39

Important : les contacts Reed ILS doivent être NF ou NC (contact ouvert , l'aimant approché pour un montage PullUp , voir ci-après);
les chinois ont une appellation inverse NO , bien vérifier le type.
Pour la barrière IR , comme pour les ILS bien vérifier le modèle (normalement close NC chez les Chinois).

Le schéma de câblage des ILS avec les 2 résistances de PullUP (qui servent à mettre GPIO0 et GPIO2 à l’état haut : HIGHT);
ce choix est imposé par l'ESP8266 car si :
- GPIO0 est LOW : échec de démarrage
- GPIO2 est LOW échec de démarrage également: HIGH obligatoire sur BOOT,

Il faut donc que l’ESP envoi une notification en wifi lorsque les GPIO0 et GPIO2 changent d’état de HIGHT à LOW

esp2

Le schéma avec la barrière IR

esp40

esp2a

esp38

Les messages MQTT sont envoyés, dans ce tuto, à une variable de Domoticz (domoticz/in),ils peuvent être envoyés à d'autres utilisateurs.

L'esp8266-01

En savoir plus sur l'esp8266-01 : https://ouilogique.com/esp8266-01/ .

- il est nécessaire d’utiliser une alimentation 3.3 V externe entre (VCC et GND), car la consommation électrique de l'esp01 est importante lorsque le Wifi se connecte.
- pour que le module soit actif ,le pin CH_PD (chip power-down) doit être obligatoirement raccordé à VCC.
- RST peut lui aussi être raccordé à VCC pour éviter des resets intempestifs. (ou avec une résistance de 10 kΩ à VCC et un bouton poussoir à GND. Lorsque la broche RST est LOW, l'ESP8266 se réinitialise ( RESET )

esp1

Programmation de l’esp, scripts lua et python (domoticz)

Pour flasher un programme dans la mémoire de l'ESP01 depuis un ordinateur il faut :
-soit utiliser le programme développé pour les Arduino https://www.arduino.cc/en/software
-soit Le logiciel CoolTerm : commandes AT https://xofe14.scenari-community.org/Publications/Formations/Formation_Arduino_Lycee_web/co/CoolTerm.html
-soit ESPlorer : https://esp8266.ru/esplorer/

- pouvoir connecter l'ESP01 à l'ordinateur :
l'ESP01 ne dispose pas de port USB,iIl va donc falloir le connecter en utilisant un module USB pour module ESP8266

esp3

le mode "PROG" : pour flasher un programme dans la mémoire de l'ESP.ce mode s'active quand l'ESP démarre avec sa broche GPIO0 raccordée à GND

Il existe des modules avec un interrupteur permettant le choisir le mode UART ou PROG ,j'ai utilisé quelquefois ce genre de module avant qu'il ne tombe en panne; je suis revenu à la version classique à laquelle j'ai ajouté 2 fils Dupont, entre GND et GPIO 0, avec des terminaisons mâle et femelle.
- modèle avec commutateur

esp4

- modéle classique modifié:

esp5 esp6

Pour la programmation je vais utiliser l'IDE Arduino

Pour s'assurer que l'ESP est bien fonctionnel, avec une commande AT :

esp7

esp8

Sur Windows le port doit être à la même vitesse qu'indiquée dans le programme Arduino

esp9

le programme qui sera injecté pour envoyer au serveur MQTT le changement de position des ILS remplacera le firmware de l'ESP8266.Ce dernier ne répondra donc plus aux commandes AT.

Réglages préliminaires

pour la programmation de l'ESP8266 avec l'IDE Arduino:
- Sélection de l’URL pour installer le package nécessaire pour les cartes à base de l’esp8266:

esp10

url :http://arduino.esp8266.com/stable/package_esp8266com_index.json

esp11

- Sélectionner Type de carte :

esp12

esp13

- Sélectionner de nouveau Type de carte pour choisir après ce téléchargement qui est long, la bonne carte :

esp14

esp15

Normalement , il n’y a pas besoin de modifier les paramètres indiqués dans outils :

esp16

Programmation

Pour utiliser la Wifi ,envoyer des messages à MQTT et formater ces messages en Json , il faut installer des bibliothèques:
- wifi : une multitude de librairies existent : ESP8266WiFi, ESP8266wifi, ESP8266WiFiMulti, ESP8266HTTPClient...la librairie officielle est ESP8266WiFi ,https://github.com/esp8266/Arduino/tree/master/libraries/ESP8266WiFi

- Envoi des données : librairies WiFiUdp, PubSubClient(pour MQTT) et ArduinoJson ; PubSubClient et ArduinoJson doivent être téléchargées et ajoutées à l’IDE

esp17

esp18

esp19

Le programme , inspiré de https://byfeel.info/client-mqtt-dans-votre-module-esp/

// inclusion des bibliothèques pour wifi et MQTT
#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include <PubSubClient.h> 
#include <ArduinoJson.h>

//WiFi Connection configuration
char* ssid = "Freebox-AABBCCDD"; 
char* password = "xxxxxxx-yyyyyyy-zzzzzzz-1234565"; 
//mqtt server
char mqtt_server[] = "192.168.1.42";
WiFiClient espClient;
PubSubClient MQTTclient(espClient);

#define MQTT_USER "michel"    // si user existe
#define MQTT_PASS "xxxxxxxxx"    // si pass MQTT
String lettre = ".";
String colis = ".";
String facteur = "0";
int volet = 0;// GPIO 0
int porte = 2;//GPIO 2
//mqtt
void MQTTsend() {
  char buffer[512];
  DynamicJsonDocument docMqtt(512);
  docMqtt["command"]= "setuservariable";
  docMqtt["idx"]= 19;
  docMqtt["value"]= lettre+"."+colis;
  size_t n = serializeJson(docMqtt, buffer);
  MQTTclient.publish("domoticz/in", buffer, n);
  //Serial.print("envoi : "+lettre+" "+colis);
   }

void MQTTconnect() {
  while (!MQTTclient.connected()) {
      Serial.print("Attente  MQTT connection...");
      String clientId = "NotifheureClient-";
      clientId += String(random(0xffff), HEX);

// Attente connexion MQTT
    if (MQTTclient.connect(clientId.c_str(),MQTT_USER,MQTT_PASS)) {
      Serial.println("connecté à MQTT");
      MQTTclient.subscribe("esp/in/boite_lettres");
      } else {
      //Serial.print("ECHEC, rc=");
      //Serial.print(MQTTclient.state());
      //Serial.println(" try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}
void MQTTcallback(char* topic, byte* payload, unsigned int length) {
  //Serial.print("Message MQTT [");
  //Serial.print(topic);
  //Serial.print("] ");

DynamicJsonDocument docMqtt(512);
deserializeJson(docMqtt, payload, length);
String valeur;  
valeur=docMqtt["valeur"]|"";
//Serial.println("confirmation message reçu de dz: valeur variable="+valeur);
facteur=valeur;
lettre = ".";
colis = ".";
}

void setup() {
pinMode (volet, INPUT) ;  
pinMode (porte, INPUT) ;  
Serial.begin(115200);
  // Conexion WIFI
   WiFi.begin(ssid, password);
   //Serial.println("");
  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    //Serial.print(".");
  }
   //Serial.println("Connected");
   MQTTclient.setServer(mqtt_server, 1883);
   
}

void loop() {
if (digitalRead(porte)== LOW) {colis = "colis";facteur="1"; }
if (digitalRead(volet)== LOW)  {lettre = "lettre";facteur="1"; }
  static uint32_t  lastTimeMqtt= 0;
  // connecte serveur MQTT
  if (!MQTTclient.connected()) {
    MQTTconnect();
  MQTTclient.setCallback(MQTTcallback);
  }

MQTTclient.loop();
  if (millis() - lastTimeMqtt >= 200000)  // toutes les 100 secondes
   {
     lastTimeMqtt = millis();
     if(facteur=="1"){ MQTTsend();}
   }
}

Choisir le bon port com (s’il n’est pas trouvé automatiquement) et vérifier le programme :

esp20

Upload du programme :

- Vérifier que le commutateur du module USB se trouve sur PROG , si c'est ce modèle qui est utilisé.
- Sinon relier les 2 fils Dupont pour mettre GPIO 0 à GND.

- brancher le module sur le PC

esp21

- La LED rouge doit être allumée et le rester
- La LED bleue peut clignoter au démarrage

GPIO 0 est de nouveau HIGH (les fils dupont sont désaccouplés) ; Il est recommandé de faire un reset en branchant temporairement RST à GND avant de le remettre à 3,3 volts, je ne le fais pas toujours..........Téléverser:

esp22

esp23

les notifications sur le port série et les messages MQTT

comme demandé par le programme , faire un reset: connecter le fil Dupont GND à GPIO 0.

esp24

Le monitor série de l’IDE :

esp25

Les messages publiés (avec MQTT fx)
Mise à LOW de GPIO 0 (ILS du volet de la boite aux lettres) et envoi du topic :

esp26

esp28

esp29

Réponse, ici de Domoticz, lorsque le message a été vu , pour mettre l’historique de l'ESP à zéro
la gestion de la variable est assurée par un script dzvent et un script python

esp27

esp30

Le script Python pour l'envoi du message , c' est mon script généraliste pour publier des messages MQTT , il suffit de passer les variables "topic ,et payload (nom et valeur) :

#!/usr/bin/env python3.7
# -*- coding: utf-8 -*-

import paho.mqtt.client as mqtt
import json
import sys
# Define Variables
topic= str(sys.argv[1])
etat= str(sys.argv[2]) 
valeur= str(sys.argv[3]) 
MQTT_HOST = "192.168.1.42"
MQTT_PORT = 1883
MQTT_KEEPALIVE_INTERVAL = 45
MQTT_TOPIC = topic

MQTT_MSG=json.dumps({etat: valeur});
# Define on_publish event function
def on_publish(client, userdata, mid):
    print ("Message Published...")

def on_connect(client, userdata, flags, rc):
    client.subscribe(MQTT_TOPIC)
    client.publish(MQTT_TOPIC, MQTT_MSG)

def on_message(client, userdata, msg):
    print(msg.topic)
    print(msg.payload) # <- do you mean this payload = {...} ?
    payload = json.loads(msg.payload) # you can use json.loads to convert string to json
    #print(payload['state_l2']) # then you can check the value
    client.disconnect() # Got message then disconnect

# Initiate MQTT Client
mqttc = mqtt.Client()

# Register publish callback function
mqttc.on_publish = on_publish
mqttc.on_connect = on_connect
mqttc.on_message = on_message

# Connect with MQTT Broker
mqttc.connect(MQTT_HOST, MQTT_PORT, MQTT_KEEPALIVE_INTERVAL)

# Loop forever
mqttc.loop_forever()

câblage

Le câblage définitif :

esp31

Le câblage sur la platine d’ essai :

esp32

Le module final :

esp33

Ou celui-ci plus facile à réaliser en utilisant un support pour esp01 plutôt que des embases pour fil Dupont (les soudures sont plus faciles).

esp37

ma page perso

quelques copies d'écran

esp34

un clic sur la boite aux lettres

esp35

esp36

crée le 05/06/2021
14/09/2021 ajout précision sur les ILS NF
08/01/2022 Cht BL, Barrière IR en remplacement ILS

page:68