- Matériaux nécessaires:
- Fonctionnement du capteur de courant ACS712:
- Schéma
- Code et explication:
- Application Android pour surveiller la consommation d'électricité:
Nous connaissons tous les compteurs d'énergie électrique qui sont installés dans la maison ou les bureaux de chacun pour mesurer la consommation électrique. Enfin, chaque mois, nous sommes nombreux à s'inquiéter de la facture d'électricité élevée et nous devons regarder le compteur d'énergie de temps en temps. Mais que se passe-t-il si nous pouvons surveiller nos consommations d'électricité de partout dans le monde et recevoir un SMS / E-mail lorsque votre consommation d'énergie atteint une valeur seuil. Ici, nous construisons un projet de compteur d'énergie basé sur l'IoT.
Auparavant, nous avons construit un circuit Energy Meter qui vous envoie des SMS sur la facture en utilisant le module GSM. Dans ce projet, nous fabriquons un compteur d'énergie électrique intelligent à l'aide du module Wi-Fi Arduino et ESP8266 qui peut non seulement vous envoyer un SMS / e-mail de votre facture d'électricité, mais également vous pouvez surveiller la consommation d'énergie à tout moment et de n'importe où dans le monde. Ici, nous avons utilisé un capteur de courant ACS712 pour mesurer la consommation d'énergie, nous en discuterons sous peu.
Nous prendrons l'aide de la plate-forme IFTTT pour relier notre Wi-Fi aux notifications SMS / E-mail. Nous utiliserons également l'application Android MQTT Dashboard pour surveiller nos consommations d'énergie. Alors, commençons….
Matériaux nécessaires:
- Arduino Uno
- ESP12 / NodeMCU
- Capteur de courant ACS712-30Amp
- Tout appareil AC
- Fils mâle-femelle
Fonctionnement du capteur de courant ACS712:
Avant de commencer à construire le projet, il est très important pour nous de comprendre le fonctionnement du capteur de courant ACS712 car c'est l'élément clé du projet. Mesurer le courant, en particulier le courant alternatif, est toujours une tâche difficile en raison du bruit associé à un problème d'isolation incorrect, etc. Mais, avec l'aide de ce module ACS712 qui a été conçu par Allegro, les choses sont devenues beaucoup plus faciles.
Ce module fonctionne sur le principe de l' effet Hall, qui a été découvert par le Dr Edwin Hall. Selon son principe, lorsqu'un conducteur porteur de courant est placé dans un champ magnétique, une tension est générée sur ses bords perpendiculaires aux directions à la fois du courant et du champ magnétique. N'allons pas trop loin dans le concept mais, en termes simples, nous utilisons un capteur à effet Hall pour mesurer le champ magnétique autour d'un conducteur porteur de courant. Cette mesure sera exprimée en millivolts que nous appelons la tension hall. Cette tension Hall mesurée est proportionnelle au courant qui circulait dans le conducteur.
Le principal avantage de l'utilisation du capteur de courant ACS712 est qu'il peut mesurer à la fois le courant alternatif et le courant continu et qu'il fournit également une isolation entre la charge (charge CA / CC) et l'unité de mesure (partie microcontrôleur). Comme le montre l'image, nous avons trois broches sur le module qui sont respectivement Vcc, Vout et Ground.
Le bornier à 2 broches est l'endroit où le fil porteur de courant doit être passé. Le module fonctionne sur + 5V, le Vcc doit donc être alimenté par 5V et la terre doit être connectée à la terre du système. La broche Vout a une tension de décalage de 2500 mV, ce qui signifie que lorsqu'il n'y a pas de courant circulant dans le fil, la tension de sortie sera de 2500 mV et lorsque le courant circulant est positif, la tension sera supérieure à 2500 mV et lorsque le courant circulant est négatif, le la tension sera inférieure à 2500 mV.
Nous utiliserons la broche analogique d'Arduino pour lire la tension de sortie (Vout) du module, qui sera de 512 (2500mV) lorsqu'il n'y a pas de courant circulant dans le fil. Cette valeur diminuera à mesure que le courant circule dans le sens négatif et augmentera à mesure que le courant circule dans le sens positif. Le tableau ci-dessous vous aidera à comprendre comment la tension de sortie et la valeur ADC varient en fonction du courant traversant le fil.
Ces valeurs ont été calculées sur la base des informations fournies dans la fiche technique de l'ACS712. Vous pouvez également les calculer à l'aide des formules ci-dessous:
Tension Vout (mV) = (Valeur ADC / 1023) * 5000 Courant à travers le fil (A) = (Vout (mv) -2500) / 185
Maintenant que nous savons comment fonctionne le capteur ACS712 et ce que nous pouvons en attendre. Passons au schéma de circuit.
Nous avons utilisé ce capteur pour créer un circuit d'ampèremètre numérique à l'aide du microcontrôleur PIC et de l'ACS712.
Schéma
Étape 1: Connectez - vous à IFTTT avec vos informations d'identification.
Étape 2: Sur Mes applets, cliquez sur Nouvelle applet
Étape 3: Cliquez sur + ceci
Étape 4: Recherchez AdaFruit et cliquez dessus.
Étape 5: Cliquez sur Surveiller un flux sur AdaFruit IO.
Étape 6: Choisissez Feed comme facture, Relation comme « égal à» et la valeur seuil à laquelle vous voulez un e-mail. Cliquez sur Créer une action . J'ai utilisé 4 comme valeur de déclenchement de seuil.
Étape 7: Cliquez sur + ça . Recherchez G-mail et cliquez dessus et connectez-vous avec vos identifiants g-mail.
Étape 8: Cliquez sur vous envoyer un e-mail.
Étape 9: Écrivez votre sujet et votre corps comme indiqué et cliquez pour créer.
Étape 10: Votre « recette » est prête. Passez en revue et cliquez sur Terminer.
Maintenant, nous en avons terminé avec l'intégration Web. Passons à la partie codage.
Code et explication:
Nous utilisons la communication série entre ESP12 et Arduino. Nous devons donc écrire du code pour Arduino et NodeMCU pour la transmission et la réception.
Code pour la partie émetteur, c'est-à-dire pour Arduino Uno:
Le code Arduino complet est donné à la fin de ce tutoriel. Nous utiliserons la bibliothèque pour le capteur de courant qui peut être téléchargée à partir de ce lien.
Cette bibliothèque a une fonction intégrée pour calculer le courant. Vous pouvez écrire votre code pour calculer le courant, mais cette bibliothèque possède des algorithmes de mesure du courant précis.
Tout d'abord, incluez la bibliothèque pour le capteur de courant comme:
#include "ACS712.h"
Créez une matrice pour stocker l'énergie pour l'envoyer à NodeMCU.
char watt;
Créez une instance pour utiliser ACS712-30Amp au PIN A0. Modifiez le premier argument si vous utilisez une variante de 20 A ou 5 A.
Capteur ACS712 (ACS712_30A, A0);
Dans la fonction de configuration , définissez la vitesse de transmission de 115200 pour communiquer avec NodeMCU. Appelez la fonction sensor.calibrate () pour calibrer le capteur de courant afin d'obtenir des lectures précises.
void setup () { Serial.begin (115200); sensor.calibrate (); }
En fonction de boucle , nous appellerons sensor.getCurrentAC (); fonction pour obtenir la valeur actuelle et la stocker dans la variable flottante I. Après avoir obtenu le courant, calculer la puissance en utilisant la formule P = V * I. Nous utilisons 230V car c'est la norme commune dans les pays européens, changez pour votre local, si nécessaire
boucle vide () { float V = 230; float I = sensor.getCurrentAC (); flotteur P = V * I;
Ces lignes convertissent la puissance en Wh.
last_time = heure_actuelle; heure_courante = millis (); Wh = Wh + P * ((heure_actuelle - heure_dernière) /3600000.0);
Maintenant, nous devons convertir ce Wh en forme de caractère pour l'envoyer à NodeMCU, pour ce dtostrf (); convertira un float en un tableau de caractères afin qu'il puisse ensuite être imprimé facilement:
dtostrf (Wh, 4, 2, watt);
Le format est:
dtostrf (floatvar, StringLengthIncDecimalPoint, numVarsAfterDecimal, charbuf);
Ecrivez ce tableau de caractères dans le tampon série en utilisant Serial.write () ; fonction. Cela enverra la valeur Wh à NodeMCU.
Serial.write (watt); retard (10000); }
Code pour le nœud de pièce du récepteurMCU ESP12:
Pour cela, nous avons besoin de la bibliothèque AdaFruit MQTT qui peut être téléchargée à partir de ce lien.
Maintenant, ouvrez Arduino IDE. Aller aux exemples -> bibliothèque AdaFruit MQTT -> mqtt_esp8266
Nous modifierons ce code en fonction de nos clés AIO et de nos informations d'identification Wi-Fi et des données série entrantes de l'Arduino.
Tout d'abord, nous avons inclus toutes les bibliothèques pour le module Wi-Fi ESP12 et AdaFruit MQTT.
#comprendre
Nous définissons le SSID et le mot de passe de votre Wi-Fi, à partir desquels vous souhaitez connecter votre ESp-12e.
#define WLAN_SSID "xxxxxxxx" #define WLAN_PASS "xxxxxxxxxxx"
Cette section définit le serveur AdaFruit et le port du serveur qui sont respectivement définis comme «io.adafruit.com» et «1883».
#define AIO_SERVER "io.adafruit.com" #define AIO_SERVERPORT 1883
Remplacez ces champs par votre nom d'utilisateur et les clés AIO que vous avez copiés depuis le site AdaFruit lors de la création du flux.
#define AIO_USERNAME "********" #define AIO_KEY "******************************"
Ensuite, nous avons créé une classe ESP12 WiFiClient pour se connecter au serveur MQTT.
Client WiFiClient;
Configurez la classe client MQTT en transmettant le client WiFi et le serveur MQTT et les informations de connexion.
Adafruit_MQTT_Client mqtt (& client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);
Configurez un flux appelé «Puissance» et «Facture» pour la publication des modifications.
Adafruit_MQTT_Publish Power = Adafruit_MQTT_Publish (& mqtt, AIO_USERNAME "/ feeds / Power"); Adafruit_MQTT_Publish bill = Adafruit_MQTT_Publish (& mqtt, AIO_USERNAME "/ feeds / bill");
Dans la fonction de configuration , nous connectons le module Wi-Fi au point d'accès Wi-Fi.
void setup () { Serial.begin (115200); retard (10); Serial.println (F ("Démo Adafruit MQTT")); // Connectez-vous au point d'accès WiFi. Serial.println (); Serial.println (); Serial.print ("Connexion à"); Serial.println (WLAN_SSID); WiFi.begin (WLAN_SSID, WLAN_PASS); …. …. … }
En fonction de boucle , nous vérifierons les données entrantes de l'Arduino et publierons ces données sur AdaFruit IO.
void loop () { // Assurez-vous que la connexion au serveur MQTT est active (cela établira la première // connexion et se reconnectera automatiquement une fois déconnecté). Voir la définition de la fonction MQTT_connect // plus loin ci-dessous. MQTT_connect (); int i = 0; float watt1;
Cette fonction vérifie les données entrantes de l'Arduino et stocke ces données dans un tableau de watts à l' aide de la fonction serial.read ().
if (Serial.available ()> 0) { delay (100); // permet à tous les numéros de série envoyés d'être reçus ensemble while (Serial.available () && i <5) { watt = Serial.read (); } watt = '\ 0'; }
La fonction atof () convertit les caractères en valeurs flottantes et nous stockerons cette valeur flottante dans une autre variable flottante watt1.
watt1 = atof (watt);
Calculez le montant de la facture en multipliant la puissance (en Wh) par le tarif de l'énergie et divisez-la par 1000 pour produire de l'énergie en KWh.
bill_amount = watt1 * (tarif énergétique / 1000); // 1unité = 1kwH
Maintenant, nous pouvons publier des trucs!
Serial.print (F ("\ nSending Power val")); Serial.println (watt1); Serial.print ("…");
Ce morceau de code publie des valeurs de puissance à la puissance d' alimentation
if (! Power.publish (watt1)) { Serial.println (F ("Failed")); } else { Serial.println (F ("OK!")); }
Cela publiera la facture d'électricité à la source de la facture .
if (! bill.publish (bill_amount)) { Serial.println (F ("Failed")); } else { Serial.println (F ("OK!")); }
Le montant de notre facture peut changer rapidement mais IFTTT prend du temps pour déclencher l'applet, donc ces lignes donneront le temps de se déclencher afin que nous puissions recevoir un e-mail de seuil.
Modifiez la valeur bill_amount sur laquelle vous souhaitez recevoir des e-mails. Modifiez également la configuration IFTTT AdaFruit IO.
if (bill_amount == 4) { for (int i = 0; i <= 2; i ++) { bill.publish (bill_amount); retard (5000); } bill_amount = 6; }
Le code complet pour Arduino et NodeMCU ESP12 est donné à la fin de ce tutoriel.
Maintenant, téléchargez les codes sur les deux tableaux. Connectez votre matériel comme indiqué dans le schéma de circuit et ouvrez io.adafruit.com. Ouvrez le tableau de bord que vous venez de créer. Vous verrez que la consommation d'énergie et la facture d'électricité sont en cours de mise à jour.
Lorsque votre facture atteint à INR 4 alors vous recevrez un email comme celui - ci.
Application Android pour surveiller la consommation d'électricité:
Vous pouvez utiliser l'application Android pour surveiller les valeurs. Pour cela, téléchargez l' application Android MQTT Dashboard depuis le Play Store ou depuis ce lien.
Pour configurer la connexion avec io.adafruit.com, procédez comme suit:
Étape 1: Ouvrez l'application et cliquez sur le signe «+». Remplissez l'ID client comme vous le souhaitez. Le serveur et le port restent identiques, comme indiqué sur la capture d'écran. Vous obtiendrez le nom d'utilisateur et le mot de passe (clé active) du tableau de bord AdaFruit IO comme indiqué ci-dessous.
Active Key est votre mot de passe.
Étape 2: Sélectionnez Compteur d'électricité et sélectionnez S'abonner. Dans l'abonnement, donnez un nom et un sujet conviviaux. Le format du sujet est 'votre nom d' utilisateur' / feeds / 'feedname' et cliquez sur créer.
Étape 3: De la même manière, abonnez-vous au flux de factures.
Étape 4: Au fur et à mesure que vos appareils consomment de l'énergie, les valeurs mises à jour seront affichées sous Power and Bill .
C'est ainsi que vous pouvez créer un compteur d'énergie électrique intelligent, qui peut non seulement être surveillé de n'importe où dans le monde, mais également déclencher un courrier électronique lorsque vous avez une consommation d'électricité élevée.
Consultez également tous nos projets IoT.