Bouclier multicapteur ESP8266 avec Node-RED

Dans ce projet, vous découvrirez comment intégrer le Shield multicapteur ESP8266 pour la carte Wemos D1 Mini avec Node-RED. L’ESP8266 Multisensor Shield établira une connexion MQTT avec un Raspberry Pi exécutant Node-RED et Mosquitto MQTT.

Aperçu du projet

Le blindage Multisensor se compose d’un capteur de température, d’un capteur de mouvement, d’un LDR et d’une prise 3 broches où vous pouvez connecter n’importe quelle sortie, comme un module de relais par exemple.

Nous utiliserons le courtier Mosquitto installé sur le même Raspberry Pi exécutant Node-RED. Le courtier est chargé de recevoir tous les messages, de filtrer les messages, de décider qui s’y intéresse et de publier les messages à tous les clients abonnés. Pour en savoir plus sur MQTT, vous pouvez lire : Qu’est-ce que MQTT et comment ça marche.

La figure suivante montre un aperçu de ce que nous allons faire dans ce didacticiel.

• L’application Node-RED publie des messages (« au » ou « désactivé« ) dans le sujet esp8266/sortie. L’ESP8266 est abonné à ce sujet. Ainsi, il reçoit le message avec « on » ou « off » pour activer ou désactiver la sortie.
• L’ESP8266 publie la température sur le esp8266/température sujet et la luminosité sur le esp8266/ldr sujet. L’application Node-RED est abonnée à ces sujets. Ainsi, il reçoit des lectures de température et de luminosité qui sont affichées sur un graphique et une jauge.
• Node-RED est abonné au sujet esp8266/mouvement. L’ESP8266 publie sur ce sujet lorsqu’un mouvement est détecté. Lorsqu’un mouvement est détecté, le message « MOTION DETECTED! » s’affiche pendant 10 secondes dans le widget texte Node-RED Dashboard.

Lecture recommandée: ESP32 MQTT – Publier et s’abonner avec Arduino IDE

Conditions préalables

Si vous aimez la domotique et que vous souhaitez en savoir plus sur Node-RED, Raspberry Pi, ESP8266 et Arduino, nous vous recommandons de télécharger notre cours : Construire un système domotique avec Node-RED, ESP8266 et Arduino.

Ressources

Vous pouvez trouver toutes les ressources nécessaires pour construire ce projet dans les liens ci-dessous (ou vous pouvez visiter le Projet GitHub):

Schématique

Vous pouvez construire le blindage multicapteur sur un PCB, ou vous pouvez construire le circuit de blindage multicapteur sur une planche à pain.

Voici une liste des pièces dont vous avez besoin pour construire le circuit :

Vous pouvez utiliser les liens précédents ou accéder directement à MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Après avoir rassemblé toutes les pièces nécessaires, assemblez le circuit en suivant le schéma suivant :

Voici à quoi ressemble le circuit sur une planche à pain :

Alternativement, vous pouvez construire un PCB pour le WeMos D1 Mini (apprenez à construire un bouclier multicapteur pour ESP8266) :

Voici à quoi ressemble le circuit en utilisant le blindage PCB avec un boîtier imprimé en 3D :

Préparation de l’IDE Arduino

Nous allons programmer l’ESP8266 à l’aide de l’IDE Arduino. Afin de télécharger du code sur votre ESP8266 à l’aide de l’IDE Arduino, vous devez installer le module complémentaire ESP8266 (Comment installer la carte ESP8266 dans l’IDE Arduino). Vous devrez également installer trois bibliothèques supplémentaires pour exécuter le code sur l’ESP8266.

Installation de la bibliothèque PubSubClient

le PubSubClient La bibliothèque fournit un client pour effectuer une simple messagerie de publication/abonnement avec un serveur qui prend en charge MQTT (permet essentiellement à votre ESP8266 de parler avec Node-RED).

