Surveillance domotique intelligente pilotée par Alexa

Composants et fournitures

Composant	Quantité
Arduino UNO	1
Espressif ESP8266 ESP-01	1
Capteur DHT11 Température & Humidité (4 broches)	1
Contrôleur 4 canaux I2C ControlEverything.com	1
Capteur d'obstacle IR	1
Caméra	1
Fils de connexion (jumper wires)	1

Applications et services en ligne

Arduino IDE
Amazon Alexa Skills Kit
Amazon Alexa echosim.io
ThingSpeak API
Backendless
PushingBox

À propos de ce projet

Introduction

Dans le monde actuel, les gens passent plus de temps au travail que chez eux. Il y a donc un besoin de système de surveillance domestique où les gens peuvent connaître l'état de leur maison pendant qu'ils sont au travail. Ce serait encore mieux si l'on pouvait simplement demander à « quelqu'un » des nouvelles de sa maison pendant les heures de travail. Cela peut être accompli en utilisant Amazon Alexa comme assistant qui peut donner à l'utilisateur les informations nécessaires sur sa maison.

Pas seulement au travail, les utilisateurs peuvent connaître l'état de la maison n'importe où dans le monde tant qu'ils ont une connexion Internet et un appareil Amazon Alexa.

Les fonctions suivantes sont implémentées dans ce projet :

Contrôler les appareils domestiques comme le ventilateur et la lumière
Indiquer l'état des appareils
Indiquer les conditions météorologiques de la maison (température et humidité)
Envoyer un instantané de l'intérieur de la maison à l'utilisateur via Gmail lorsque requis
Envoyer des notifications en cas de :

Intrus (envoie aussi une photo)
Incendie
Invité (envoie aussi une photo)

ÉTAPE 1 : Programmation de l'Arduino et de l'ESP8266

Téléchargez l'IDE Arduino depuis le site officiel : arduino.cc

Ouvrez l'IDE Arduino et allez dans Fichier → Préférences → dans URL supplémentaire du gestionnaire de cartes, tapez : https://arduino.esp8266.com/stable/package_esp8266com_index.json

Allez dans Outils → Cartes → Gestionnaire de cartes → et installez le paquet esp8266 trouvé en dernier.

Pour programmer l'Arduino, branchez simplement le câble USB de l'Arduino à l'ordinateur et sélectionnez Arduino/Genuino UNO dans Outils → Cartes. Assurez-vous également de sélectionner les bons ports COM dans Outils (le numéro de port COM se trouve dans le Gestionnaire de périphériques). Écrivez le programme requis, compilez-le et cliquez sur Téléverser s'il n'y a pas d'erreurs.

Pour programmer l'ESP8266, faites la connexion comme indiqué dans le diagramme :

Surveillance domotique intelligente pilotée par Alexa

Connectez l'USB de l'Arduino à l'ordinateur. Dans Outils → Carte → sélectionnez Generic ESP8266 et sélectionnez aussi le bon port COM. Écrivez le programme requis, compilez-le et cliquez sur Téléverser s'il n'y a pas d'erreurs. Assurez-vous de connecter la broche RST de l'Arduino à GND (l'Arduino agit comme un programmateur pour l'ESP8266).

Dans ce projet, l'ESP8266 est programmé en premier, puis les connexions du circuit sont retirées. Ensuite, le circuit est reconnecté comme indiqué dans la figure nommée « Connexions du circuit ». Et ensuite l'Arduino est programmé.

ÉTAPE 2 : Configuration de thingspeak.com

Créez un compte sur thingspeak.com.

Nous utilisons les canaux dans ThingSpeak pour stocker les informations de contrôle des appareils et les acheminer vers l'Arduino/Alexa. Nous stockons également les valeurs de température et d'humidité dans les canaux. C'est comme un emplacement de stockage pour l'information.

Allez dans Canaux → Mes canaux et créez un nouveau canal. Donnez un nom et une description à vos canaux.

Dans notre projet, nous avons besoin de 8 canaux (vous pouvez faire le travail avec moins de canaux, mais ce sera un peu plus compliqué lors de la programmation). ThingSpeak a aussi une contrainte de temps lors de la mise à jour d'un canal. Il doit y avoir un intervalle de 10 à 15 secondes entre deux mises à jour successives d'un même canal.

