Interrupteur WiFi pour appareils électroménagers avec ESP8266

Découvrez comment construire votre propre interrupteur WiFi avec le module ESP et comment contrôler n'importe quel appareil de votre endroit préféré.

Que sont les commutateurs WiFi ?

Nous vivons aujourd'hui à l'ère de l'Internet des objets, et les interrupteurs Wi-Fi en constituent la base. Ce sont des appareils qui permettent d'allumer, d'éteindre ou de moduler l'intensité d'appareils domestiques comme les lumières, les ventilateurs, etc., à distance ou de manière autonome, grâce à nos téléphones portables, notre voix, la température ambiante ou même les prévisions météorologiques.

Comment fonctionnent-ils ?

Elles reposent sur une communication sans fil (communément appelée WiFi) qui leur permet de se connecter à Internet et de traiter des données, afin de pouvoir agir en fonction de certaines conditions définies par l'utilisateur.

Exigences relatives à l'application :

• Module ESP8266 (ESP-01)
• carte PCB
• planche à pain
• câbles de câblage
• Compte Ubidots
• Arduino nano

1. Schéma :

Matériels:

3 résistances de 1 kΩ, 1/4 W

2 résistances de 470 ohms, 1/2 W

1 connecteur femelle double en ligne (U3)

1x MOC3010 (Opto-triac)

1x Triac BTA24

1 condensateur de 100 nF 400 V

1 alimentation Hi-Link 3,3 V

1 bornier 2 broches

1 bornier 3 broches

PCB : Lien pour télécharger le fichier Gerber !

Circuit imprimé fabriqué avec PCBGOGO (industrie de la fabrication de circuits imprimés)

2. Création d'un périphérique et d'une variable Ubidots .

Rendez-vous dans la section Appareil de votre Ubidots et créez un nouvel appareil appelé « wifiswitch ».

Dans votre appareil « wifiswitch », créez une variable appelée « light ».

3. Création Dashboard et des widgets Ubidots .

Une fois notre appareil et notre variable créés, nous pouvons créer un dashboard et un widget pour contrôler la lumière depuis une dashboard . Pour créer un nouveau dashboard , appuyez sur « Données >Dashboard ». Appuyez ensuite sur l’icône « + » et configurez le dashboard selon vos besoins.

Créez maintenant un widget de contrôle pour définir l'état de l'ampoule associée à la variable « lumière ». Pour ce faire, sélectionnez l'icône « + » située en haut à droite de la page. Choisissez ensuite « Interrupteur » comme type de widget, sélectionnez la variable à contrôler et configurez le widget selon vos besoins.

Vous êtes alors prêt à programmer et à tester votre projet.

4. Programmation avec l'IDE Arduino.

1. Si ce n'est pas déjà fait, téléchargez l' IDE Arduino.

1a. Ouvrez l'IDE Arduino et sélectionnez Fichiers -> Préférences

1b. Ajoutez l'URL ci-dessous dans le « URL supplémentaires du gestionnaire de tableaux » . Vous pouvez ajouter plusieurs URL en les séparant par des virgules.

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

2. Ouvrez et installez la carte ESP8266 dans le Gestionnaire de cartes : Outils -> Carte -> Gestionnaire de cartes

2a. Vous pouvez facilement trouver la carte en tapant « ESP8266 » dans la barre de recherche.

3. Sélectionnez maintenant la carte ESP8266 générique dans le menu Outils -> Carte

4. Définissez ou vérifiez le port de votre PC avec lequel le périphérique communique. Allez dans Outils -> Port : -> Sélectionnez le port

4b. Assurez-vous que la vitesse de chargement de votre IDE est de 115 200 en allant dans Outils -> Vitesse de chargement -> 115 200.

5. Téléchargez la bibliothèque Ubidots si ce n'est pas déjà fait. Cliquez ensuite sur Croquis → Inclure une bibliothèque → Ajouter une bibliothèque .ZIP et sélectionnez la bibliothèque Ubidots

Si le téléchargement est réussi, vous recevrez la réponse suivante : « Bibliothèque ajoutée à vos bibliothèques. »

8. Fermez puis rouvrez l'IDE Arduino.

Programmation de l'ESP8266 :

Une fois votre ESP8266 configuré, vous pouvez commencer à publier et à recevoir des données depuis/vers Ubidots afin de contrôler le commutateur Wi-Fi.
1. Copiez et collez le code suivant dans l'IDE Arduino. N'oubliez pas de personnaliser le SSID et le mot de passe Wi-Fi, ainsi que votre Ubidots .