1. Cliquez ici pour télécharger la bibliothèque PubSubClient. Vous devriez avoir un .Zip *: français dossier dans votre dossier Téléchargements
2. Décompressez le .Zip *: français dossier et vous devriez obtenir pubsubclient-master dossier
3. Renommez votre dossier de pubsubclient-master à pubsous-client
4. Bouge le pubsous-client dossier à votre installation Arduino IDE bibliothèques dossier

Bibliothèque OneWire

1. Cliquez ici pour télécharger la bibliothèque OneWire. Vous devriez avoir un dossier .zip dans vos téléchargements
2. Décompressez le .Zip *: français dossier et vous devriez obtenir OneWire-maître dossier
3. Renommez votre dossier de OneWire-maître à Un fil
4. Bouge le Un fil dossier à votre installation Arduino IDE bibliothèques dossier

Bibliothèque de température de Dallas

1. Cliquez ici pour télécharger la bibliothèque DallasTemperature. Vous devriez avoir un dossier .zip dans vos téléchargements
2. Décompressez le .Zip *: français dossier et vous devriez obtenir Arduino-Temperature-Control-Library-master dossier
3. Renommez votre dossier de Arduino-Temperature-Control-Library-master à DallasTempérature
4. Bouge le DallasTempérature dossier à votre installation Arduino IDE bibliothèques dossier
5. Enfin, rouvrez votre IDE Arduino

Télécharger le code

Copiez le code suivant dans l’IDE Arduino. Le code est bien commenté sur les endroits où vous devez apporter des modifications. Vous devez modifier le code avec votre propre SSID, mot de passe et adresse IP du courtier MQTT (adresse IP Raspberry Pi).

/*********
  Rui Santos
  Complete project details at https://www.raspberryme.com  
*********/

// Load libraries
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <OneWire.h>
#include <DallasTemperature.h>

// Replace with your network credentials
const char* ssid     = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// Change the variable to your Raspberry Pi IP address, so it connects to your MQTT broker
const char* mqtt_server = "REPLACE_WITH_YOUR_MQTT_BROKER";
// MQTT Broker IP example
//const char* mqtt_server = "192.168.1.144";

// Initializes the espClient. You should change the espClient name if you have multiple ESPs running in your home automation system
WiFiClient espClient;
PubSubClient client(espClient);

// Variable to hold the temperature reading
String temperatureString = "";

// Set GPIOs for: output variable, status LED, PIR Motion Sensor, and LDR
const int output = 15;
const int statusLed = 12;
const int motionSensor = 5;
const int ldr = A0;
// Store the current output state
String outputState = "off";

// GPIO where the DS18B20 is connected to
const int oneWireBus = 4;          
// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(oneWireBus);
// Pass our oneWire reference to Dallas Temperature sensor 
DallasTemperature sensors(&oneWire);

// Timers - Auxiliary variables
unsigned long now = millis();
unsigned long lastMeasure = 0;
boolean startTimer = false;
unsigned long currentTime = millis();
unsigned long previousTime = 0; 

// Don't change the function below. 
// This function connects your ESP8266 to your router
void setup_wifi() {
  delay(10);
  // We start by connecting to a WiFi network
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("WiFi connected - ESP IP address: ");
  Serial.println(WiFi.localIP());
}

// This functions is executed when some device publishes a message to a topic that your ESP8266 is subscribed to
// Change the function below to add logic to your program, so when a device publishes a message to a topic that 
// your ESP8266 is subscribed you can actually do something
void callback(String topic, byte* message, unsigned int length) {
  Serial.print("Message arrived on topic: ");
  Serial.print(topic);
  Serial.print(". Message: ");
  String messageTemp;
  
  for (int i = 0; i < length; i++) {
    Serial.print((char)message[i]);
    messageTemp += (char)message[i];
  }
  Serial.println();

  // Feel free to add more if statements to control more GPIOs with MQTT
  // If a message is received on the topic esp8266/output, you check if the message is either on or off. 
  // Turns the output according to the message received
  if(topic=="esp8266/output"){
    Serial.print("Changing output to ");
    if(messageTemp == "on"){
      digitalWrite(output, LOW);
      Serial.print("on");
    }
    else if(messageTemp == "off"){
      digitalWrite(output, HIGH);
      Serial.print("off");
    }
  }
  Serial.println();
}