Les huit canaux avec leurs valeurs et significations sont donnés ci-dessous :

Nom du canal (valeur1-signification, valeur2-signification, etc.) :

Contrôle appareil (0 - lumière ON, 1 - lumière OFF, 2 - ventilateur ON, 3 - ventilateur OFF)
État lumière (0 - lumière éteinte, 1 - lumière allumée)
État ventilateur (0 - ventilateur éteint, 1 - ventilateur allumé)
Humidité (valeur d'humidité)
Température (valeur de température)
Notification intrus (1 - alerte intrus)
Notification incendie (1 - alerte incendie)
Notification invité (1 - alerte invité)

Quand vous cliquez sur un canal, vous pouvez voir son ID de canal et ses clés API d'écriture dans l'onglet Clés API. L'ID de canal est requis pour obtenir l'information/valeur dans le canal. Et la clé d'écriture est requise pour stocker une valeur dans le canal.

Requête HTTP pour mettre à jour un canal :

https://api.thingspeak.com/update?api_key=<clé écriture>&field1=<valeur>

<clé écriture> est remplacé par les clés d'écriture correspondantes du canal et la valeur peut être (0/1 dans le cas du contrôle d'appareil ou valeurs temp/humidité).

Requête HTTP pour lire une valeur depuis un canal :

https://api.thingspeak.com/channels/<channel id>/field/field1/last.html

<channel id> est remplacé par l'ID de canal particulier du canal dont nous voulons lire.

ÉTAPE 3 : Le Programme

Le programme est divisé en 3 parties :

A) Programme pour Arduino : le programme pour Arduino est très simple. Il reçoit les données de l'ESP8266 en série et, en fonction des données reçues, contrôle les appareils. Plus d'informations sur le programme se trouvent dans les commentaires du programme lui-même.

B) Programme pour ESP8266 : le programme pour ESP8266 implique 3 choses :

Mise à jour de la température et de l'humidité via requête HTTP :

client.print(String("GET ") + "/update?key=<write key>&field1=" + humidity + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); // update humidity
client.print(String("GET ") + "/update?key=<write key>&field1=" + temperature + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); // update temperature

Le <write key> est remplacé par la clé d'écriture correspondante trouvée dans le canal ThingSpeak pour l'humidité et la température respectivement. Et host est api.thingspeak.com.

Téléchargez la bibliothèque DHT depuis : GitHub Adafruit DHT

Lecture depuis les canaux correspondants de ThingSpeak et contrôle des appareils basé sur les valeurs obtenues :

client.print(String("GET ") + "/channels/<channel id>/field/field1/last.html HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n");

Où <channel id> est remplacé par l'ID de canal correspondant trouvé dans ThingSpeak.

Envoi d'alerte en cas de température élevée via PushingBox :

String host1 = "api.pushingbox.com";
client.print(String("GET ") + "/pushingbox?devid=<your dev id> HTTP/1.1\r\n" + "Host: " + host1 + "\r\n" + "Connection: close\r\n\r\n");

Où <your dev id> est remplacé par votre device ID dans PushingBox.

ÉTAPE 4 : Configuration du LinkIt Smart 7688 Duo et de la webcam

Dans ce projet, la webcam et le LinkIt Smart 7688 Duo sont utilisés pour capturer la photo requise et l'envoyer à l'utilisateur. Vous pouvez aussi utiliser un module caméra Arduino et l'interfacer avec l'Arduino ou utiliser n'importe quelle caméra IP.

Appuyez et maintenez le bouton WiFi sur le LinkIt Smart 7688 pendant 20 secondes pour réinitialiser la carte. Ensuite, après la réinitialisation des paramètres WiFi, vous pourrez voir son nom de point d'accès dans les connexions réseau sans fil. Connectez maintenant l'ordinateur à ce réseau.

Après vous être connecté, ouvrez le navigateur et tapez 192.168.100.1 dans la barre d'adresse. Vous pourrez voir son portail.

Définissez un mot de passe pour vous connecter à son portail.

Après vous être connecté, allez dans l'onglet Réseau et sélectionnez le mode Station (nous en avons besoin pour accéder à Internet) et connectez-le à votre réseau WiFi et appuyez sur Configurer et redémarrer.

