Iotbaserad solpaneleffektövervakning med esp32 och thingspeak

Inom området förnybar energi ligger solenergi i framkant, för att producera energi genom att använda kraften från solen är det enklaste och kommersiellt genomförbara sättet för förnybar energi. På tal om solpaneler måste uteffekten från solpanelens utgång övervakas för att få maximal effekt från panelerna. Det är därför ett övervakningssystem i realtid blir nödvändigt. I ett stort solkraftverk kan det också användas för att övervaka effektutgången från varje panel som hjälper till att identifiera dammuppbyggnaden. Det förhindrar också felförhållanden under driftstiden. I några av våra tidigare artiklar har vi byggt ett par solenergirelaterade projekt som en soldriven mobiltelefonladdare och solomvandlare, etc. Du kan kolla in dem om du letar efter fler projekt om solenergi.

I det här projektet kommer vi att skapa ett IoT-baserat övervakningssystem för solenergi genom att inkludera MPPT (Maximum Power Point Tracker) -baserad batteriladdningsteknik, vilket hjälper till att minska laddningstiden och förbättra effektiviteten. Vi kommer också att mäta paneltemperaturen, utspänningen och strömmen för att förbättra kretsens säkerhetsaspekt. Slutligen, för att toppa allt, kommer vi att använda ThingSpeak molntjänster för att övervaka utdata från var som helst runt om i världen. Observera att detta projekt är en fortsättning på MPPT Solar Charge Controller Project som vi byggde tidigare. Här kommer vi att övervaka panelens utgångsspänning, ström och effekt med hjälp av ESP32 IoT-utvecklingskortet.

Välja rätt komponenter för IoT-aktiverad solenergimonitor

Med en solskärm blir det mycket enkelt att övervaka och upptäcka fel i vilket solsystem som helst. Det är därför som komponentval blir en mycket viktig del när man utformar ett sådant system. Nedan följer listan över delar som vi använde.

ESP32 dev-kort
MPPT-krets (kan vara vilken som helst solkrets)
Ett shuntmotstånd (till exempel 1 Ohm 1 watt - lämpligt för upp till 1A ström)
Ett litiumbatteri (7,4 v föredras).
Aktiv Wi-Fi-anslutning
Temperaturgivare för solpanelen
Spänningsdelarkrets (se beskrivning)

Esp32 Dev Board:

För en IoT-aktiverad applikation är det viktigt att välja rätt typ av utvecklingskort som kommer att kunna bearbeta data från sina analoga stift och skicka data via alla typer av anslutningsprotokoll som Wi-Fi eller till molnet server. Vi valde specifikt ESP32 eftersom det är en billig mikrokontroller med massor av funktioner. Dessutom har den en inbyggd Wi-Fi-radio genom vilken vi enkelt kan ansluta till internet.

Solkrets:

En solladdningskrets är en krets som får högre spänning från solpanelen och omvandlar den till en laddningsspänning så att den effektivt kan ladda batteriet. För detta projekt kommer vi att använda det LT3562-baserade MPPT Charge Controller Circuit Board som vi redan har gjort i ett av våra tidigare projekt. Men om du vill bädda in denna IoT-aktiverade övervakning kan du använda vilken som helst solcirkel. Vi har valt detta kort eftersom kretsen är utrustad med Maximum Power Point Tracking (MPPT), vilket är fördelaktigt för solpanelprojekt med låg effekt. Det är ett effektivt sätt att ladda ett litet litiumbatteri från en solpanel.

Shuntmotstånd:

Varje motstånd följer ohmens lag, vilket innebär att om en viss mängd ström strömmar genom motståndet, kommer en viss mängd spänningsfall att visas. Shuntmotstånd är inte ett undantag från detta och det används specifikt för att mäta strömflödet. Beroende på det nominella strömflödet genom solpanelen väljer du dock ett shuntmotstånd som producerar en tillräcklig mängd spänning som kan mätas av mikrokontrollenheten. Men samtidigt är motståndets watt också en viktig sak. Val av shuntmotståndseffekt är också viktigt.

Spänningsfallet kan beräknas med formeln nedan. Detta kallas Ohms lag-

V = I x R