// This functions reconnects your ESP8266 to your MQTT broker
// Change the function below if you want to subscribe to more topics with your ESP8266 
void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Create a random client ID
    String clientId = "ESP8266Client-";
    clientId += String(random(0xffff), HEX);
    // Attempt to connect
    if (client.connect(clientId.c_str())) {
      Serial.println("connected");  
      // Subscribe or resubscribe to a topic
      // You can subscribe to more topics (to control more outputs)
      client.subscribe("esp8266/output");  
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}

// Checks if motion was detected and the sensors are armed. Then, starts a timer.
ICACHE_RAM_ATTR void detectsMovement() {
  Serial.println("MOTION DETECTED!");
  client.publish("esp8266/motion", "MOTION DETECTED!");
  previousTime = millis();
  startTimer = true;
}

void setup() {
  // Start the DS18B20 sensor
  sensors.begin();

  // Serial port for debugging purposes
  Serial.begin(115200);

  // PIR Motion Sensor mode, then set interrupt function and RISING mode
  pinMode(motionSensor, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(motionSensor), detectsMovement, RISING);
  
  // Initialize the output variable and the LED as OUTPUTs
  pinMode(output, OUTPUT);
  pinMode(statusLed, OUTPUT);
  digitalWrite(output, HIGH);
  digitalWrite(statusLed, LOW);
  
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
  
  // Timer variable with current time
  now = millis();

  // Publishes new temperature and LDR readings every 30 seconds
  if (now - lastMeasure > 30000) {
    lastMeasure = now;
    sensors.requestTemperatures(); 
    // Temperature in Celsius degrees
    temperatureString = String(sensors.getTempCByIndex(0));
    // Uncomment the next line for temperature in Fahrenheit degrees
    //temperatureString = String(sensors.getTempFByIndex(0));
    // Publishes Temperature values
    client.publish("esp8266/temperature", temperatureString.c_str());
    Serial.println("Temperature published");
    
    // Publishes LDR values
    client.publish("esp8266/ldr", String(analogRead(ldr)).c_str());
    Serial.println("LDR values published");    
  }
  // After 10 seconds have passed since motion was detected, publishes a "No motion" message
  if ((now - previousTime > 10000) && startTimer) { 
    client.publish("esp8266/motion", "No motion");
    Serial.println("Motion stopped");
    startTimer = false;
  }
}

Afficher le code brut

Ce code est assez long à expliquer, vous pouvez donc simplement remplacer les trois variables suivantes par vos coordonnées et le code fonctionnera immédiatement.

const char* ssid = "";
const char* password = "";
const char* mqtt_server = "";

Si vous voulez savoir comment fonctionne ce code, continuez à lire.

rappeler()

Dans le rappeler() fonction lorsqu’un nouveau message est reçu sur le sujet esp8266/sortievous vérifiez si le message est soit au ou désactivé pour activer ou désactiver la sortie en conséquence.

if(topic=="esp8266/output"){
  Serial.print("Changing output to ");
  if(messageTemp == "on"){
    digitalWrite(output, LOW);
    Serial.print("on");
  }
  else if(messageTemp == "off"){
    digitalWrite(output, HIGH);
    Serial.print("off");
  }
}

Publication des relevés de température et LDR

Cette section de code publie de nouvelles lectures de température et de LDR toutes les 30 secondes. Les températures relevées sont publiées sur le esp8266/température sujet. Les relevés de luminosité sont publiés sur le esp8266/ldr sujet.

