Pirater un capteur de mouvement PIR avec un ESP8266

Dans ce projet, nous allons modifier un capteur de mouvement commercial (alimenté par une tension secteur) avec un ESP8266 pour enregistrer les données chaque fois qu’un mouvement est détecté. Les données seront envoyées à Node-RED en utilisant le protocole de communication MQTT. L’ESP8266 sera alimenté via le fil de sortie de phase du capteur de mouvement à l’aide du convertisseur AC/DC HLK-PM03.

Conditions préalables

Avant de poursuivre ce projet, nous vous recommandons de consulter les ressources suivantes :

Pièces requises :

Voici une liste des pièces nécessaires pour ce projet :

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 !

Aperçu du projet

Ce projet est divisé en trois parties :

1. Construire le circuit
2. Écrire et télécharger le code ESP8266
3. Création du flux Node-RED

L’image suivante montre un aperçu de haut niveau du projet que nous allons construire.

Capteur de mouvement

Nous allons pirater un capteur de mouvement commercial qui a suffisamment d’espace pour mettre un ESP-01 et le module convertisseur AC/DC HLK-PM03 à l’intérieur. Nous avons acheté notre détecteur de mouvement pour 5 $ dans un magasin local.

Lorsque le capteur PIR détecte un mouvement, il y a de la puissance sortant du fil chaud rouge qui peut allumer une lampe ou un appareil. Votre détecteur de mouvement doit avoir un schéma de câblage similaire sur le couvercle ou imprimé dans le manuel d’instructions.

Dans notre projet, la charge de sortie du capteur de mouvement est la HLK-PM03 CA/CC module convertisseur qui alimentera l’ESP8266.

En rapport: Alimentez ESP8266 avec une tension alternative à l’aide du convertisseur HLK-PM03

Le convertisseur AC/DC du module HLK-PM03 fournit 3,3 V à partir de 110 VAC ou 220 VAC. Cela le rend parfait pour alimenter l’ESP8266 à partir de la tension secteur.

En résumé, lorsqu’un mouvement est détecté, l’alimentation atteint l’ESP8266. L’ESP8266 peut exécuter des tâches tant que le capteur de mouvement est déclenché.

Vous devrez peut-être ajuster la durée pendant laquelle le capteur reste allumé, afin que votre ESP8266 ait suffisamment de temps pour exécuter ses tâches. Le capteur doit avoir un bouton pour régler l’heure (et un autre pour régler la luminosité).

Dans notre exemple, chaque fois que l’ESP8266 s’allume, il exécute une esquisse qui envoie des informations à Node-RED via MQTT pour enregistrer la date et l’heure auxquelles le mouvement a été détecté.

Au lieu d’envoyer des informations à Node-RED, vous pouvez exécuter d’autres tâches, telles que :

Ces tâches peuvent être facilement effectuées en utilisant IFTTT.

1. Construire le circuit

Le diagramme schématique suivant montre le circuit pour ce projet.

Retirez le couvercle de votre capteur de mouvement PIR. À l’intérieur, il devrait y avoir trois fils : entrer en phase, neutre, et éliminer progressivement. Suivez ces étapes:

• Fil entrer en phase (marron) et neutre (bleu) au détecteur de mouvement
• Fil neutre (bleu) et éliminer progressivement (rouge) à l’entrée HLK-PM03

Il est recommandé d’ajouter un fusible à fusion lente juste avant le convertisseur HKL-PM03 et un condensateur à la sortie.

Noter: si vous utilisez un ESP8266 qui est toujours sous tension avec le HLK-PM03, nous vous recommandons d’utiliser ce circuit de protection.

Le HLK-PM03 délivre 3,3 V et GND. Ceux-ci sont connectés à la broche ESP8266 VCC et GND pour l’alimenter.

Nous avons construit le circuit HLK-PM03 et ESP8266 sur un petit protoboard pour économiser de l’espace. Nous avons également ajouté des broches d’en-tête pour placer l’ESP8266-01. De cette façon, vous pouvez brancher et débrancher la carte chaque fois que vous devez télécharger un nouveau code.

Lecture recommandée: Guide de référence des GPIO et brochage ESP8266

2. Écriture et téléchargement du code ESP8266

Nous allons programmer l’ESP8266 à l’aide de l’IDE Arduino. Afin de télécharger du code sur votre ESP8266, vous devez d’abord installer le module complémentaire ESP8266, si vous ne l’avez pas déjà fait (Installer la carte ESP8266 dans l’IDE Arduino).

