Daugybė saulės kolektorių galios stebėjimas naudojant „esp32“ ir „thingspeak“

Atsinaujinančios energijos srityje saulės energija yra priešakyje, nes energijos gamyba naudojant saulės jėgą yra lengviausias ir komerciškai perspektyviausias atsinaujinančios energijos būdas. Kalbant apie saulės kolektorius, reikia stebėti saulės kolektorių išėjimo galią, kad iš plokščių būtų gaunama optimali galia. Štai kodėl realaus laiko stebėjimo sistema tampa būtina. Didelėje saulės elektrinėje jis taip pat gali būti naudojamas kiekvieno skydelio galiai stebėti, kuris padeda nustatyti dulkių kaupimąsi. Tai taip pat apsaugo nuo bet kokių gedimų veikimo metu. Kai kuriuose ankstesniuose straipsniuose mes sukūrėme keletą su saulės energija susijusių projektų, tokių kaip saulės energija valdomo mobiliojo telefono įkroviklis, saulės keitiklio grandinė ir kt. Galite juos patikrinti, jei ieškote daugiau saulės energijos projektų.

Šiame projekte mes sukursime IoT pagrįstą saulės energijos stebėjimo sistemą, įtraukdami MPPT (Maximum Power Point Tracker) pagrįstą akumuliatorių įkrovimo techniką, kuri padės sumažinti įkrovimo laiką ir pagerinti efektyvumą. Taip pat išmatuosime skydo temperatūrą, išėjimo įtampą ir srovę, kad pagerintume grandinės saugos aspektą. Galiausiai, norėdami stebėti išvesties duomenis iš bet kurios pasaulio vietos, naudosime „ThingSpeak“ debesų paslaugas. Atkreipkite dėmesį, kad šis projektas yra tęsinys anksčiau pastatytam „MPPT“ saulės įkrovos valdiklio projektui. Čia mes stebėsime skydo išėjimo įtampą, srovę ir galią naudodami ESP32 IoT kūrimo plokštę.

Tinkamų komponentų pasirinkimas IoT įgalintiems saulės energijos monitoriams

Naudojant saulės monitorių tampa labai lengva stebėti ir aptikti bet kurios Saulės sistemos gedimus. Štai kodėl komponentų pasirinkimas tampa labai svarbia dalimi kuriant tokią sistemą. Toliau pateiktas naudotų dalių sąrašas.

ESP32 „dev“ plokštė
MPPT grandinė (gali būti bet kuri saulės grandinė)
Šuntinis rezistorius (pvz., 1 omas 1 vatas - tinka iki 1A srovės)
Ličio baterija (pageidautina 7.4v).
Aktyvus „Wi-Fi“ ryšys
Saulės kolektoriaus temperatūros jutiklis
Įtampos daliklio grandinė (žr. Aprašą)

„Esp32 Dev“ lenta:

Norint naudoti „IoT“ programą, būtina pasirinkti tinkamo tipo kūrimo plokštę, kuri galės apdoroti duomenis iš savo analoginių kaiščių ir siųsti duomenis per bet kokio tipo ryšio protokolą, pvz., „Wi-Fi“ arba į debesį. serverio. Mes specialiai pasirinkome ESP32, nes tai yra pigus mikrovaldiklis su daugybe funkcijų. Be to, jame yra įmontuotas „Wi-Fi“ radijas, per kurį mes galime labai lengvai prisijungti prie interneto.

Saulės grandinė:

Saulės įkrovimo grandinė yra grandinė, gaunanti didesnę įtampą iš saulės kolektoriaus ir paverčianti ją žemyn įkrovimo įtampa, kad galėtų efektyviai įkrauti akumuliatorių. Šiam projektui naudosime „LT3562“ pagrindu veikiančią MPPT įkrovimo valdiklio schemą, kurią jau atlikome viename iš savo ankstesnių projektų. Bet jei norite įterpti šį interneto įgalinimo stebėjimą, galite naudoti bet kokią saulės grandinę. Mes pasirinkome šią plokštę, nes grandinėje įrengtas maksimalaus galios taško stebėjimas (MPPT), kuris yra naudingas mažos galios saulės kolektorių projektams. Tai efektyvus būdas įkrauti nedidelę ličio bateriją iš saulės kolektoriaus.

