Iotbasert energimåler med esp12 og arduino

Vi vet alle om elektrisitetsenergimålere som er installert i alles hus eller kontorer for å måle strømforbruket. Til slutt hver måned blir mange av oss bekymret for den høye strømregningen, og vi må se på energimåleren en gang i blant. Men hva om vi kan overvåke strømforbruket vårt hvor som helst i verden og få en SMS / e-post når energiforbruket når en terskelverdi. Her bygger vi et IoT-basert prosjekt med energimåler.

Tidligere har vi bygget en energimålerkrets som sender deg SMS om regningen ved hjelp av GSM-modulen. I dette prosjektet lager vi en Smart Electricity Energy meter ved hjelp av Arduino og ESP8266 Wi-Fi-modulen som ikke bare kan sende deg en SMS / e-post av strømregningen, men du kan også overvåke energiforbruket når som helst og hvor som helst i verden. Her har vi brukt en Current Sensor ACS712 for å måle energiforbruket, vi vil diskutere om det snart.

Vi vil ta hjelp av IFTTT- plattformen for å koble Wi-Fi til SMS / E-postvarsler. Vi vil også bruke MQTT Dashboard Android App for å overvåke energiforbruket vårt. Så la oss komme i gang….

Nødvendige materialer:

Arduino Uno
ESP12 / NodeMCU
ACS712-30Amp Strømssensor
Eventuelt AC-apparat
Mann-kvinnelige ledninger

Arbeid med ACS712 nåværende sensor:

Før vi begynner å bygge prosjektet, er det veldig viktig for oss å forstå hvordan ACS712 strømføleren fungerer, da den er nøkkelkomponenten i prosjektet. Å måle strøm, spesielt vekselstrøm, er alltid en tøff oppgave på grunn av støy kombinert med feilaktig isolasjonsproblem osv. Men med hjelp av denne ACS712-modulen som ble konstruert av Allegro har det blitt mye enklere.

Denne modulen fungerer på prinsippet om Hall-effekt, som ble oppdaget av Dr. Edwin Hall. I følge hans prinsipp, når en strømførende leder blir plassert i et magnetfelt, genereres en spenning over kantene vinkelrett på retningene til både strømmen og magnetfeltet. La oss ikke komme for dypt inn i konseptet, men ganske enkelt bruker vi en hallsensor til å måle magnetfeltet rundt en strømførende leder. Denne målingen vil være i form av millivolt som vi kalte som hall-spenning. Denne målte hall-spenningen er proporsjonal med strømmen som strømmer gjennom lederen.

Den største fordelen med å bruke ACS712 strømføler er at den kan måle både vekselstrøm og likestrøm, og den gir også isolasjon mellom belastning (vekselstrøm / likestrøm) og måleenhet (del av mikrokontroller). Som vist på bildet har vi tre pinner på modulen som er henholdsvis Vcc, Vout og Ground.

Den 2-pinners rekkeklemmen er der den strømførende ledningen skal føres gjennom. Modulen fungerer på + 5V, slik at Vcc skal drives av 5V og bakken skal være koblet til bakken på systemet. Vout-pinnen har en offset-spenning på 2500mV, noe som betyr at når det ikke strømmer strøm gjennom ledningen, vil utgangsspenningen være 2500mV, og når strømmen strømmer er positiv, vil spenningen være større enn 2500mV, og når strømmen er negativ, vil spenningen vil være mindre enn 2500mV.

Vi vil bruke den analoge pinnen til Arduino for å lese utgangsspenningen (Vout) til modulen, som vil være 512 (2500mV) når det ikke strømmer strøm gjennom ledningen. Denne verdien vil reduseres når strømmen strømmer i negativ retning og vil øke når strømmen strømmer i positiv retning. Tabellen nedenfor hjelper deg med å forstå hvordan utgangsspenningen og ADC-verdien varierer basert på strømmen som strømmer gjennom ledningen.

Disse verdiene ble beregnet basert på informasjonen gitt i databladet til ACS712. Du kan også beregne dem ved hjelp av formlene nedenfor:

Voutspenning (mV) = (ADC-verdi / 1023) * 5000 Strøm gjennom ledningen (A) = (Vout (mv) -2500) / 185

Nå som vi vet hvordan ACS712-sensoren fungerer og hva vi kan forvente av den. La oss gå videre til kretsskjemaet.

Vi har brukt denne sensoren til å lage Digital Ammeter Circuit ved hjelp av PIC Microcontroller og ACS712.

Kretsskjema

Trinn 1: Logg inn på IFTTT med din legitimasjon.

Trinn 2: Klikk på Ny applet på mine applets

Trinn 3: Klikk på + dette

Trinn 4: Søk i AdaFruit og klikk på den.