Après le redémarrage de la carte, une adresse IP locale lui sera attribuée. Trouvez l'adresse en utilisant n'importe quel outil IP ou le portail de votre routeur. Dans mon cas, c'était 192.168.1.4.

Tapez maintenant l'adresse IP locale dans la barre d'adresse du navigateur. Assurez-vous que l'ordinateur est connecté au même réseau que le LinkIt Smart. Il vous sera demandé de vous connecter à nouveau.

Pour activer le streaming depuis la webcam, vous devez activer MJPG Streamer (mjpg-streamer est une application en ligne de commande qui copie des images JPEG depuis un ou plusieurs plugins d'entrée vers plusieurs plugins de sortie). Pour ce faire, dans le portail, allez à l'emplacement OpenWrt en haut à droite. Vous devrez vous connecter à nouveau.

Après vous être connecté, allez dans l'onglet Service et cochez « activer MJPG streamer » et attribuez un numéro de port pour ce service. J'ai attribué 4440. Cliquez sur Enregistrer et Appliquer.

Après la configuration, vous pouvez connecter votre webcam au port hôte USB du LinkIt Smart 7688 Duo via un câble OTG.

Pour voir le flux, ouvrez le navigateur et tapez <adresse IP locale>:<port> dans la barre d'adresse. Dans mon cas, c'est 192.168.1.4:4400.

Pour prendre un instantané, tapez la commande <IP locale>:<port>?action=snapshot

Maintenant, cette image est disponible localement mais nous devons la rendre disponible au service PushingBox. Pour y parvenir, nous devons faire du transfert de port (port forwarding). Le transfert de port peut être fait dans le portail du routeur. Le processus est différent pour chaque routeur. Faites une recherche Google pour savoir comment faire du port forwarding pour votre routeur spécifique. C'est généralement disponible sous le service NAT.

Après avoir fait le port forwarding, vous pouvez accéder à ce port (par exemple 4440) depuis votre IP externe. L'IP externe peut être trouvée en tapant « what's my ip » dans Google.

Vous devez mettre cette adresse, c'est-à-dire https://<IP externe>:<port>?action=snapshot dans PushingBox (expliqué à l'étape suivante) pour que PushingBox puisse accéder à cette image, l'attacher au mail et vous l'envoyer quand requis.

Vous pouvez aussi stocker l'image sur une carte SD car le LinkIt Smart 7688 Duo dispose aussi d'un emplacement pour carte SD pour stocker des informations.

Plus d'informations à ce sujet : Documentation MediaTek

ÉTAPE 5 : Configuration de PushingBox

PushingBox est utilisé pour envoyer des notifications sur les différentes alertes du projet vers Gmail.

Connectez-vous à PushingBox avec un compte Google : pushingbox.com

Allez dans Mes services → Ajouter un service. Il y a beaucoup de services parmi lesquels choisir comme Gmail, Twitter, notification push pour Android, etc.

Sélectionnez Gmail (car nous avons besoin d'envoyer une photo en pièce jointe) et remplissez la configuration du nom Gmail appropriée et l'ID Gmail de l'utilisateur à qui l'alerte doit être envoyée.

Allez dans Mes scénarios et créez un nouveau scénario. Donnez un nom au scénario (ex : ALERTE) et ajoutez le service créé précédemment.

Écrivez un objet et un corps de mail appropriés et entrez l'URL pour prendre la capture d'écran de la webcam pour joindre la photo. Créez différents scénarios pour différentes alertes.

API pour exécuter un scénario PushingBox : https://api.pushingbox.com/pushingbox?devid=<device id>

ÉTAPE 6 : Création de la Skill Alexa avec Backendless

Backendless est utilisé pour créer la skill Alexa. C'est de la programmation par glisser-déposer simple utilisée pour créer une skill Alexa (ou n'importe quel programme) qui peut être accédée via l'API Backendless.

Créez un compte sur Backendless : backendless.com

Connectez-vous à votre compte Backendless. Cliquez sur Créer une application et donnez un nom à votre application.
Cliquez sur l'icône Logique métier dans la barre d'icônes à gauche. Vous verrez l'écran SERVICES API.
Cliquez sur l'icône « + » pour créer un nouveau service. Assurez-vous de sélectionner CODELESS dans la popup « Nouveau service ». Entrez « AlexaService » pour le nom du service. Cliquez sur le bouton ENREGISTRER :