/**************************************** * Bibliothèques ****************************************/ #include "UbidotsESPMQTT.h" /**************************************** * Définition des constantes ****************************************/ #define TOKEN "............................." // Votre jeton Ubidots #define WIFINAME "............ // Votre SSID #define WIFIPASS "............ // Votre mot de passe Wi-Fi #define DEVICE_LABEL "wifiswitch" // Nom du périphérique #define VARIABLE_LABEL1 "light" // Nom de la variable Ubidots const int ERROR_VALUE = 65535; // Valeur d'erreur const uint8_t NUMBER_OF_VARIABLES = 2; // Nombre de variables auxquelles le programme va s'abonner char * variable_labels[NUMBER_OF_VARIABLES] = {"light"}; // Noms des variables #define luz 0 #define bouton 2 int seguro=0; int ledState = LOW; // État actuel de la broche de sortie int buttonState; // Lecture actuelle de la broche d'entrée int lastButtonState = HIGH; // Lecture précédente de la broche d'entrée int reading; unsigned long lastDebounceTime = 0; // Délai de la dernière bascule de la broche de sortie unsigned long debounceDelay = 50; float estadoluz; // Variable à utiliser dans le code float value; // Variable pour stocker les données d'entrée uint8_t variable; // À utiliser avec le switch case Ubidots ubiClient(TOKEN); WiFiClient client; /**************************************** * Fonctions auxiliaires ****************************************/ void callback(char* topic, byte* payload, unsigned int length) { char* variable_label = (char *) malloc(sizeof(char) * 30); get_variable_label_topic(topic, variable_label); value = btof(payload, length); set_state(variable_label); execute_cases(); free(variable_label); //////////////////Light//////////////////// digitalWrite(luz, estadoluz); /////////////////Lumière///////////////////// } // Analyse le sujet pour extraire l'étiquette de la variable dont la valeur a changé void get_variable_label_topic(char * topic, char * variable_label) { Serial.print("sujet :"); Serial.println(topic); sprintf(variable_label, ""); for (int i = 0; i < NUMBER_OF_VARIABLES; i++) { char * result_lv = strstr(topic, variable_labels[i]); if (result_lv != NULL) { uint8_t len ​​= strlen(result_lv); char result[100]; uint8_t i = 0; for (i = 0; i < len - 3; i++) { result[i] = result_lv[i]; } result[i] = '\0'; Serial.print("Label is: "); Serial.println(result); sprintf(variable_label, "%s", result); break; } } } // Conversion d'un tableau de caractères en valeur flottante. float btof(byte * payload, unsigned int length) { char * demo = (char *) malloc(sizeof(char) * 10); for (int i = 0; i < length; i++) { demo[i] = payload[i]; } float value = atof(demo); free(demo); return value; } // Machine à états à utiliser switch case void set_state(char* variable_label) { variable = 0; for (uint8_t i = 0; i < NUMBER_OF_VARIABLES; i++) { if (strcmp(variable_label, variable_labels[i]) == 0) { break; } variable++; } if (variable >= NUMBER_OF_VARIABLES) variable = ERROR_VALUE; // Non valide } // Fonction avec switch case pour déterminer quelle variable a changé et lui assigner la valeur correspondante à la variable de code void execute_cases() { switch (variable) { case 0: estadoluz = value; Serial.print("Luz: "); Serial.println(estadoluz); Serial.println(); break; case ERROR_VALUE: Serial.println("error"); Serial.println(); break; default: Serial.println("default"); Serial.println(); } } /**************************************** * Fonction principale ****************************************/ void setup() { // Placez votre code de configuration ici, à exécuter une seule fois : pinMode(luz, OUTPUT); pinMode(boton, INPUT); ubiClient.ubidotsSetBroker("ubidots"); // Configure correctement le broker pour le compte professionnel ubiClient.setDebug(true); // Passe une valeur booléenne (true ou false) pour activer les messages de débogage Serial.begin(115200); ubiClient.wifiConnection(WIFINAME, WIFIPASS); ubiClient.begin(callback); if(!ubiClient.connected()){ ubiClient.reconnect(); } char* deviceStatus = getUbidotsDevice(DEVICE_LABEL); if (strcmp(deviceStatus, "404") == 0) { ubiClient.add("light", 0); //Insère vos étiquettes de variable et la valeur à envoyerubidotsPublish(DEVICE_LABEL); ubiClient.loop(); } ubiClient.ubidotsSubscribe(DEVICE_LABEL,VARIABLE_LABEL1); //Insérer les étiquettes du périphérique et de la variable Serial.println(variable_labels[1]); } void loop() { // Placez votre code principal ici, pour qu'il s'exécute en boucle : if(!ubiClient.connected()){ ubiClient.reconnect(); ubiClient.ubidotsSubscribe(DEVICE_LABEL,VARIABLE_LABEL1); //Insérer les étiquettes du périphérique et de la variable } ubiClient.loop(); readit(); debounce(); // Enregistrer la lecture. Au prochain passage dans la boucle, ce sera lastButtonState : lastButtonState = reading; } void readit(){ // Lire l'état du bouton dans une variable locale : reading = digitalRead(boton); if (reading != lastButtonState) { // Réinitialiser le temporisateur anti-rebond lastDebounceTime = millis(); void debounce(){ if ((millis() - lastDebounceTime) > debounceDelay) { // Quelle que soit la valeur lue, elle est présente depuis plus longtemps que le délai d'anti-rebond, // donc on la considère comme l'état actuel : readit2(); } } void readit2(){ // Si l'état du bouton a changé : if (reading != buttonState) { buttonState = reading; toggle(); } } void toggle(){ // Basculer la LED uniquement si le nouvel état du bouton est BAS if (buttonState == BAS) { ledState = !ledState; // Définir l'état de la LED : digitalWrite(luz, ledState); ubiClient.add("light", ledState); //Insérer les étiquettes de vos variables et la valeur à envoyerubidotsPublish(DEVICE_LABEL); } } char* getUbidotsDevice(char* deviceLabel) { char* data = (char *) malloc(sizeof(char) * 700); char* response = (char *) malloc(sizeof(char) * 400); sprintf(data, "GET /api/v1.6/devices/%s/", deviceLabel); sprintf(data, "%s HTTP/1.1\r\n", data); sprintf(data, "%sHost:ubidots\r\nUser-Agent:wifiswitch/1.0\r\n", data); sprintf(data, "%sX-Auth-Token: %s\r\nConnection: close\r\n\r\n", data, TOKEN); free(data); if (client.connect("ubidots", 80)) { client.println(data); } else { free(data); free(response); return "e"; } int timeout = 0; while(!client.available() && timeout < 5000) { timeout++; if (timeout >= 4999){ free(data); free(response); return "e"; } delay(1); } int i = 0; while (client.available()) { response[i++] = (char)client.read(); if (i >= 399){ break; } } char * pch; char * statusCode; int j = 0; pch = strtok (response, " "); while (pch != NULL) { if (j == 1 ) { statusCode = pch; } pch = strtok (NULL, " "); j++; } free(response); return statusCode; }