Trinn 5: Klikk på Overvåk en feed på AdaFruit IO.

Trinn 6: Velg feed som regning, Sivil som ' lik' og terskelen verdi der du ønsker en e-post. Klikk på Opprett handling . Jeg har brukt 4 som terskelverdien min.

Trinn 7: Klikk på + det . Søk etter G-post og klikk på den, og logg inn med g-postinformasjonen din.

Trinn 8: Klikk på send deg en e-post.

Trinn 9: Skriv emnet og kroppen din som vist, og klikk for å lage.

Trinn 10: Din ' oppskrift ' er klar. Gjennomgå det og klikk på ferdig.

Nå er vi ferdige med nettintegrasjon. La oss gå videre med kodingsdel..

Kode og forklaring:

Vi bruker seriell kommunikasjon mellom ESP12 og Arduino. Så vi må skrive kode for både Arduino og NodeMCU for overføring og mottakelse.

Kode for senderdel dvs. for Arduino Uno:

Komplett Arduino-kode er gitt på slutten av denne opplæringen. Vi bruker biblioteket for gjeldende sensor som kan lastes ned fra denne lenken.

Dette biblioteket har innebygd funksjon for å beregne strøm. Du kan skrive koden din for å beregne strømmen, men dette biblioteket har nøyaktige strømmålealgoritmer.

Først inkluderer du bibliotek for gjeldende sensor som:

# inkluderer "ACS712.h"

Lag en matrise for å lagre strøm for å sende den til NodeMCU.

røye watt;

Opprett en forekomst for å bruke ACS712-30Amp ved PIN A0. Endre første argument hvis du bruker 20Amp eller 5 Amp variant.

ACS712-sensor (ACS712_30A, A0);

I oppsettfunksjon definerer du baudrate på 115200 for å kommunisere med NodeMCU. Ring sensor.calibrate () -funksjon for kalibrering av nåværende sensor for å få nøyaktige målinger.

ugyldig oppsett () { Serial.begin (115200); sensor. kalibrer (); }

I sløyfefunksjon vil vi kalle sensor.getCurrentAC (); funksjon for å få den nåværende verdien og lagre i flottørvariabelen I. Etter å ha fått strøm, beregne effekt med P = V * I formel. Vi bruker 230V fordi det er den vanlige standarden i europeiske land. Bytt til ditt lokale, om nødvendig

ugyldig sløyfe () { float V = 230; flyte I = sensor.getCurrentAC (); flyte P = V * I;

Disse linjene konverterer kraft til Wh.

siste tid = nåværende tid; current_time = millis (); Wh = Wh + P * ((nåværende tid-siste tid) / 3600000.0);

Nå må vi konvertere denne Wh til tegnform for å sende den til NodeMCU, for denne dtostrf (); vil konvertere en flottør til en røyeoppstilling, slik at den lett kan skrives ut:

dtostrf (Wh, 4, 2, watt);

Formatet er:

dtostrf (floatvar, StringLengthIncDecimalPoint, numVarsAfterDecimal, charbuf);

Skriv dette tegnsettet til seriell buffer ved hjelp av Serial.write () ; funksjon. Dette vil sende Wh- verdi til NodeMCU.

Serial.write (watt); forsinkelse (10000); }

Kode for mottaker del NodeMCU ESP12:

For dette trenger vi AdaFruit MQTT-biblioteket som kan lastes ned fra denne lenken.

Nå åpner du Arduino IDE. Gå til eksempler -> AdaFruit MQTT-bibliotek -> mqtt_esp8266

Vi vil redigere denne koden i henhold til våre AIO-nøkler og Wi-Fi-legitimasjon og innkommende serielle data fra Arduino.

Først inkluderte vi alle bibliotekene for ESP12 Wi-Fi-modul og AdaFruit MQTT.

#inkludere #include "Adafruit_MQTT.h" #include "Adafruit_MQTT_Client.h"

Vi definerer SSID og passord for Wi-Fi, som du vil koble til ESp-12e fra.

#define WLAN_SSID "xxxxxxxx" #define WLAN_PASS "xxxxxxxxxxx"

Denne delen definerer AdaFruit-serveren og serverporten som er løst som henholdsvis “io.adafruit.com” og “1883”.

#define AIO_SERVER "io.adafruit.com" #define AIO_SERVERPORT 1883

Erstatt disse feltene med brukernavnet og AIO-nøklene som du har kopiert fra AdaFruit-nettstedet mens du oppretter feeden.

#define AIO_USERNAME "********" #define AIO_KEY "*****************************"

Så har vi laget en ESP12 WiFiClient-klasse for å koble til MQTT-serveren.

WiFiClient-klient;

Sett opp MQTT-klientklassen ved å sende inn WiFi-klienten og MQTT-serveren og påloggingsinformasjonen.

