Switch WiFi pour appareils électroménagers avec ESP8266

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

Que sont les commutateurs WiFi ?

De nos jours, nous vivons à l’ère de l’Internet des objets et les commutateurs WiFi en sont essentiellement la base. Ce sont des appareils qui peuvent allumer, éteindre ou atténuer les appareils électroménagers comme les lumières, les ventilateurs, etc. à distance ou de manière autonome, contrôlés par nos téléphones portables, notre voix, la température ambiante ou même les bulletins météorologiques.

Comment fonctionnent-ils ?

Ils sont basés sur la communication sans fil (communément appelée WiFi) qui leur permet de se connecter à Internet et de traiter les données, afin de pouvoir agir en fonction de certaines conditions établies par l'utilisateur.

Exigences de candidature :

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

1. Schéma :

Matériels:

3x résistances 1k ohm 1/4w

2x résistances 470 ohms 1/2w

1x connecteur femelle double en ligne (U3)

1x MOC3010 (Opto-triac)

1x Triac BTA24

1x condensateur 100nf 400v

1x alimentation Hi-Link 3,3 V

1x bornier 2p

1x bornier 3p

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

PCB fabriqué avec PCBGOGO (industrie de fabrication de PCB)

2. Création de périphériques et de variables Ubidots .

Accédez à la section Appareil de votre Ubidots et créez un nouvel appareil appelé « wifiswitch ».

A l'intérieur de votre appareil " wifiswitch ", créez une variable appelée " light ".

3. Création Dashboard et du widget Ubidots .

Une fois notre appareil et notre variable créés, nous pouvons créer un dashboard dashboard Web ou mobile . Pour créer un nouveau dashboard , appuyez sur « Données > Dashboard ». Appuyez ensuite sur l'icône plus et terminez la dashboard comme vous le souhaitez.

Créez maintenant un widget de contrôle pour définir l'état de l'ampoule associée à la variable "light". Pour créer le widget de contrôle, sélectionnez l'icône plus située en haut à droite de la page. Appuyez ensuite sur "Switch" comme type de widget, sélectionnez la variable que vous souhaitez contrôler et complétez la configuration du widget comme vous le souhaitez.

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

4. Programmation avec l'IDE Arduino.

1. Si ce n'est pas encore 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 cartes . 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. Maintenant, sélectionnez la carte générique ESP8266 dans le menu Outils -> Carte.

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

4b. Assurez-vous que votre vitesse de téléchargement IDE est de 115200 en allant dans Outils -> Vitesse de téléchargement -> 115200.

5. Téléchargez la Ubidots ESPMQTT si vous ne l'avez pas déjà fait. Maintenant, cliquez sur Sketch -> Include Library -> Add .ZIP Library et choisissez la Ubidots ESP8266 MQTT

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

8. Fermez et rouvrez l'IDE Arduino.

Programmation de l'ESP8266 :