2. Téléchargement du code sur l'ESP8266 :

Pour téléverser le code sur l'ESP8266, nous avons besoin d'une interface série pour communiquer (programmer) le module avec le PC. Nous pouvons utiliser des convertisseurs USB vers TTL, mais dans ce cas, nous allons utiliser l' interface série de l'Arduino qui fonctionne très bien.

Pour téléverser le code dans l'ESP8266, vous devez suivre les branchements ci-dessous.

REMARQUE : Veuillez faire attention à l'alimentation VCC de l'ESP8266, il ne fonctionne qu'avec une alimentation de 3,3 V.

Vérifiez maintenant que votre code est correct en cliquant sur le bouton de vérification dans l'IDE Arduino, au-dessus de l'éditeur.

Une fois le code vérifié, vous recevrez une réponse similaire à celle ci-dessous, indiquant qu'il est correctement configuré.

Ensuite, vous devez téléverser le code dans votre NodeMCU. Pour ce faire, cliquez sur l'icône de flèche vers la droite située à côté de l'icône de validation.

Une fois le code téléchargé, vous recevrez le message ci-dessous dans l'IDE Arduino :

5. Configurez les commandes vocales à l'aide de l'Assistant Google :

Pour contrôler votre interrupteur Wi-Fi avec Google Home, il faut d'abord configurer une plateforme intermédiaire appelée IFTTT . Celle-ci permettra d'associer votre interrupteur à l'Assistant Google. Pour une configuration correcte, suivez les étapes ci-dessous.

Si vous n'avez pas de compte, inscrivez-vous.

Cliquez sur « Mes applets ».

Cliquez ensuite sur « Nouvelle applet ».

Cliquez sur « + ceci » pour configurer le déclencheur de votre condition.

Recherchez le service « Assistant Google » et cliquez dessus.

Cliquez sur « Dites une phrase simple ».

Remplissez les champs de déclenchement avec les phrases que vous souhaitez utiliser pour contrôler la lumière, la réponse et la langue, puis cliquez sur « Créer un déclencheur ».

Cliquez ensuite sur « +cela » pour configurer l'action.

Recherchez le service d'action Webhooks

Cliquez sur « Faire une requête web ».

Champs d'action à remplir :

Enfin, cliquez sur Terminer.

REMARQUE : Répétez toutes les étapes pour configurer l’applet « Éteindre la lumière », avec l’ Body .

6. Séance de test :

Conformément au schéma illustré, connectez correctement le module à votre appareil de climatisation.

Ajoutez un bouton momentané de votre choix dans le bloc terminal appelé SW.

Identifiez les câbles de phase, de neutre et de lumière :

Effectuez les branchements, placez le bouton, serrez les vis et testez.

Si vous préférez apprendre visuellement, consultez le tutoriel vidéo suivant. Vous y trouverez toutes les étapes de la réalisation de ce projet expliquées en détail :

Résumé:

Dans ce guide, nous avons appris à construire un interrupteur Wi-Fi contrôlable à distance par la voix, une application mobile ou un ordinateur, permettant de gérer l'éclairage d'une chambre ou de toute autre pièce. Cet appareil fonctionne grâce au module Wi-Fi ESP8266, un module compact qui facilite la connexion à Internet. Il peut être utilisé pour contrôler de nombreux appareils tels que des ventilateurs, des moteurs, des rideaux, des lampes, des rubans LED, etc.

Commencez dès aujourd'hui à développer vos solutions IoT avec Ubidots.