V är spänningen som kommer att produceras under "I" dvs mängden strömflöde genom mängden motstånd "R". Till exempel kommer 1 ohm motstånd att producera 1V spänningsfall när 1A ström strömmar genom den.

För motståndets wattförbrukning kan formeln nedan ges -

P = I ² R

Där I är det maximala strömflödet och R är motståndsvärdet. För 1A ström med 1 ohm motstånd är 1 watt tillräcklig för effektförlusten. Detta är dock användbart för små solpanelprojekt men inte alls lämpligt för solnätrelaterade applikationer. I ett sådant fall är den icke-invasiva mättekniken faktiskt vad som måste användas. I ett sådant fall kan strömflödet mätas exakt där en mycket låg ström, såväl som en mycket hög ström, kan mätas.

Litiumbatteri:

Valet av litiumbatteri är en viktig del av alla projekt som involverar solpaneler. Eftersom mikrokontroller-enheten som alltid är på och ständigt kontrollerar och skickar in data krävs minst hundra milliampere ström för stabil drift.

Batterikapaciteten bör vara något som kan driva mikrokontrollern i minst 4-5 dagar när solen inte skiner på grund av monsunen. Det är också viktigt att laddströmmen måste vara mer än laddströmmen ur batteriperspektivet. Det är ganska ovanligt om någon ansluter 100 mA belastning med ett batteri och ger en laddningsström, vilket är mindre än så. För att vara på den säkrare sidan borde vi ha minst 5 gånger mer laddström än lastströmmen.

Å andra sidan måste batterispänningen vara högre än någon vanlig spänningsregulatorinspänning som krävs för mikrokontrollern. Till exempel kan ett 7,4 V litiumbatteri anslutas över både 3,3 V och 5,0 V linjär spänningsregulator (eftersom linjär regulator kräver högre utfallsspänning mer än LDO och Switching.)

I vårt projekt använde vi ett 4000mAH batteri med 7,4 V-klass. Vi använde en 5.0V-regulator som ger tillräcklig ström och spänningsutgång för ESP32.

Spänningsdelare:

En spänningsdelare är en viktig del av solpanelens spänningsmätning. Man bör välja en spänningsdelare som delar spänningen enligt mikrokontrollerns I / O-spänningsingång.

Välj ovanstående motstånd på ett sådant sätt att spänningsdelarens utgångsspänning inte ska överstiga mikrostyrenhetens maximala I / O-spänning (3,3 V för ESP32). Det rekommenderas dock att använda en potentiometer eftersom det ger flexibilitet att välja vilken som helst solpanel med högre eller lägre spänning och kan enkelt ställa in spänningen med en multimeter.

I vårt fall har vi en potentiometer i MPPT-kretskretsen som fungerar som en spänningsdelare. Vi ställer in spänningsdelaren med en delningsfaktor på 6V. Vi kopplade in två multimetrar, en i ingången och en annan i utgången på potten, och ställde in värdet att när ingångsspänningen är 18V kommer utgången att vara 3V eftersom solpanelens nominella utgångsspänning är 18V.

Temperaturgivare för solpanelen:

Solpanelens uteffekt har en direkt anslutning till solpanelens temperatur. Varför? Eftersom en solpanels temperatur börjar öka utströmmen från solpanelen ökar exponentiellt medan spänningsutgången börjar minska linjärt.

Enligt effektformeln är Wattage lika med spänning gånger ström (W = V x A), minskande utspänning minskar också solpanelens uteffekt även efter att strömflödet har ökat. Nu är nästa fråga som kommer att tänka på oss, hur man mäter soltemperaturen? Tja, det är ganska intressant eftersom solpaneler i allmänhet utsätts för värmemiljön eftersom de utsätts för direkt solljus och av uppenbara skäl. Det bästa sättet att mäta solpanelens temperatur är att använda en sensor för plan yttemperatur. Det föreslås också att man använder ett termoelement av K-typ som placeras direkt i solpanelen.

För vår applikation har vi använt en termistorbaserad temperatursensormodul, som visas nedan.

Kretsschema för IoT-baserad övervakning av solenergi