if (now - lastMeasure > 30000) {
  lastMeasure = now;
  sensors.requestTemperatures(); 
  // Temperature in Celsius degrees
  temperatureString = String(sensors.getTempCByIndex(0));
  // Uncomment the next line for temperature in Fahrenheit degrees
  //temperatureString = String(sensors.getTempFByIndex(0));
  // Publishes Temperature values
  client.publish("esp8266/temperature", temperatureString.c_str());
  Serial.println("Temperature published");

  // Publishes LDR values
  client.publish("esp8266/ldr", String(analogRead(ldr)).c_str());
  Serial.println("LDR values published"); 
}

Noter: la température est publiée en degrés Celsius, mais vous pouvez décommenter la ligne suivante pour la température en degrés Fahrenheit :

temperatureString = String(sensors.getTempFByIndex(0));

Détection de mouvement

Lorsqu’un mouvement est détecté, il appelle le détecteMouvement() fonction, publie le message « MOTION DETECTED! » sur le esp8266/mouvement sujet, et démarre un minuteur :

void detectsMovement() {
  Serial.println("MOTION DETECTED!");
  client.publish("esp8266/motion", "MOTION DETECTED!");
  previousTime = millis();
  startTimer = true;
}

Si aucun mouvement n’est détecté pendant plus de 10 secondes, un nouveau message est publié dans la esp8266/mouvement avec le texte « Pas de mouvement »:

 // After 10 seconds have passed since motion was detected, publishes a "No motion" message
if ((now - previousTime > 10000) && startTimer) { 
  client.publish("esp8266/motion", "No motion");
  Serial.println("Motion stopped");
  startTimer = false;
}

Ce sont les principales sections de code dont vous devez vous soucier. Vous pouvez modifier les messages, vous abonner à plus de sujets pour contrôler plus de sorties ou publier d’autres lectures de capteurs.

Tester la connexion

Téléchargez le code sur votre tableau. Après l’avoir téléchargé, et avec le Raspberry Pi exécutant votre application Node-RED et le courtier Mosquitto, ouvrez le moniteur série Arduino IDE à un débit en bauds de 115200 et voyez ce qui se passe en temps réel.

Ceci est utile pour vérifier si l’ESP8266 a établi une connexion réussie avec votre routeur et avec le courtier Mosquitto.

Création du flux Node-RED

Avant de créer le flux, vous devez avoir installé dans votre Raspberry Pi :

Importation du flux Node-RED

Pour importer le flux Node-RED fourni, rendez-vous dans Référentiel GitHub ou cliquez sur la figure ci-dessous pour voir le fichier brut et copiez le code fourni.

Ensuite, dans la fenêtre Node-RED, dans le coin supérieur droit, sélectionnez le menu et accédez à Importer > Presse-papiers.

Ensuite, collez le code fourni et cliquez sur Importer.

Voici le flux importé qui contrôle l’ESP8266 et affiche les relevés de capteur publiés.

Interface utilisateur Node-RED

Après avoir effectué toutes les modifications nécessaires, cliquez sur le Déployer bouton pour enregistrer toutes les modifications.

Maintenant, votre application Node-RED est prête. Pour accéder à l’interface utilisateur Node-RED et voir à quoi ressemble votre application, accédez à n’importe quel navigateur de votre réseau local et tapez :

http://Your_RPi_IP_address:1880/ui

Votre application doit ressembler à la figure suivante.

Lorsqu’un mouvement est détecté, il imprime le message « MOTION DETECTED! » dans le champ Statut PIR :

Conclusion

Voilà pour ce projet. Nous espérons que vous avez trouvé ce projet utile et que vous êtes en mesure d’intégrer le Multisensor Shield à votre propre système domotique à l’aide de Node-RED.

Si vous aimez ce projet, vous aimerez peut-être aussi nos autres projets :

Merci d’avoir lu.