Šunto rezistorius:

Bet kuris rezistorius laikosi omo dėsnio, o tai reiškia, kad jei per rezistorių teka tam tikras srovės kiekis, pasirodys tam tikras įtampos kritimas. Šuntiniai rezistoriai nėra to išimtis ir yra specialiai naudojami srovės srautui matuoti. Tačiau, atsižvelgiant į vardinį srovės srautą per saulės kolektorių, pasirinkite šunto rezistorių, kuris sukurs pakankamą įtampos kiekį, kurį gali išmatuoti mikrovaldiklio blokas. Bet tuo pačiu metu svarbus yra ir rezistoriaus galingumas. Taip pat svarbu parinkti šunto rezistoriaus galią.

Įtampos kritimą galima apskaičiuoti pagal žemiau pateiktą formulę. Tai vadinama Ohmo įstatymu

V = I x R

V yra įtampa, kuri bus sukurta „I“ metu, ty srovės srautas per rezistoriaus „R“ kiekį. Pavyzdžiui, 1 omo rezistorius sukels 1 V įtampos kritimą, kai per jį tekės 1A srovės.

Rezistoriaus galiai galima naudoti toliau pateiktą formulę:

P = I ² R

Kur I yra didžiausias srovės srautas, o R yra rezistoriaus vertė. 1A srovės su 1 omų rezistoriumi galiai išsklaidyti pakanka 1 vato. Tačiau tai naudinga mažiems saulės kolektorių projektams, tačiau visai netinka su saulės tinklu susijusioms programoms. Tokiu atveju iš tikrųjų reikia naudoti neinvazinę srovės matavimo techniką. Tokiu atveju srovės srautą galima tiksliai išmatuoti ten, kur galima išmatuoti labai mažą srovės kiekį, taip pat labai didelį srovės kiekį.

Ličio baterija:

Ličio baterijos pasirinkimas yra būtina bet kurio projekto, susijusio su saulės baterijomis, dalis. Kadangi mikrovaldiklio blokas, kuris visada lieka įjungtas ir nuolat tikrina bei teikia duomenis, stabiliam veikimui reikalauja mažiausiai šimto miliamperų srovės.

Baterijos talpa turėtų būti tokia, kuri galėtų valdyti mikrovaldiklį bent 4-5 dienas, kai saulė nešviečia dėl musono. Taip pat svarbu, kad akumuliatoriaus požiūriu įkrovimo srovė turėtų būti didesnė už apkrovos srovę. Gana neįprasta, jei kas nors sujungia 100mA apkrovą su akumuliatoriumi ir teikia įkrovimo srovę, kuri yra mažesnė. Kad būtume saugesni, turėtume turėti bent 5 kartus didesnę įkrovimo srovę nei apkrovos srovė.

Kita vertus, akumuliatoriaus įtampa turi būti didesnė nei bet kuri įprasta įtampos reguliatoriaus įėjimo įtampa, reikalinga mikrovaldikliui. Pvz., 7,4 V ličio baterija gali būti prijungta tiek prie 3,3 V, tiek prie 5,0 V linijinės įtampos reguliatorių (nes linijiniam reguliatoriui reikalinga didesnė kritimo įtampa nei LDO ir perjungimo).

Savo projekte naudojome 4000mAH bateriją su 7,4 V reitingu. Mes naudojome 5,0 V reguliatorių, kuris užtikrina pakankamą srovės ir įtampos išėjimą ESP32.

Įtampos daliklis:

Įtampos daliklis yra būtina saulės kolektoriaus įtampos matavimo dalis. Reikėtų pasirinkti įtampos daliklį, kuris padalins įtampą pagal mikrovaldiklio įvesties / išvesties įtampą.