Une fois votre ESP8266 configuré, nous pouvons commencer à publier et à souscrire des données depuis/vers Ubidots afin de contrôler le Wifi Switch.
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 " Ubidots ESPMQTT.h" /******* ********************************* * Définir les constantes ************** **************************/ #define TOKEN "................. .........." // Votre TOKEN Ubidots #define WIFINAME "........." //Votre SSID #define WIFIPASS "........." // Votre Pass Wifi #define DEVICE_LABEL "wifiswitch" // Nom de l'appareil #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 pour le programme qui va à l'abonné char * variable_labels[NUMBER_OF_VARIABLES] = {"light"}; // Noms des variables #define luz 0 #define boton 2 int seguro=0; int ledState = FAIBLE ; // l'état actuel de la broche de sortie int buttonState; // la lecture actuelle de la broche d'entrée int lastButtonState = HIGH; // la lecture précédente de la broche d'entrée int Reading ; non signé long lastDebounceTime = 0 ; // la dernière fois que la broche de sortie a été basculée, unsigned long debounceDelay = 50 ; flotteur estadoluz; // Variable à utiliser dans la valeur float du code ; // Variable pour stocker les données d'entrée uint8_t variable ; // A utiliser avec le switch case Ubidots ubiClient(TOKEN); Client WiFiClient ; /****************************************** * Fonctions auxiliaires ****** **********************************/ rappel nul (sujet char*, charge utile octet*, longueur int non signée) { char* variable_label = (char *) malloc(sizeof(char) * 30); get_variable_label_topic(sujet, variable_label); valeur = btof (charge utile, longueur); set_state(variable_label); exécuter_cases(); gratuit(variable_label); ////////////////Light/////////////////// digitalWrite(lumière, état); ////////////////Light//////////////////// } // Analyser le sujet pour extraire l'étiquette de variable qui a changé value void get_variable_label_topic(char * topic, char * variable_label) { Serial.print("topic:"); Serial.println(sujet); 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); résultat de caractères[100] ; uint8_t je = 0; pour (i = 0; i < len - 3; i++) { result[i] = result_lv[i]; } résultat[i] = '\0'; Serial.print("L'étiquette est : "); Serial.println (résultat); sprintf(variable_label, "%s", résultat); casser; } } } // converti 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]; } valeur flottante = atof(démo); gratuit (démo); valeur de retour ; } // 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++; } si (variable >= NUMBER_OF_VARIABLES) variable = ERROR_VALUE ; // Non valide } // Fonction avec switch case pour déterminer quelle variable a changé et attribuer la valeur en conséquence à la variable de code void exécuter_cases() { switch (variable) { case 0: estadoluz = value; Serial.print("Luz: "); Serial.println(état); Serial.println(); casser; cas ERROR_VALUE : Serial.println("erreur"); Serial.println(); casser; par défaut : Serial.println("par défaut"); Serial.println(); } } /**************************************** * Fonction principale **** ***********************************/ void setup() { // mettez votre code de configuration ici, à exécuter une fois : pinMode(luz, OUTPUT); pinMode(bouton, INPUT); ubiClient. ubidots SetBroker(" ubidots .com"); // Définit correctement le courtier 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(rappel); if(!ubiClient.connected()){ ubiClient.reconnect(); } char* deviceStatus = obtenir le périphérique Ubidots (DEVICE_LABEL); if (strcmp(deviceStatus, "404") == 0) { ubiClient.add("light", 0); //Insérez votre variable Labels et la valeur à envoyer à ubiClient. ubidots Publier(DEVICE_LABEL); ubiClient.loop(); }ubiClient. ubidots Abonnez-vous (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 l'exécuter à plusieurs reprises : if(!ubiClient.connected()){ ubiClient.reconnect(); ubiClient. ubidots Abonnez-vous (DEVICE_LABEL, VARIABLE_LABEL1); //Insérer les étiquettes du périphérique et de la variable } ubiClient.loop(); readit(); anti-rebond(); // enregistre la lecture. La prochaine fois dans la boucle, ce sera le lastButtonState : lastButtonState = Reading; } void readit(){ // lit l'état du switch dans une variable locale : reading = digitalRead(boton); if (reading != lastButtonState) { // réinitialise le minuteur anti-rebond lastDebounceTime = millis(); } } void debounce(){ if ((millis() - lastDebounceTime) > debounceDelay) { // quelle que soit la lecture, elle est là depuis plus longtemps que le // délai anti-rebond, alors prenez-le comme état actuel réel : readit2 (); } } void readit2(){ // si l'état du bouton a changé : if (reading != buttonState) { buttonState = reading; basculer(); } } void toggle(){ // bascule la LED uniquement si l'état du nouveau bouton est FAIBLE if (buttonState == LOW) { ledState = !ledState; // définit la LED : digitalWrite(luz, ledState); ubiClient.add("lumière", ledState); //Insérez votre variable Labels et la valeur à envoyer à ubiClient. ubidots Publier(DEVICE_LABEL); } } char* get Ubidots Device(char* deviceLabel) { char* data = (char *) malloc(sizeof(char) * 700); char* réponse = (char *) malloc(sizeof(char) * 400); sprintf(data, "GET /api/v1.6/devices/%s/", deviceLabel); sprintf(données, "%s HTTP/1.1\r\n", données); sprintf(data, "%sHost : industrial.api. ubidots .com\r\nUser-Agent:wifiswitch/1.0\r\n", data); sprintf(data, "%sX-Auth-Token : %s\r\nConnexion : close\r\n\r\n", data, TOKEN); gratuit(données); if (client.connect("industrial.api. ubidots .com", 80)) { client.println(data); } else { gratuit(données); gratuit(réponse); renvoie "e" ; } int délai d'attente = 0 ; while(!client.available() && timeout < 5000) { timeout++; if (timeout >= 4999){ free(data); gratuit(réponse); renvoie "e" ; } délai(1); } int je = 0; while (client.available()) { réponse[i++] = (char)client.read(); si (je >= 399){ pause ; } } char * pch; char * code d'état ; entier j = 0 ; pch = strtok (réponse, " ); while (pch != NULL) { if (j == 1 ) { statusCode = pch; } pch = strtok (NULL, " ); j++; } free(réponse); renvoyer le code d'état ; }

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

Pour télécharger le code sur l'ESP8266, nous avons besoin d'une interface série pour communiquer (programmeur) le module avec le PC, nous pouvons utiliser des convertisseurs USB vers TTL, mais dans ce cas, nous allons utiliser la série de l'Arduino qui fait un très bon travail.

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

REMARQUE : Soyez prudent avec le VCC de l'ESP8266, il ne fonctionne qu'avec une alimentation de 3,3 V.

Maintenant, vérifiez 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écharger le code dans votre NodeMCU. Pour ce faire, choisissez l'icône de flèche droite à côté de l'icône de vérification.

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 Google Assistant :

Pour contrôler votre « WiFi Switch » avec Google Home, nous devons d'abord configurer une plateforme intermédiaire appelée IFTTT , cela nous permettra de coupler notre Switch avec l'Assistant Google. Pour configurer correctement, suivez les étapes indiquées ci-dessous.

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

Cliquez sur « Mes applets ».

Ensuite, cliquez 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 du déclencheur 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 ».

Ensuite, cliquez sur « +ça » pour configurer l'action.

Recherchez le service d'action « Webhooks ».

Cliquez sur « Faire une demande web ».

Champs d'action complets :

Enfin, cliquez sur Terminer.

REMARQUE : répétez tout pour définir l' applet  Éteindre la lumière  instruction Body

6. Séance de test :

Grâce au schéma présenté sur l'image, connectez correctement le module à votre appareil AC.

Ajoutez un bouton momentané de votre préférence dans le bornier appelé SW.

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

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

Si vous êtes un apprenant visuel, consultez le didacticiel vidéo suivant. Vous pouvez trouver toutes les étapes que j'ai effectuées pour construire ce projet soigneusement expliquées :

Résumé:

Dans ce guide, nous venons d'apprendre comment créer un commutateur WiFi pouvant être contrôlé sur Internet par votre voix, une application de téléphone portable ou votre PC, qui vous permet de contrôler l'ampoule d'une chambre ou de tout autre endroit. Cet appareil fonctionne sur la base du module WiFi ESP8266, c'est-à-dire un petit module qui permet au projet de se mettre facilement en ligne. Et cet appareil peut être utilisé pour contrôler de nombreux appareils différents tels que des ventilateurs, des moteurs, des rideaux, des lumières, des bandes LED et bien plus encore.

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