Vous devrez également installer le PubSubClient bibliothèque pour créer un client MQTT avec l’ESP8266. La bibliothèque PubSubClient 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).

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

Ensuite, copiez le code suivant dans votre IDE Arduino, mais ne le téléchargez pas encore. Vous devez apporter quelques modifications pour que cela fonctionne pour vous.

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  
*********/

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

// Replace with your SSID, password and MQTT broker IP address
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";
const char* mqtt_server = "REPLACE_WITH_YOUR_MQTT_BROKER_IP";
//For example
//const char* mqtt_server = "192.168.1.144";

WiFiClient espClient;
PubSubClient client(espClient);

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(".");
  }

  randomSeed(micros());

  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

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");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}

void setup() {
  pinMode(BUILTIN_LED, OUTPUT);     // Initialize the BUILTIN_LED pin as an output
  digitalWrite(BUILTIN_LED, HIGH);
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  while (!client.connected()) {
    reconnect();
  }
  Serial.print("Motion Detected");
  // Publish MQTT message
  String mqttMessage = "Motion Detected";  
  client.publish("esp/pir", mqttMessage.c_str());
}

void loop() {
  client.loop();
}

Afficher le code brut

Inclure vos informations d’identification réseau

Vous devez inclure vos informations d’identification réseau dans les lignes suivantes.

const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

Incluez l’adresse IP de votre courtier MQTT

Vous devez également inclure l’adresse IP de votre courtier MQTT.

const char* mqtt_server = "REPLACE_WITH_YOUR_MQTT_BROKER_IP"; 

Pour trouver l’adresse IP de votre courtier MQTT, vous devez d’abord la configurer. Nous utilisons le courtier Mosquitto hébergé sur un Raspberry Pi. Suivez les ressources suivantes si vous ne l’avez pas encore fait :

Comment fonctionne le code

Le code est très simple. Il publie simplement un message sur un sujet. À des fins de test, nous allumons également la LED intégrée à chaque fois que l’ESP8266 est alimenté. Cela se fait sur le mettre en place() car il ne sera exécuté qu’une seule fois (lorsqu’un mouvement est détecté et pendant que l’ESP8266 est alimenté).

void setup() {
   pinMode(BUILTIN_LED, OUTPUT); // BUILTIN_LED pin as an output
   digitalWrite(BUILTIN_LED, HIGH);
   Serial.begin(115200);
   setup_wifi();
   client.setServer(mqtt_server, 1883);
   while (!client.connected()) {
     reconnect();
   }
   Serial.print("Motion Detected");
   // Publish MQTT message
   String mqttMessage = "Motion Detected";  
   client.publish("esp/pir", mqttMessage.c_str());
}

Téléchargement du code

Après avoir modifié le code avec vos informations d’identification réseau, vous pouvez le télécharger sur votre carte. Pour télécharger le code sur l’ESP8266-01, vous avez besoin d’un adaptateur série ou un Programmeur FTDI.

3. 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é. Il reçoit les messages ESP8266 MQTT et enregistre l’heure chaque fois qu’un mouvement est détecté.

Nous avons également ajouté deux boutons pour effacer et actualiser le journal.

Tableau de bord 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 au tableau de bord 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

Manifestation

Maintenant, vous pouvez tester votre projet. Chaque fois qu’un mouvement est détecté, l’ESP8266 s’allume et envoie un message via MQTT à Node-RED.

Si vous accédez à votre tableau de bord Node-RED, vous pouvez voir tous les journaux de détection de mouvement. Votre application doit ressembler à la figure suivante.

Le tableau de bord affiche la dernière détection de mouvement et tous les journaux précédents. Vous avez également la possibilité d’actualiser le journal et de l’effacer. Veuillez noter que l’effacement du journal est irréversible.

Conclusion

Ce projet a montré comment vous pouvez pirater un capteur de mouvement commercial avec un ESP8266 pour le rendre plus intelligent. Vous pouvez facilement alimenter l’ESP8266 avec le HLK-PM03 à partir de la tension secteur et créer un circuit compact pouvant s’adapter au capteur de mouvement.

Chaque fois qu’un mouvement est détecté, l’ESP8266 est alimenté et exécute une tâche. Dans ce cas, il publie un message MQTT pour enregistrer l’heure à laquelle le mouvement a été détecté, mais vous pouvez facilement écrire du code pour exécuter toute autre tâche.

Nous espérons que vous avez trouvé ce projet utile. Si vous avez aimé ce projet, vous pourriez également être intéressé par l’une des ressources suivantes :