Minėtus rezistorius pasirinkite taip, kad įtampos daliklio išėjimo įtampa neviršytų mikrovaldiklio maksimalios įvesties / išvesties įtampos (ESP32 - 3,3 V). Tačiau patariama naudoti potenciometrą, nes tai suteiks lankstumo pasirinkti bet kurią aukštesnės ar žemesnės įtampos saulės baterijos skydelį ir lengvai nustatys įtampą naudodamas multimetrą.

Mūsų atveju MPPT plokštės grandinėje turime potenciometrą, kuris veikia kaip įtampos daliklis. Mes nustatėme įtampos daliklį, kurio padalijimo koeficientas yra 6 V. Mes sujungėme du daugiametrius matuoklius, vieną į indą, o kitą į puodo išėjimą, ir nustatėme vertę, kad kai įėjimo įtampa yra 18 V, išėjimas bus 3 V, nes saulės kolektoriaus vardinė išėjimo įtampa yra 18 V.

Saulės skydo temperatūros jutiklis:

Saulės baterijos galia tiesiogiai susijusi su saulės baterijos temperatūra. Kodėl? Nes saulės kolektoriaus temperatūrai pradėjus didėti, saulės kolektoriaus išėjimo srovė didėja eksponentiškai, o įtampos išvestis pradeda mažėti tiesiškai.

Pagal galios formulę, galia yra lygi įtampai, padaugintai iš srovės (W = V x A), mažėjanti išėjimo įtampa taip pat sumažina saulės baterijų išėjimo galią net padidėjus srovės srautui. Dabar mums kyla kitas klausimas, kaip išmatuoti saulės temperatūrą? Na, tai gana įdomu, nes saulės baterijos dažniausiai būna veikiamos šilumos aplinkos, nes ją veikia tiesioginiai saulės spinduliai ir dėl akivaizdžių priežasčių. Geriausias būdas matuoti saulės kolektorių temperatūrą yra plokščio paviršiaus temperatūros jutiklis. Taip pat siūloma naudoti K tipo termoporą, dedamą tiesiai į saulės kolektorių.

Savo taikymui naudojome termistoriaus pagrindu pagamintą temperatūros jutiklio modulį, kuris parodytas žemiau.

IoT pagrįstos saulės energijos stebėjimo schema

Visa IoT įjungto saulės energijos monitoriaus schema parodyta žemiau. Schema paprasta. Raudona brūkšninių taškų lenta yra MPPT plokštė, kurią naudojome šiam projektui.

„ThingSpeak“ nustatymas

Sukurkite paskyrą naudodami „ThingSpeak“ ir eikite į parinktį „Mano kanalas“, tada spustelėkite Naujas kanalas.

Sukurkite naują kanalą su laukų pavadinimais.

Dabar, nustatę lauką, eikite į API raktų lauką, kuriame yra API API raktas. Šį raktą reikia nurodyti kode, taip pat kanalo ID.

„ThingSpeak“ adresą galite rasti tame pačiame puslapyje.

Atlikdami pirmiau nurodytus veiksmus, galite labai lengvai nustatyti „ThingSpeak“. Jei norite sužinoti daugiau apie „ThingSpeak“ ir jo sąrankos procesą, galite peržiūrėti ankstesnius mūsų straipsnius šia tema.

„Arduino“ saulės energijos stebėjimo naudojant ESP32 kodas

Visą saulės energijos stebėjimo kodą ESP32 rasite šio puslapio apačioje. Kodas prasideda apibrėžiant jūsų SSID, slaptažodį ir kelis kitus pastovius parametrus, kaip parodyta žemiau.

// apibrėžti „WiFi SSID“ ir „PWD“, skirtą „uplink“. #define WLAN_SSID "xxxx" #define WLAN_PASS "xxxxxxxxxx"

// atsparumas esant 25 laipsnių C temperatūrai #apibrėžti THERMISTORNOMINAL 10000 // temp. vardiniam atsparumui (beveik visada 25 C) #define TEMPERATURENOMINAL 25 // Termistoriaus beta koeficientas (paprastai 3000–4000) #define BCOEFFICIENT 3950 // „kito“ rezistoriaus vertė #define SERIESRESISTOR 10000