Backendless crée le Service API et vous invitera à créer une méthode pour le service. Ce sera la méthode qui traitera les requêtes d'Alexa. Entrez « handleRequest » pour le nom de la méthode. Assurez-vous de sélectionner POST pour l'opération REST, et déclarez un argument avec le nom « req » et le type « Any Object » comme indiqué ci-dessous :

Backendless crée un espace réservé pour la logique sans code de la méthode. Cliquez sur le bouton ÉDITER pour commencer à basculer vers le Concepteur de logique sans code.

Dans le bloc de fonction créé, cliquez sur la zone qui dit « doSomething » et changez-la en « sendAlexaResponse ». Cette fonction est utilisée pour faire dire quelque chose à Alexa qui peut être passé comme argument. Cliquez sur le bouton SAUVEGARDER pour que la fonction soit sauvegardée :

Cliquez sur l'icône d'engrenage située dans le bloc violet à côté du mot « Function ». Ajoutez deux arguments en glissant les blocs d'entrée comme indiqué dans l'image ci-dessous. Attribuez les noms des arguments comme « whatToSay » et « waitForResponse ». Remarquez qu'au fur et à mesure que vous ajoutez des arguments, la zone Blocs de contexte est automatiquement peuplée avec les blocs représentant les valeurs des arguments :

Modifiez la logique de la fonction pour qu'elle ressemble à l'image ci-dessous. Pour les blocs « Créer des objets », utilisez l'icône d'engrenage pour changer le nom des propriétés de l'objet. N'oubliez pas de sauvegarder votre travail en cliquant sur le bouton SAUVEGARDER.

Maintenant que la fonction personnalisée est construite, revenez à la méthode handleRequest du service AlexaService. Cliquez sur la catégorie Fonctions personnalisées dans la barre d'outils à gauche et glissez le bloc sendAlexaResponse pour le connecter avec le connecteur de retour de votre méthode de service :

Les étapes ci-dessus peuvent aussi être trouvées sur leur site web : Partie 1 et Partie 2

Cliquez sur le nœud « Ajouter nouveau » sous Fonctions dans la section NAVIGATEUR. Dans le bloc de fonction créé, cliquez sur la zone qui dit « doSomething » et changez-la en « getIntentName »

Modifiez les blocs pour que la fonction ressemble à ceci :

Cela permettra d'obtenir le nom de l'intention basé sur les énoncés d'exemple. Retournez aux services API → → handle request dans la section NAVIGATEUR. Les variables et la logique sont créées depuis la section Système. Créez les variables suivantes :

Ensuite, nous stockons le nom de l'intention dans la variable requête. Et puis nous comparons avec les intentions. Par exemple, si la requête est « introduction », alors la variable réponse est définie sur « salut ! Je peux contrôler.... » et cette réponse est lue à haute voix par Alexa à la fin.

Modifiez le bloc comme indiqué ci-dessous :

Si la requête est l'intention LightsOn, alors nous mettons à jour le canal ThingSpeak à '0' en utilisant une requête HTTP GET et en même temps nous mettons à jour l'état de l'appareil (1/0 selon On/Off). La même chose est répétée pour LightsOff, FanOn et FanOff.

Pour la météo, nous lisons depuis les canaux Température et Humidité et stockons le résultat dans la variable réponse. Comme le canal ne donne que des valeurs, nous ajoutons du texte pour rendre la réponse significative :

Pour l'instantané du salon, nous exécutons le scénario PushingBox :

Pour l'état des appareils, nous lisons les informations depuis le canal d'état de ThingSpeak :

Pour les notifications et alertes, nous lisons depuis les canaux d'alerte (incendie, intrus et invité) :

En fonction des valeurs que nous obtenons du champ de notification, les messages d'alerte correspondants sont stockés dans la variable respond0. S'il n'y a pas de notification, aucun message n'est stocké.

Une fois la notification lue à haute voix, '0' est mis à jour dans les canaux de notification pour qu'Alexa ne relise pas la même notification. Puis à la fin, en fonction de la requête, la variable respond0/respond est lue à haute voix.

PS : Après avoir créé le modèle requis dans Backendless, cliquez sur « Déployer le modèle » en haut à droite de l'écran sans code pour déployer le modèle.

