- Pareizo komponentu izvēle IoT iespējotam saules enerģijas monitoram
- IoT balstītas saules enerģijas uzraudzības shēmas shēma
- ThingSpeak iestatīšana
- Arduino kods saules enerģijas uzraudzībai, izmantojot ESP32
- Datu pārbaude un uzraudzība
Atjaunojamās enerģijas jomā priekšplānā ir saules enerģija, jo enerģijas ražošana, izmantojot saules enerģiju, ir vienkāršākais un komerciāli izdevīgākais atjaunojamās enerģijas veids. Runājot par saules paneļiem, ir jāuzrauga saules paneļu izejas jauda, lai iegūtu optimālu jaudu no paneļiem. Tāpēc kļūst nepieciešama reāllaika uzraudzības sistēma. Lielā saules elektrostacijā to var arī izmantot, lai uzraudzītu katra paneļa jaudu, kas palīdz identificēt putekļu uzkrāšanos. Tas arī novērš jebkādus traucējumu apstākļus darbības laikā. Dažos no mūsu iepriekšējiem rakstiem mēs esam izveidojuši dažus ar saules enerģiju saistītus projektus, piemēram, ar saules enerģiju darbināmu mobilo tālruņu lādētāju un saules invertora ķēdi utt. Jūs varat tos pārbaudīt, ja meklējat vairāk saules enerģijas projektu.
Šajā projektā mēs izveidosim IoT balstītu Saules enerģijas uzraudzības sistēmu, iekļaujot uz MPPT (Maximum Power Point Tracker) balstītu akumulatoru uzlādes tehniku, kas palīdzēs samazināt uzlādes laiku un uzlabot efektivitāti. Mēs arī izmērīsim paneļa temperatūru, izejas spriegumu un strāvu, lai uzlabotu ķēdes drošības aspektu. Visbeidzot, lai to visu papildinātu, mēs izmantosim mākoņpakalpojumus ThingSpeak, lai uzraudzītu izejas datus no jebkuras vietas pasaulē. Ņemiet vērā, ka šis projekts ir turpinājums iepriekš izveidotajam MPPT saules uzlādes kontroliera projektam. Šeit mēs uzraudzīsim paneļa izejas spriegumu, strāvu un jaudu, izmantojot ESP32 IoT izstrādes paneli.
Pareizo komponentu izvēle IoT iespējotam saules enerģijas monitoram
Izmantojot saules monitoru, kļūst ļoti viegli uzraudzīt un atklāt kļūdas jebkurā Saules sistēmā. Tāpēc komponentu izvēle kļūst par ļoti svarīgu daļu, izstrādājot šādu sistēmu. Zemāk ir saraksts ar daļām, kuras mēs izmantojām.
- ESP32 dev valde
- MPPT ķēde (var būt jebkura saules ķēde)
- Šunta rezistors (piemēram, 1 Ohm 1 vats - piemērots līdz 1A strāvai)
- Litija akumulators (vēlams 7.4v).
- Aktīvs Wi-Fi savienojums
- Temperatūras sensors saules panelim
- Sprieguma dalītāja ķēde (skatīt aprakstu)
Esp32 Dev padome:
Lietojumprogrammai, kurā iespējota IoT, ir svarīgi izvēlēties pareizā veida attīstības paneli, kas spēs apstrādāt datus no tā analogajām tapām un nosūtīt datus, izmantojot jebkura veida savienojuma protokolu, piemēram, Wi-Fi vai mākoni. serveris. Mēs īpaši izvēlējāmies ESP32, jo tas ir lēts mikrokontrolleris ar daudzām funkcijām. Turklāt tajā ir iebūvēts Wi-Fi radio, caur kuru mēs varam ļoti viegli izveidot savienojumu ar internetu.
Saules ķēde:
Saules uzlādes ķēde ir ķēde, kas saņem lielāku spriegumu no saules paneļa un pārveido to par uzlādes spriegumu, lai tas varētu efektīvi uzlādēt akumulatoru. Šajā projektā mēs izmantosim ar MP35T MPPT lādēšanas kontroliera shēmu, kuru jau esam izveidojuši vienā no mūsu iepriekšējiem projektiem. Bet, ja vēlaties iegult šo IoT iespējotu uzraudzību, varat izmantot jebkura veida saules ķēdi. Mēs izvēlējāmies šo dēli, jo ķēde ir aprīkota ar maksimālās jaudas punktu izsekošanu (MPPT), kas ir izdevīga mazjaudas saules paneļu projektiem. Tas ir efektīvs veids, kā no saules paneļa uzlādēt nelielu litija akumulatoru.
Šunta rezistors:
Jebkurš rezistors ievēro omu likumu, kas nozīmē, ka, ja caur rezistoru plūst noteikts strāvas daudzums, parādīsies noteikts sprieguma kritums. Šunta rezistori nav izņēmums, un to īpaši izmanto strāvas plūsmas mērīšanai. Tomēr, atkarībā no nominālās strāvas plūsmas caur saules paneli, izvēlieties šunta rezistoru, kas radīs pietiekamu sprieguma daudzumu, ko var izmērīt ar mikrokontrollera bloku. Bet tajā pašā laikā svarīga ir arī rezistora jauda. Svarīga ir arī šunta rezistora jaudas izvēle.
Sprieguma kritumu var aprēķināt, izmantojot tālāk sniegto formulu. Tas ir pazīstams kā Ohma likums
V = I x R
V ir spriegums, kas radīsies “I” laikā, ti, strāvas plūsmas daudzums caur rezistora “R” daudzumu. Piemēram, 1 omu rezistors radīs 1 V sprieguma kritumu, kad caur to plūst 1 A strāva.
Rezistora jaudai var izmantot zemāk norādīto formulu-
P = I 2 R
Kur I ir maksimālā strāvas plūsma, un R ir rezistora vērtība. 1A strāvas stiprumam ar 1 omu rezistoru jaudas izkliedēšanai ir pietiekams 1 vats. Tomēr tas ir noderīgi maziem saules paneļu projektiem, bet nepavisam nav piemērots ar saules enerģiju saistītiem lietojumiem. Šādā gadījumā faktiski ir jāizmanto neinvazīvās strāvas mērīšanas tehnika. Šādā gadījumā strāvas plūsmu var precīzi izmērīt tur, kur var izmērīt ļoti mazu strāvas daudzumu, kā arī ļoti lielu strāvas daudzumu.
Litija akumulators:
Litija akumulatora izvēle ir būtiska jebkura projekta sastāvdaļa, kurā iesaistīti saules paneļi. Tā kā mikrokontrolleru vienībai, kas vienmēr paliek ieslēgta un pastāvīgi pārbauda un iesniedz datus, stabilai darbībai ir nepieciešama vismaz simts miliampēru strāvas.
Baterijas ietilpībai vajadzētu būt tādai, kas mikrokontrolleru varētu darbināt vismaz 4-5 dienas, kad musona dēļ saule nespīd. Svarīgi ir arī tas, ka uzlādes strāvai no akumulatora viedokļa jābūt lielākai par slodzes strāvu. Tas ir diezgan neparasti, ja kāds savieno 100mA slodzi ar akumulatoru un nodrošina uzlādes strāvu, kas ir mazāka par to. Lai būtu drošāk, mums vajadzētu būt vismaz 5 reizes lielākai uzlādes strāvai nekā slodzes strāvai.
No otras puses, akumulatora spriegumam jābūt lielākam par jebkuru parasto sprieguma regulatora ieejas spriegumu, kas nepieciešams mikrokontrollerim. Piemēram, 7,4 V litija akumulatoru var pieslēgt gan 3,3 V, gan 5,0 V lineārajam sprieguma regulatoram (jo lineārajam regulatoram ir nepieciešams lielāks izkrišanas spriegums nekā LDO un komutācijai.)
Savā projektā mēs izmantojām 4000mAH akumulatoru ar 7.4V vērtējumu. Mēs izmantojām 5,0 V regulatoru, kas nodrošina pietiekamu strāvas un sprieguma izvadi ESP32.
Sprieguma dalītājs:
Sprieguma dalītājs ir būtiska Saules paneļa sprieguma mērīšanas sastāvdaļa. Jāizvēlas sprieguma dalītājs, kas sadalīs spriegumu atbilstoši mikrokontrollera I / O sprieguma ieejai.
Izvēlieties iepriekš minētos rezistorus tā, lai sprieguma dalītāja izejas spriegums nepārsniegtu mikrokontrollera maksimālo I / O spriegumu (3,3 V ESP32). Tomēr ieteicams izmantot potenciometru, jo tas nodrošinās elastību, izvēloties jebkuru saules paneļa augstāku vai zemāku sprieguma pakāpi, un to var viegli iestatīt, izmantojot multimetru.
Mūsu gadījumā MPPT plates ķēdē mums ir potenciometrs, kas darbojas kā sprieguma dalītājs. Mēs iestatījām sprieguma dalītāju ar dalīšanas koeficientu 6V. Mēs savienojām divus daudzmetrus, vienu ieejas un otru katla izejā, un iestatījām vērtību, ka tad, kad ieejas spriegums ir 18 V, izeja būs 3 V, jo saules paneļa nominālais izejas spriegums ir 18 V.
Temperatūras sensors Saules panelim:
Saules paneļa jaudas izejai ir tieša saikne ar saules paneļa temperatūru. Kāpēc? Tā kā saules paneļa temperatūra sāk palielināt izejas strāvu no saules paneļa eksponenciāli palielinās, kamēr sprieguma izeja sāk lineāri samazināties.
Saskaņā ar jaudas formulu, jauda ir vienāda ar spriegumu reizinātu ar strāvu (W = V x A), samazinoties izejas spriegumam, saules paneļa izejas jauda samazinās arī pēc strāvas plūsmas palielināšanās. Tagad nākamais jautājums, kas mums ienāk prātā, ir, kā izmērīt saules temperatūru? Nu, tas ir diezgan interesanti, jo saules paneļi parasti ir pakļauti siltuma videi, jo acīmredzamu iemeslu dēļ tā ir pakļauta tiešiem saules stariem. Vislabākais saules paneļa temperatūras mērīšanas veids ir plakanas virsmas temperatūras sensors. Ieteicams izmantot arī K tipa termopāri, kas ievietota tieši saules panelī.
Mūsu lietošanai mēs esam izmantojuši termistora bāzes temperatūras sensora moduli, kas parādīts zemāk.
IoT balstītas saules enerģijas uzraudzības shēmas shēma
Pilna IoT iespējotā saules enerģijas monitora shēma ir parādīta zemāk. Shēma ir vienkārša. Sarkanais domuzīme-dēlis ir MPPT dēlis, kuru izmantojām šim projektam.
ThingSpeak iestatīšana
Izveidojiet kontu ar ThingSpeak un dodieties uz opciju “mans kanāls”, pēc tam noklikšķiniet uz Jauns kanāls.
Izveidojiet jaunu kanālu ar lauku nosaukumiem.
Pēc lauka iestatīšanas dodieties uz lauku API atslēgas, kur ir pieejama API rakstīšanas atslēga. Šī atslēga ir jānorāda kodā, kā arī kanāla ID.
ThingSpeak adresi var atrast tajā pašā lapā.
Veicot iepriekš minētās darbības, jūs varat ļoti viegli iestatīt ThingSpeak. Ja vēlaties uzzināt vairāk par ThingSpeak un tā iestatīšanas procesu, varat apskatīt mūsu iepriekšējos rakstus par šo tēmu.
Arduino kods saules enerģijas uzraudzībai, izmantojot ESP32
Pilns ESP32 saules enerģijas uzraudzības kods ir atrodams šīs lapas apakšdaļā. Kods sākas ar jūsu SSID, paroles un dažu citu nemainīgu parametru noteikšanu, kā parādīts zemāk.
// definējiet WiFi SSID un PWD augšupielādei. #define WLAN_SSID "xxxx" #define WLAN_PASS "xxxxxxxxxx"
// pretestība 25 grādos C #define THERMISTORNOMINAL 10000 // temp. nominālajai pretestībai (gandrīz vienmēr 25 C) #define TEMPERATURENOMINAL 25 // Termistora beta koeficients (parasti 3000-4000) #define BCOEFFICIENT 3950 // "cita" rezistora vērtība #define SERIESRESISTOR 10000
Termistora nominālie omi tiek nodrošināti nominālā temperatūrā. Iestatiet šo vērtību atkarībā no termistora datu lapas. Ielieciet termistora Beta koeficienta un sērijas rezistora vērtību.
// definēt analogu strāvai un spriegumam const int curr_an_pin = 35; const int volt_an_pin = 34; const int ntc_temp_an_pin = 33;
PIN šeit ir definēti.
#define thingSpeakAddress "xxxxxxxxx" #define channelID xxxxx #define writeFeedAPIKey "xxxxxxx" #define readFeedAPIKey "xxxxxxx" #define readFieldAPIKey "xxxxxxxx" #define readStatusAPIKey "xxxxxxx"
Ielieciet lietuSpeakAddress, channelID, Write Feed API Key. Pārējās lietas nav nepieciešamas, taču tās joprojām ir noderīgas, ja dati jāsaņem no tīmekļa.
void setup () { // šeit ievietojiet iestatīšanas kodu, lai tas darbotos vienreiz: // iestatiet seriālo portu uz 115200 Serial.begin (115200); // Inicializēt sērijas aizkavi (1000); WiFi.mode (WIFI_STA); ThingSpeak.begin (klients); // Inicializējiet ThingSpeak // todo: izveidojiet uzdevumu, lai nolasītu tapu, lai iegūtu strāvu un spriegumu, un aprēķina saules paneļa vatu un temperatūru xTaskCreate ( wifi_task, / * Task function. * / "Wifi_task", / * String ar nosaukumu uzdevums. * / 1024 * 2, / * Steka lielums baitos. * / NULL, / * Parametrs nodots kā uzdevuma ievads * / 5, / * Uzdevuma prioritāte. * / NULL); / * Uzdevuma rokturis. * / Serial.print ("Datu lasīšana"); }
Iepriekš minētajā kodā tiek inicializēts serveris ThingSpeak un izveidots uzdevums, kas iegūs datus, kas saistīti ar saules paneli.
Galvenajā kontūrā saules strāva un spriegums tiek uztverti, izmantojot analogo tapu, un tiek veikts vidējais rādītājs.
pludiņš solar_curr_adc_val = 0; pludiņš saules_volt_adc_val = 0; par (i = 0; i <NUMURI; i ++) { curr_samples = analogRead (curr_an_pin); volt_samples = analogRead (volt_an_pin); temp_samples = analogRead (ntc_temp_an_pin); kavēšanās (10); } // vidējais visu izlašu skaits float curr_avg = 0; pludiņš volt_avg = 0; pludiņa temp_avg = 0; par (i = 0; i <NUMURI; i ++) { curr_avg + = curr_samples; volt_avg + = volt_paraugi; temp_avg + = temp_paraugi; } curr_avg / = NUMURI; volt_avg / = NUMURI; temp_avg / = NUMURI; //Serial.print("ADC VALUE = "); //Serial.println(ADC_VALUE); // konvertēt ADC vērtību spriegumos, lai iegūtu faktisko strāvu un spriegumu. pludiņš saules_curr = (curr_avg * 3.3) / (4095); pludiņš saules_volt = (volt_avg * 3,3) / (4095); // izmantojot sprieguma dalītāju, mēs pazeminām faktisko spriegumu. // šī iemesla dēļ mēs reizinām 6 ar vidējo spriegumu, lai iegūtu faktisko saules paneļa spriegumu. saules_volt * = 6;
Saules spriegums tiek iesniegts, reizinot ar 6, jo mēs izveidojām sprieguma dalītāju, kas ieejas spriegumu sadalīs 6 reizes.
Temperatūra tiek ģenerēta no termistora, izmantojot logaritmisko veidojumu.
// pārvērst vērtību pretestībā temp_avg = 4095 / temp_avg - 1; temp_avg = SERIESRESISTOR / temp_avg; //Serial.print("Termistora pretestība "); //Serial.println(temp_avg); pludiņš Steinhart; steinhart = temp_avg / THERMISTORNOMINAL; // (R / Ro) steinhart = log (steinhart); // ln (R / Ro) steinhart / = IESPĒJAMAIS; 1 / B * ln (R / Ro) steinhart + = 1,0 / (TEMPERATURENOMINAL + 273,15); // + (1 / Uz) Steinhart = 1,0 / Steinhart; // Apgriezt steinhartu - = 273,15; // konvertēt absolūto temperatūru uz C
Dati tiek nolasīti ik pēc 15 sekundēm.
kavēšanās (1000); skaits ++; Sērijas.druka ("."); ja (skaitīt> = 15) { skaitīt = 0; Serial.println ("=============================================== =========================== ""; Serial.print ("Saules spriegums ="); Serial.println (saules_volt); Serial.print ("Saules strāva ="); Seriālais.println (saules_krāsa); pludiņš solar_watt = solar_volt * solar_curr; Serial.print ("Saules vats ="); Serial.println (saules_vats); Serial.print ("Saules temperatūra ="); Seriālais.println (steinhart); Serial.println ("=============================================== =========================== "";
Dati par attiecīgajiem laukiem tiek pārsūtīti, izmantojot funkciju Thing.Speak.setField (); kad ir pievienots WiFi.
ja (WiFi.status () == WL_CONNECTED) { ThingSpeak.setField (1, solar_volt); ThingSpeak.setField (2, saules_curr); ThingSpeak.setField (3, saules_vats); ThingSpeak.setField (4, Steinhart); // rakstīt ThingSpeak kanālā int x = ThingSpeak.writeFields (channelID, writeFeedAPIKey); if (x == 200) { Serial.println ("Kanālu atjaunināšana ir veiksmīga."); } else { Serial.println ("Kanāla atjaunināšanas problēma. HTTP kļūdas kods" + virkne (x)); } } else { Serial.println ("\ r \ n ######################################################## ######################### "); Serial.println ("Neizdevās atjaunināt datus uz thingSpeak Server."); Serial.println ("WiFi nav izveidots savienojums…"); Serial.println ("################################################################# ############### \ r \ n "); } Serial.print ("Datu lasīšana"); } }
Wi-Fi uzdevums, kas izveidots zemāk esošajā koda fragmentā-
void wifi_task (void * parametrs) { while (1) { if (WiFi.status ()! = WL_CONNECTED) { Serial.print ("Mēģinājums izveidot savienojumu ar SSID:"); Serial.println (WLAN_SSID); while (WiFi.status ()! = WL_CONNECTED) { WiFi.begin (WLAN_SSID, WLAN_PASS); // Savienojuma izveide ar WPA / WPA2 tīklu. Mainiet šo līniju, ja izmantojat atvērto vai WEP tīklu Serial.print ("."); kavēšanās (5000); } Serial.println ("\ nSavienots."); Seriālais.println (); Serial.println ("savienots ar WiFi"); Serial.println ("IP adrese:"); Serial.println (WiFi.localIP ()); } vTaskDelay (1000 / portTICK_PERIOD_MS); } vTaskDelete (NULL); }
Datu pārbaude un uzraudzība
Saules panelis ir savienots ar ķēdi un ievietots saules gaismā testēšanai, kā parādīts zemāk.
Pilnīga darbība ir parādīta zemāk esošajā video. Mūsu ķēde varēja nolasīt paneļa izejas spriegumu, strāvu un jaudu un atjaunināt to tiešraidē pa lietu kanāla kanālu, kā parādīts tālāk.
Kā redzam, iepriekšminētajā diagrammā ir parādīti 15 minūšu dati. Tā kā tas ir āra darbības projekts, ir jāizmanto pareizs PCB kopā ar pievienoto lodziņu. Korpuss ir jāveido tā, lai lietus laikā ķēde paliktu ūdensizturīga. Lai modificētu šo shēmu vai apspriestu citus šī projekta aspektus, lūdzu, izmantojiet Circuit Digest aktīvo forumu. Ceru, ka jums patika apmācība un uzzinājāt kaut ko noderīgu.