Det fullständiga kretsschemat för IoT Enabled Solar Power Monitor visas nedan. Schemat är enkelt. Den röda bindestreckbrädan är MPPT-kortet som vi använde för detta projekt.

Ställa in ThingSpeak

Skapa ett konto med ThingSpeak och gå till alternativet “min kanal” och klicka sedan på den nya kanalen.

Skapa en ny kanal med fältnamnen.

Efter att du har ställt in fältet, gå till fältet API-nycklar där skriv-API-nyckeln är tillgänglig. Denna nyckel måste anges i koden såväl som i kanal-ID.

ThingSpeak-adressen finns på samma sida.

Med ovanstående steg kan du ställa in ThingSpeak mycket enkelt. Om du vill lära dig mer om ThingSpeak och dess installationsprocess kan du kolla in våra tidigare artiklar om ämnet.

Arduino-kod för övervakning av solenergi med ESP32

Den fullständiga övervakningskoden för solenergi ESP32 finns längst ner på denna sida. Koden börjar med att definiera ditt SSID, lösenord och några andra konstanta parametrar som visas nedan.

// definiera WiFi SSID & PWD för upplänkning. #define WLAN_SSID "xxxx" #define WLAN_PASS "xxxxxxxxxx"

// motstånd vid 25 grader C #define THERMISTORNOMINAL 10000 // temp. för nominellt motstånd (nästan alltid 25 C) #define TEMPERATURENOMINAL 25 // Termistorns beta-koefficient (vanligtvis 3000-4000) #define BCOEFFICIENT 3950 // värdet på det "andra" motståndet #define SERIESRESISTOR 10000

Termistorns nominella ohm tillhandahålls vid den nominella temperaturen. Ställ in detta värde beroende på databladet för termistorn. Sätt termistorns Betakoefficient och seriemotståndsvärde.

// definiera Analog för ström och spänning const int curr_an_pin = 35; const int volt_an_pin = 34; const int ntc_temp_an_pin = 33;

PIN-koden definieras här.

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

Sätt sakenSpeakAddress, channelID, Write Feed API Key. Resten av sakerna krävs inte men är ändå användbara om data måste tas emot från webben.