ÉTAPE 7 : Configuration de la Skill Alexa dans la Console Développeur Amazon

Allez sur la console développeur Amazon et connectez-vous avec un compte Amazon. developer.amazon.com

Allez dans la console développeur et cliquez sur l'onglet ALEXA. Cliquez sur « Alexa Skills Kit - Commencer ».

Créez un type de skill personnalisé, donnez un nom et un nom d'invocation à la skill.

Les intentions respectives et les énoncés d'exemple sont donnés dans le code ci-dessous.

{
  "languageModel": {
    "intents": [
      { "name": "AMAZON.CancelIntent", "samples": [] },
      { "name": "AMAZON.HelpIntent", "samples": [] },
      { "name": "AMAZON.StopIntent", "samples": [] },
      { "name": "Camera", "samples": [ "please send a snapshot of my living room", "please send a snapshot of my home", "please send a photo of my living room", "please send a photo of my home" ], "slots": [] },
      { "name": "FanOff", "samples": [ "turn off Fan", "switch off Fan", "turn off the Fan", "switch off the Fan" ], "slots": [] },
      { "name": "FanOn", "samples": [ "turn on Fan", "switch on Fan", "turn on the Fan", "switch on the Fan" ], "slots": [] },
      { "name": "Introduction", "samples": [ "what you can do", "what can you do", "what can you do for me" ], "slots": [] },
      { "name": "LightsOff", "samples": [ "turn off lights", "switch off lights", "turn off the lights", "switch off the lights" ], "slots": [] },
      { "name": "LightsOn", "samples": [ "turn on lights", "switch on lights", "turn on the lights", "switch on the lights" ], "slots": [] },
      { "name": "Notification", "samples": [ "what are my notifications", "is there any notifications", "is there any updates", "read out my notifications" ], "slots": [] },
      { "name": "Status", "samples": [ "what is my device status", "what is the status of my devices" ], "slots": [] },
      { "name": "Weather", "samples": [ "what is the weather condition of my home", "what is the weather of my home", "what is the weather", "what is the temperature of my home", "what is the temperature" ], "slots": [] }
    ],
    "invocationName": "my home"
  }
}

Dans l'onglet Configuration, sélectionnez HTTPS comme type de point de terminaison de service. Remplissez l'URL par défaut avec l'URL API de Backendless.

Sélectionnez la 2ème option dans Certificat pour le point de terminaison par défaut dans le certificat SSL. Vous pouvez aussi tester la skill en utilisant le simulateur de test.

Après la fin du test, vous pouvez publier la skill avec les informations de publication requises.

ÉTAPE 8 : Configuration finale et finition !

Faites les connexions du circuit comme indiqué ci-dessous :

Parfois, l'ESP8266 peut mal fonctionner à cause d'un courant insuffisant. Donc, bien que non mentionné dans le circuit, il est recommandé d'alimenter l'ESP8266 depuis une source 3,3 V séparée. Si vous utilisez une power bank, assurez-vous de réduire la tension de 5 V à 3,3 V en utilisant un régulateur de tension 3,3 V.

Téléversez le programme sur l'ESP8266 et l'Arduino. J'ai montré la connexion à une ampoule, la même chose peut être étendue à un ventilateur ou n'importe quel appareil.

Finalement, utilisez Amazon Echo ou echosim.io pour tester votre skill.

Vous devez activer la skill en utilisant le nom d'invocation (comme dans mon cas - « my home »). Parfois, cela ne fonctionnera pas si elle est utilisée sans nom d'invocation, comme je l'ai montré plusieurs fois dans ma vidéo.

J'espère que vous avez apprécié ce tutoriel !

Merci !

Code

Smart_bell_ESP8266.ino Arduino

Code pour ESP8266 pour obtenir une alerte sur l'intrus et l'invité