Termistoriaus vardinės omos yra numatytos vardinėje temperatūroje. Nustatykite šią vertę priklausomai nuo termistoriaus duomenų lapo. Įdėkite termistoriaus beta koeficientą ir nuoseklų rezistoriaus vertę.

// apibrėžti srovės ir įtampos analogą const int curr_an_pin = 35; const int volt_an_pin = 34; const int ntc_temp_an_pin = 33;

PIN yra apibrėžti čia.

#define thingSpeakAddress "xxxxxxxxx" #define channelID xxxxx #define writeFeedAPIKey "xxxxxxx" #define readFeedAPIKey "xxxxxxx" #define readFieldAPIKey "xxxxxxxx" #define readStatusAPIKey "xxxxxxx"

Įdėkite „thingSpeakAddress“, „channelID“, „Write Feed API Key“. Likusių dalykų nereikia, bet jie vis tiek yra naudingi, jei duomenis reikia gauti iš interneto.

void setup () { // įdėkite čia savo sąrankos kodą, kad jis būtų paleistas vieną kartą: // nustatykite nuoseklųjį prievadą 115200 Serial.begin (115200); // Inicializuoti nuoseklųjį delsą (1000); „WiFi.mode“ (WIFI_STA); „ThingSpeak.begin“ (klientas); // Inicijuoti „ThingSpeak“ // todo: sukurkite užduotį, kad galėtumėte perskaityti kaištį, kad gautumėte srovę ir įtampą, ir apskaičiuokite saulės kolektoriaus vatą ir temperatūrą xTaskCreate ( wifi_task, / * Task function. * / "Wifi_task", / * String with name of užduotis. * / 1024 * 2, / * Krūvos dydis baitais. * / NULL, / * Parametras perduotas kaip užduoties įvestis * / 5, / * Užduoties prioritetas. * / NULL); / * Užduoties rankena. * / Serial.print („Duomenų skaitymas“); }

Ankstesniame kode yra inicijuojamas „ThingSpeak“ serveris ir sukuriama užduotis, kuri gaus duomenis, susijusius su saulės baterija.

Pagrindinėje kilpoje saulės srovė ir įtampa suvokiama per analoginį kaištį ir atliekamas vidurkis.

plūduriuojantis saulės_srovės_adc_val = 0; plūdė saulės_volt_adc_val = 0; už (i = 0; i <NUMERIAI; i ++) { curr_samples = analogRead (curr_an_pin); volt_samples = analogRead (volt_an_pin); temp_samples = analogRead (ntc_temp_an_pin); vėlavimas (10); } // visų mėginių vidurkis iš kintamosios srovės_avg = 0; plūdė volt_avg = 0; plūdės temp_avg = 0; už (i = 0; i <NUMERIAI; i ++) { curr_avg + = curr_samples; volt_avg + = volt_ mėginiai; temp_avg + = temp_samples; } curr_avg / = SKAIČIAI; volt_avg / = SKAIČIAI; temp_avg / = SKAIČIAI; //Serial.print("ADC VALUE = "); //Serial.println(ADC_VALUE); // konvertuoti ADC vertę į įtampą, kad gautumėte faktinę srovę ir įtampą. plūdinė saulės_ srovė = (srovės_avg * 3,3) / (4095); plūdė saulės_voltas = (volt_avg * 3,3) / (4095); // naudodami įtampos daliklį, mes sumažiname tikrąją įtampą. // dėl šios priežasties padauginame 6 iš vidutinės įtampos, kad gautume tikrąją saulės kolektoriaus įtampą. saulės_voltas * = 6;

Saulės įtampa pateikiama padauginus iš 6, nes mes sukūrėme įtampos daliklį, kuris įėjimo įtampą padalins 6 kartus.

Temperatūra generuojama iš termistoriaus, naudojant logaritminį darinį.

// konvertuoti reikšmę į atsparumo temp_avg = 4095 / temp_avg - 1; temp_avg = SERIESRESISTOR / temp_avg; //Serial.print("Termistoriaus varža "); //Serial.println(temp_avg); plūdinis Steinhartas; steinhart = temp_avg / THERMISTORNOMINAL; // (R / Ro) steinhart = log (steinhart); // ln (R / Ro) steinhart / = POKYČIAS; // 1 / B * ln (R / Ro) steinhart + = 1,0 / (TEMPERATURENOMINAL + 273,15); // + (1 / To) Steinhartas = 1,0 / Steinhartas; // Apverskite Steinhartą - = 273,15; // konvertuoti absoliučią tempą į C

Duomenys skaitomi kas 15 sekundžių.

vėlavimas (1000); skaičius ++; Serijinis spaudinys ("."); jei (skaičius> = 15) { skaičius = 0; Serial.println ("=============================================== ============================ "); Serial.print („Saulės įtampa =“); Serial.println (saulės_voltas); Serial.print („Saulės srovė =“); Serial.println (saulės_srovė); plūdė saulės_vatas = saulės_voltas * saulės_srovė; Serial.print („Saulės vatas =“); Serial.println (saulės_vatas); Serial.print ("Saulės temperatūra ="); Serialas.println (steinhart); Serial.println ("=============================================== ============================ ");

Atitinkamų laukų duomenys perduodami naudojant funkciją Thing.Speak.setField (); kai prijungtas „WiFi“.

if (WiFi.status () == WL_CONNECTED) { ThingSpeak.setField (1, saulės_voltas); „ThingSpeak.setField“ (2, saulės_srovė); „ThingSpeak.setField“ (3, saulės_vatas); „ThingSpeak.setField“ (4, Steinhartas); // rašyti į „ThingSpeak“ kanalą int x = ThingSpeak.writeFields (channelID, writeFeedAPIKey); if (x == 200) { Serial.println ("Kanalų atnaujinimas sėkmingas."); } else { Serial.println ("Problema atnaujinant kanalą. HTTP klaidos kodas" + eilutė (x)); } } else { Serial.println ("\ r \ n ####################################################### ######################### "); Serial.println ("Nepavyko atnaujinti duomenų į" thingSpeak "serverį."); Serial.println („„ WiFi “neprijungtas…“); Serial.println ("################################################################ ############### \ r \ n "); } Serial.print („Duomenų skaitymas“); } }

„Wi-Fi“ užduotis, sukurta žemiau esančiame kodo fragmente-

void wifi_task (void * parametras) { while (1) { if (WiFi.status ()! = WL_CONNECTED) { Serial.print ("Bandoma prisijungti prie SSID:"); Serial.println (WLAN_SSID); while (WiFi.status ()! = WL_CONNECTED) { WiFi.begin (WLAN_SSID, WLAN_PASS); // Prisijunkite prie WPA / WPA2 tinklo. Pakeiskite šią eilutę, jei naudojate atvirą arba WEP tinklą Serial.print ("."); vėlavimas (5000); } Serial.println ("\ nPrijungta."); Serial.println (); Serial.println („Wi-Fi prijungtas“); Serial.println ("IP adresas:"); Serial.println („WiFi.localIP“ ()); } vTaskDelay (1000 / portTICK_PERIOD_MS); } vTaskDelete (NULL); }

Duomenų tikrinimas ir stebėjimas

Saulės skydelis yra sujungtas su grandine ir įdėtas į saulės spindulius bandymams, kaip parodyta žemiau.

Visas darbas parodytas toliau pateiktame vaizdo įraše. Mūsų grandinė sugebėjo nuskaityti išvesties įtampą, srovę ir galią iš skydo ir atnaujinti ją tiesiogiai „thingspeak“ kanale, kaip parodyta žemiau.

Kaip matome, 15 minučių duomenys rodomi aukščiau pateiktame grafike. Kadangi tai lauko operacijų projektas, reikia naudoti tinkamą PCB kartu su uždara dėže. Korpusas turi būti pagamintas taip, kad grandinė liktų nepralaidi lietui. Norėdami modifikuoti šią grandinę arba aptarti tolesnius šio projekto aspektus, maloniai naudokitės aktyviu „Circuit Digest“ forumu. Tikiuosi, kad jums patiko pamoka ir sužinojote ką nors naudingo.