ogiltig inställning () { // placera din installationskod här, för att köra en gång: // ställ in seriell port på 115200 Serial.begin (115200); // Initiera seriell fördröjning (1000); WiFi-läge (WIFI_STA); ThingSpeak.begin (klient); // Initiera ThingSpeak // todo: skapa en uppgift för att läsa en pin för att få ström och spänning och beräkna watt och temperatur på solpanelen xTaskCreate ( wifi_task, / * Task-funktion. * / "Wifi_task", / * Sträng med namn på uppgift. * / 1024 * 2, / * Stackstorlek i byte. * / NULL, / * Parameter skickad som inmatning av uppgiften * / 5, / * Uppgiftens prioritet. * / NULL); / * Aktivitetshandtag. * / Serial.print ("Data Reading."); }

I ovanstående kod initialiseras ThingSpeak-servern och en uppgift skapas som kommer att få informationen relaterad till solpanelen.

I huvudslingan avkänns solströmmen och spänningen via en analog stift och genomsnittet görs.

float solar_curr_adc_val = 0; float solar_volt_adc_val = 0; för (i = 0; i <NUMSAMPLES; i ++) { curr_samples = analogRead (curr_an_pin); volt_samples = analogRead (volt_an_pin); temp_samples = analogRead (ntc_temp_an_pin); fördröjning (10); } // genomsnitt alla prover ut float curr_avg = 0; float volt_avg = 0; float temp_avg = 0; för (i = 0; i <NUMSAMPLES; i ++) { curr_avg + = curr_samples; volt_avg + = volt_samples; temp_avg + = temp_samples; } curr_avg / = NUMSAMPEL; volt_avg / = NUMSAMPLES; temp_avg / = NUMSAMPLES; //Serial.print("ADC VALUE = "); //Serial.println(ADC_VALUE); // konvertera adc-värde till spänningar för att få aktuell ström och spänning. float solar_curr = (curr_avg * 3.3) / (4095); float solar_volt = (volt_avg * 3.3) / (4095); // genom att använda en spänningsdelare stegar vi ner den faktiska spänningen. // av den anledningen multiplicerar vi 6 med genomsnittlig spänning för att få solpanelens faktiska spänning. solar_volt * = 6;

Solspänningen skickas genom att multiplicera med 6 när vi skapade spänningsdelaren som delar ingångsspänningen med 6 gånger.

Temperaturen genereras från termistorn med hjälp av en logaritmisk formation.

// konvertera värdet till motstånd temp_avg = 4095 / temp_avg - 1; temp_avg = SERIESRESISTOR / temp_avg; //Serial.print("Thermistor-motstånd "); //Serial.println(temp_avg); float steinhart; steinhart = temp_avg / THERMISTORNOMINAL; // (R / Ro) steinhart = log (steinhart); // ln (R / Ro) steinhart / = BCOEFFICIENT; // 1 / B * ln (R / Ro) steinhart + = 1,0 / (TEMPERATURENOMINAL + 273,15); // + (1 / To) steinhart = 1.0 / steinhart; // Invertera steinhart - = 273,15; // konvertera absolut temp till C.

Data läses var 15: e sekund.

fördröjning (1000); räkna ++; Serial.print ("."); if (count> = 15) { count = 0; Serial.println ("================================================ ============================== "); Serial.print ("Solar Voltage ="); Serial.println (solar_volt); Serial.print ("Solar Current ="); Serial.println (solar_curr); float solar_watt = solar_volt * solar_curr; Serial.print ("Solar Watt ="); Serial.println (solar_watt); Serial.print ("Soltemperatur ="); Serial.println (steinhart); Serial.println ("================================================ ============================== ");

Data för respektive fält överförs med funktionen Thing.Speak.setField (); när WiFi är anslutet.

om (WiFi.status () == WL_CONNECTED) { ThingSpeak.setField (1, solar_volt); ThingSpeak.setField (2, solar_curr); ThingSpeak.setField (3, solar_watt); ThingSpeak.setField (4, steinhart); // skriv till ThingSpeak-kanalen int x = ThingSpeak.writeFields (channelID, writeFeedAPIKey); if (x == 200) { Serial.println ("Uppdatering av kanaler lyckades."); } annat { Serial.println ("Problem med att uppdatera kanal. HTTP-felkod" + Sträng (x)); } } övrigt { Serial.println ("\ r \ n ############################################################### ## ######################### "); Serial.println ("Det gick inte att uppdatera data till thingSpeak Server."); Serial.println ("WiFi inte ansluten…"); Seriell.println ("########################################################################### föregå ################ \ r \ n "); } Serial.print ("Data Reading."); } }

Wi-Fi-uppgiften som skapats i kodavsnittet nedan

void wifi_task (void * parameter) { while (1) { if (WiFi.status ()! = WL_CONNECTED) { Serial.print ("Att försöka ansluta till SSID:"); Serial.println (WLAN_SSID); medan (WiFi.status ()! = WL_CONNECTED) { WiFi.begin (WLAN_SSID, WLAN_PASS); // Anslut till WPA / WPA2-nätverk. Ändra den här raden om du använder ett öppet eller WEP-nätverk Serial.print ("."); fördröjning (5000); } Serial.println ("\ nConnected."); Serial.println (); Serial.println ("WiFi-ansluten"); Serial.println ("IP-adress:"); Serial.println (WiFi.localIP ()); } vTaskDelay (1000 / portTICK_PERIOD_MS); } vTaskDelete (NULL); }

Testning och övervakning av data

Solpanelen är ansluten till kretsen och placeras i solljuset för testning enligt nedan.

Det fullständiga arbetet visas i videon nedan. Vår krets kunde läsa utgångsspänningen, strömmen och strömmen från panelen och uppdatera den live på ThingsPeak-kanalen som visas nedan.

Som vi kan se visas 15-minutersdata i ovanstående diagram. Eftersom detta är ett utomhusoperationsprojekt måste rätt PCB tillsammans med en sluten låda användas. Skåpet måste göras så att kretsen förblir vattentät i regn. För att modifiera denna krets eller för att diskutera ytterligare aspekter av detta projekt, vänligen använd det aktiva forumet för Circuit Digest. Hoppas att du gillade självstudien och lärde dig något användbart.