/* * This sketch is implementation of smart bell and home security * */
#include <ESP8266WiFi.h>
#include <String.h>
//------------------------------------------
// variables
//------------------------------------------
int intruder = 0, guest = 2; // pin 0 as intruder alert and pin 2 as guest alert
const char* ssid = "SSID"; // your SSID of WIFI
const char* password = "password"; // password of Wifi
//--------------------------------------------
const char* host = "api.thingspeak.com";
void setup() {
  Serial.begin(115200);
  delay(10);
  // We start by connecting to a WiFi network
  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  /* Explicitly set the ESP8266 to be a WiFi-client, otherwise, it by default, would try to act as both a client and an access-point and could cause network-issues with your other WiFi-devices on your WiFi-network. */
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}
int value = 0;
int x, y = 0, z, k = 0;
void loop() {
  delay(1000);
  ++value;
  Serial.print("connecting to ");
  Serial.println(host);
  // Use WiFiClient class to create TCP connections
  WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(host, httpPort)) {
    Serial.println("connection failed");
    return;
  }
  Serial.print("Requesting URL: ");
  //============================================================================================================
  // intruder alert
  //============================================================================================================
  x = digitalRead(intruder);
  // Serial.println(x);
  if (x == 0) { y = 0; }
  if (x == 1 && y == 0) {
    Serial.println("Sending Alert Pls Wait.....");
    delay(1000);
    String host1 = "api.pushingbox.com";
    client.print(String("GET ") + "/pushingbox?devid=<deviceID_intruderAlert> HTTP/1.1\r\n" + "Host: " + host1 + "\r\n" + "Connection: close\r\n\r\n"); // executing pushing box api
    client.print(String("GET ") + "/update?api_key=<write_key_intruderAlert>&field1=1 HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); // updating intruder notification
    delay(1000);
    y = 1;
  }
  //============================================================================================================
  // End of intruder alert
  //============================================================================================================
  //============================================================================================================
  // guest alert
  //============================================================================================================
  long t1;
  z = digitalRead(guest);
  if (z == 0 && (millis() >= t1 + 300000)) // wait for 5 min to avoid multiple alert sending due to multiple door bell press
  { k = 0; }
  if (x == 1 && k == 0) {
    t1 = millis(); // storing current time stamp in t1
    Serial.println("Sending Alert Pls Wait.....");
    delay(1000); // delay for sending alert and switch debouncing
    String host1 = "api.pushingbox.com";
    client.print(String("GET ") + "/pushingbox?devid=<deviceID_guestAlert> HTTP/1.1\r\n" + "Host: " + host1 + "\r\n" + "Connection: close\r\n\r\n"); // executing pushing box api
    client.print(String("GET ") + "/update?api_key=<write_key_guestAlert>&field1=1 HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); // updating guest notification
    delay(1000);
    k = 1;
  }
  //============================================================================================================
  // End of guest alert
  //============================================================================================================
  unsigned long timeout = millis();
  while (client.available() == 0) {
    if (millis() - timeout > 5000) {
      Serial.println(">>> Client Timeout !");
      client.stop();
      return;
    }
  }
  // Serial.println("closing connection");
}

Home_monitor_arduino.ino Arduino

Code pour Arduino pour contrôler les appareils

// This sketch in the implementation of home automation
#include <SoftwareSerial.h> // import the serial library
#include <String.h>
//-----------------------------------------
// pin definitions
//-----------------------------------------
#define Light 2 // pin 2 to control light
#define fan 3 // pin 3 to control fan
//------------------------------------------
// variables
//------------------------------------------
char e;
int p = 0, q = 0; // these variables prevent switching ON/OFF of already turned ON/OFF devices
SoftwareSerial home_monitor(10, 11); // RX, TX
char control_data; // the data transmitted over Bluetooth
void setup() {
  // put your setup code here, to run once:
  home_monitor.begin(115200);
  Serial.begin(9600);
  pinMode(13, OUTPUT);
}
void loop() {
  // put your main code here, to run repeatedly:
  if (home_monitor.available()) {
    control_data = home_monitor.read(); // getting control information from ESP8266 serially
    e = control_data;
    Serial.print(control_data);
    //============================================================================================================
    // Device Control
    //============================================================================================================
    // Performing required operations based on the value of channel
    //-------------------------------------------------------------
    // LIGHT
    //-------------------------------------------------------------
    if (e == '0' && p == 0) // Light ON
    {
      digitalWrite(Light, LOW);
      p = 1;
    }
    if (e == '1' && p == 1) // Light off
    {
      digitalWrite(Light, HIGH);
      p = 0;
    }
    //-------------------------------------------------------------
    // Heater (Fan)
    //-------------------------------------------------------------
    if (e == '2' && q == 0) {
      digitalWrite(fan, HIGH);
      q = 1;
    }
    if (e == '3' && q == 1) {
      digitalWrite(fan, LOW);
      q = 0;
    }
  }
}

Home_Monitor_ESP8266.ino Arduino

Code pour ESP8266 pour mettre à jour l'humidité et la température dans ThingSpeak et aussi récupérer les informations de contrôle depuis ThingSpeak

/* * This sketch updates weather information in thingspeak.com and also retrieve control information from thingspeak.com * It send the control information to arduino serially */
#include <ESP8266WiFi.h>
#include <String.h>
#include "DHT.h" // including the library of DHT11 temperature and humidity sensor
#define DHTTYPE DHT11 // DHT 11
#define dht_dpin 2 // define GPIO2 as data input
DHT dht(dht_dpin, DHTTYPE);
//------------------------------------------
// variables
//------------------------------------------
// dht DHT;
char c, e; // stores the bytes coming from the server
float temp, h; // stores float value of temp and humidity
String humidity, temperature, line; // stores string value of temp and humidity
int co = 0; // control the sending of Alert
const char* ssid = "SSID"; // your SSID of WIFI
const char* password = "password"; // password of Wifi
//--------------------------------------------
const char* host = "api.thingspeak.com";
void setup() {
  dht.begin();
  Serial.begin(115200);
  delay(10);
  // We start by connecting to a WiFi network
  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  /* Explicitly set the ESP8266 to be a WiFi-client, otherwise, it by default, would try to act as both a client and an access-point and could cause network-issues with your other WiFi-devices on your WiFi-network. */
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}
int value = 0;
void loop() {
  delay(1000);
  ++value;
  Serial.print("connecting to ");
  Serial.println(host);
  // Use WiFiClient class to create TCP connections
  WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(host, httpPort)) {
    Serial.println("connection failed");
    return;
  }
  Serial.print("Requesting URL: ");
  //============================================================================================================
  // Mini Weather Station
  //============================================================================================================
  h = dht.readHumidity(); // reads humidity and temperature
  temp = dht.readTemperature();
  if (temp < 50.0) { co = 0; }
  if (temp >= 50.0 && co == 0) // send alert if temperature is above 50 degrees and co is used to avoid multiple alert sending
  {
    Serial.println("Sending Alert please wait.......");
    delay(1000);
    String host1 = "api.pushingbox.com";
    client.print(String("GET ") + "/pushingbox?devid=<deviceID_fireAlert> HTTP/1.1\r\n" + "Host: " + host1 + "\r\n" + "Connection: close\r\n\r\n"); // pushingbox api to send alert
    delay(1000);
    client.print(String("GET ") + "/update?key=<write_key_fireAlert>&field1=1 HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); // updating thingspeak fire alert channel
    co = 1;
  }
  humidity = String(h);
  temperature = String(temp);
  Serial.println(h);
  Serial.println(temp);
  client.print(String("GET ") + "/update?key=<write_key_humidity>&field1=" + humidity + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); // update humidity in thingspeak channel
  client.print(String("GET ") + "/update?key=<write_key_temperature>&field1=" + temperature + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); // update temperature in thingspeak channel
  //============================================================================================================
  // End of Weather Station
  //============================================================================================================
  //============================================================================================================
  // Sending Control info to arduino Serially
  //============================================================================================================
  // This will send the request to the server
  client.print(String("GET ") + "/channels/<channelID_control>/field/field1/last.html HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); // get information about device control
  unsigned long timeout = millis();
  while (client.available() == 0) {
    if (millis() - timeout > 5000) {
      Serial.println(">>> Client Timeout !");
      client.stop();
      return;
    }
  }
  // Read all the lines of the reply from server and print them to Serial
  while (client.available()) {
    String line = client.readStringUntil('\r');
  }
  Serial.print(line); // received by arduino serially
  // Serial.println("closing connection");
}

Schémas

Éclairage intelligent : Allumez votre maison à votre arrivée avec Arduino et iPhone Chargeur Solaire Portable à Suivi Solaire avec Arduino et Servomoteur

Processus de fabrication

impression en 3D

Système de contrôle d'automatisation

Technologie industrielle