Adafruit_MQTT_Client mqtt (& klient, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);

Sett opp en strøm kalt 'Power' og 'bill' for publisering til endringer.

Adafruit_MQTT_Publish Power = Adafruit_MQTT_Publish (& mqtt, AIO_USERNAME "/ feeds / Power"); Adafruit_MQTT_Publish bill = Adafruit_MQTT_Publish (& mqtt, AIO_USERNAME "/ feeds / bill");

I oppsettfunksjonen kobler vi Wi-Fi-modulen til Wi-fi-tilgangspunktet.

ugyldig oppsett () { Serial.begin (115200); forsinkelse (10); Serial.println (F ("Adafruit MQTT demo")); // Koble til WiFi tilgangspunkt. Serial.println (); Serial.println (); Serial.print ("Koble til"); Serial.println (WLAN_SSID); WiFi.begin (WLAN_SSID, WLAN_PASS); …. …. ... }

I loop- funksjon vil vi se etter innkommende data fra Arduino og publisere disse dataene til AdaFruit IO.

void loop () { // Sørg for at tilkoblingen til MQTT-serveren er i live (dette vil gjøre den første // tilkoblingen og automatisk koble til igjen når den er frakoblet). Se definisjonen MQTT_connect // funksjon lenger nedenfor. MQTT_connect (); int i = 0; flyte watt1;

Denne funksjonen sjekker for innkommende data fra Arduino og lagrer disse dataene i watt- array ved hjelp av serial.read () -funksjonen.

hvis (Serial.available ()> 0) { delay (100); // lar alle sendte serier mottas sammen mens (Serial.available () && i <5) { watt = Serial.read (); } watt = '\ 0'; }

funksjonen atof () konverterer tegnene til flyteverdier, og vi vil lagre denne flyteverdien i en annen flytbar variabel watt1.

watt1 = atof (watt);

Beregn regningsbeløpet ved å multiplisere kraften (i Wh) med energitariffen og dele den med 1000 for å få kraft i KWh.

bill_amount = watt1 * (energyTariff / 1000); // 1 enhet = 1kwH

Nå kan vi publisere ting!

Serial.print (F ("\ nSending Power val")); Serial.println (watt1); Serial.print ("…");

Dette stykke kode publiserer effektverdier til Strøm -feed

hvis (! Power.publish (watt1)) { Serial.println (F ("Mislyktes")); } annet { Serial.println (F ("OK!")); }

Dette vil publisere strømregningen til fakturaen .

hvis (! bill.publish (bill_amount)) { Serial.println (F ("Mislyktes")); } annet { Serial.println (F ("OK!")); }

Regningsbeløpet kan endres raskt, men IFTTT tar tid å utløse appleten, slik at disse linjene gir tid til å utløse, slik at vi kan motta terskel-e-post.

Endre bill_amount verdien som du ønsker å få e-post. Endre også IFTTT AdaFruit IO-oppsettet.

hvis (bill_amount == 4) { for (int i = 0; i <= 2; i ++) { bill.publish (bill_mount); forsinkelse (5000); } bill_amount = 6; }

Komplett kode for Arduino og NodeMCU ESP12 er gitt på slutten av denne opplæringen.

Last nå opp kodene til begge tavlene. Koble til maskinvaren din som vist i kretsdiagrammet og Åpne io.adafruit.com. Åpne dashbordet du nettopp opprettet. Du vil se strømforbruket og strømregningen oppdateres.

Når regningen nådde INR 4, vil du motta en e-post som denne.

Android-app for overvåking av strømforbruk:

Du kan bruke Android-appen til å overvåke verdiene. For denne nedlastingen MQTT Dashboard android-appen fra Play-butikken eller fra denne lenken.

Følg disse trinnene for å konfigurere tilkoblingen til io.adafruit.com:

Trinn 1: Åpne appen og klikk på "+" -tegnet. Fyll klient-ID hva du vil. Server og port forblir de samme som vist på skjermbildet. Du får brukernavn og passord (aktiv nøkkel) fra AdaFruit IO-dashbordet som vist nedenfor.

Active Key er passordet ditt.

Trinn 2: Velg Strømmåler og velg Abonner. Gi vennlig navn og emne i abonnementet. Emneformatet er ' dittbrukernavn' / feeds / 'feedname' og klikk på Create.

Trinn 3: På samme måte kan du tegne abonnement på faktura.

Trinn 4: Når apparatene dine bruker energi, vil oppdaterte verdier vises under Power and Bill .

Slik kan du lage en Smart Electricity Energy Meter, som ikke bare kan overvåkes hvor som helst i verden, men også utløse e-post når du har høyt strømforbruk.

Sjekk også alle våre IoT-prosjekter.