- Velge riktige komponenter for IoT-aktivert solcellemonitor
- Kretsdiagram for IoT-basert solenergiovervåking
- Sette opp ThingSpeak
- Arduino-kode for solenergiovervåking ved hjelp av ESP32
- Testing og overvåking av data
Innen fornybar energi er solenergi i forkant, fordi det å produsere energi ved å bruke solens kraft er den enkleste og kommersielt levedyktige måten å fornybar energi på. Når vi snakker om solcellepaneler, må utgangseffekten til et solcellepanelutgang overvåkes for å få optimal effekt fra panelene. Dette er grunnen til at et sanntidsovervåkingssystem blir nødvendig. I et stort solkraftverk kan det også brukes til å overvåke effekten fra hvert panel som hjelper til med å identifisere støvoppbyggingen. Det forhindrer også eventuelle feilforhold i løpet av driftstiden. I noen av våre tidligere artikler har vi bygget noen få solenergirelaterte prosjekter som en soldrevet mobiltelefonlader og solenergi-inverterkrets osv. Du kan sjekke dem ut hvis du leter etter flere prosjekter om solenergi.
I dette prosjektet skal vi lage et IoT-basert solenergiovervåkingssystem ved å innlemme MPPT (Maximum Power Point Tracker) - basert batteriladingsteknikk, som vil bidra til å redusere ladetiden og forbedre effektiviteten. Vi måler også panelets temperatur, utgangsspenning og strøm for å forbedre kretsens sikkerhetsaspekt. Til slutt, for å toppe det hele, skal vi bruke ThingSpeak-skytjenestene til å overvåke utdataene fra hvor som helst i verden. Merk at dette prosjektet er en fortsettelse av MPPT Solar Charge Controller Project som vi bygde tidligere. Her vil vi overvåke utgangsspenningen, strømmen og kraften til panelet ved hjelp av ESP32 IoT-utviklingskortet.
Velge riktige komponenter for IoT-aktivert solcellemonitor
Med en solskjerm blir det veldig enkelt å overvåke og oppdage feil i ethvert solsystem. Dette er grunnen til at valg av komponenter blir en veldig viktig del når du designer et slikt system. Nedenfor er listen over deler vi brukte.
- ESP32 dev-kort
- MPPT-krets (kan være hvilken som helst solkrets)
- En shuntmotstand (for eksempel 1 Ohm 1 watt - egnet for opptil 1A strøm)
- Et litiumbatteri (7,4 v foretrukket).
- Aktiv Wi-Fi-tilkobling
- Temperatursensor for solcellepanelet
- Spenningsdelerkrets (se beskrivelsen)
Esp32 Dev Board:
For et IoT-aktivert program er det viktig å velge riktig type utviklingskort som vil kunne behandle dataene fra de analoge pinnene og sende dataene via en hvilken som helst tilkoblingsprotokoll som Wi-Fi eller til skyen. server. Vi valgte spesielt ESP32, da det er en billig mikrokontroller med mange funksjoner. Dessuten har den en innebygd Wi-Fi-radio der vi enkelt kan koble til internett.
Solkrets:
En soladekrets er en krets som får høyere spenning fra solcellepanelet og konverterer den ned til en ladespenning slik at den effektivt kan lade batteriet. For dette prosjektet vil vi bruke det LT3562-baserte MPPT Charge Controller Circuit Board som vi allerede har laget i et av våre tidligere prosjekter. Men hvis du vil bygge inn denne IoT-aktiverte overvåkingen, kan du bruke alle slags solkretser. Vi har valgt dette kortet fordi kretsen er utstyrt med Maximum Power Point Tracking (MPPT) som er gunstig for prosjekter med lavt solcellepanel. Det er en effektiv måte å lade et lite litiumbatteri fra et solcellepanel.
Shunt motstand:
Enhver motstand følger ohmens lov, noe som betyr at hvis en viss strøm strømmer gjennom motstanden, vil en viss mengde spenningsfall vises. Shuntmotstander er ikke et unntak av dette, og det brukes spesielt til å måle strømmen. Avhengig av den nominelle strømmen gjennom solcellepanelet, velg imidlertid en shuntmotstand som vil produsere en tilstrekkelig mengde spenning som kan måles av mikrokontrollerenheten. Men samtidig er motstandens wattstyrke også en viktig ting. Valg av shuntmotstandseffekten er også viktig.
Spenningsfallet kan beregnes med formelen gitt nedenfor. Dette er kjent som Ohms lov-
V = I x R
V er spenningen som blir produsert under 'I', dvs. mengden strøm som strømmer gjennom motstanden 'R'. For eksempel vil 1 ohm motstand produsere 1V spenningsfall når 1A strøm strømmer gjennom den.
For motstandens wattforbruk kan formelen gitt nedenfor brukes-
P = I 2 R
Der jeg er den maksimale strømmen, og R er motstandsverdien. For 1A strøm med 1 ohm motstand er 1 watt tilstrekkelig for strømforsyningen. Dette er imidlertid nyttig for små solcellepanelprosjekter, men ikke i det hele tatt egnet for solnettrelaterte applikasjoner. I et slikt tilfelle er den ikke-invasive strømmålingsteknikken faktisk det som må brukes. I et slikt tilfelle kan strømmen måles nøyaktig hvor det kan måles en veldig liten mengde strøm, så vel som en veldig høy mengde strøm.
Litiumbatteri:
Valget av litiumbatteri er en viktig del av ethvert prosjekt som involverer solcellepaneler. Fordi mikrokontrollerenheten som alltid er på og kontinuerlig sjekker og sender inn data, krever minst hundre milliampere strøm for stabil drift.
Batterikapasiteten bør være noe som kan drive mikrokontrolleren i minst 4-5 dager når solen ikke skinner på grunn av monsunen. Det er også viktig at ladestrømmen må være mer enn laststrømmen fra batteriperspektivet. Det er ganske uvanlig hvis noen kobler 100mA last med et batteri og gir en ladestrøm, som er mindre enn det. For å være på den sikrere siden, bør vi ha minst 5 ganger mer ladestrøm enn laststrømmen.
På den annen side må batterispenningen være høyere enn noen vanlig spenningsregulatorens inngangsspenning som kreves for mikrokontrolleren. For eksempel kan et 7,4 V litiumbatteri kobles til både 3,3 V og 5,0 V lineær spenningsregulator (ettersom lineær regulator krever høyere frafallsspenning mer enn LDO og Switching.)
I prosjektet vårt brukte vi et 4000mAH batteri med en 7,4V vurdering. Vi brukte en 5.0V regulator som gir tilstrekkelig strøm og spenningsutgang for ESP32.
Spenningsdeler:
En spenningsdeler er en viktig del av solpanelets spenningsmåling. Man bør velge en spenningsdeler som vil dele spenningen i henhold til mikrokontrollers I / O-spenningsinngang.
Velg motstandene ovenfor på en slik måte at spenningsdelerens utgangsspenning ikke skal overstige mikrokontrollerens maksimale I / U-spenning (3,3 V for ESP32). Det anbefales imidlertid å bruke et potensiometer fordi det vil gi fleksibilitet til å velge hvilken som helst solcellepanel høyere eller lavere spenningsgrad og kan enkelt stille spenningen ved hjelp av et multimeter.
I vårt tilfelle har vi et potensiometer i MPPT-kortkretsen som fungerer som en spenningsdeler. Vi setter spenningsdeleren med en delingsfaktor på 6V. Vi koblet til to multimeter, en i inngangen og en annen i utgangen til potten, og satte verdien at når inngangsspenningen er 18V, vil utgangen være 3V siden den nominelle utgangsspenningen til solcellepanelet er 18V.
Temperatursensor for solcellepanelet:
Solcelleeffekt har en direkte forbindelse med temperaturen på solcellepanelet. Hvorfor? Fordi når et solcellepanel temperatur begynner å øke utgangsstrømmen fra solcellepanelet øker eksponentielt mens spenningsutgangen begynner å redusere lineært.
I henhold til kraftformelen er Wattage lik spenning ganger strøm (W = V x A), reduserende utgangsspenning reduserer også solcellepanelets utgangseffekt selv etter økning av strømmen. Nå er det neste spørsmålet som kommer opp i tankene våre, hvordan måler vi soltemperaturen? Vel, det er ganske interessant ettersom solcellepaneler generelt blir utsatt for varmemiljøet ettersom de utsettes for direkte sollys og av åpenbare grunner. Den beste måten å måle temperaturen på solcellepanelet er ved å bruke en temperaturføler med flat overflate. Det anbefales også å bruke et K-termoelement plassert direkte i solcellepanelet.
For vår applikasjon har vi brukt en termistorbasert temperatursensormodul, som er vist nedenfor.
Kretsdiagram for IoT-basert solenergiovervåking
Det komplette kretsskjemaet for IoT Enabled Solar Power Monitor er vist nedenfor. Skjematisk er enkelt. Det røde dash-dot-kortet er MPPT-kortet som vi brukte til dette prosjektet.
Sette opp ThingSpeak
Opprett en konto med ThingSpeak og gå til alternativet “min kanal”, og klikk deretter på den nye kanalen.
Opprett en ny kanal med feltnavnene.
Nå etter å ha angitt feltet, gå til API-nøkler- feltet der Write API-nøkkelen er tilgjengelig. Denne nøkkelen må oppgis i koden så vel som i kanal-ID-en.
ThingSpeak-adressen finner du på samme side.
Med trinnene ovenfor kan du sette opp ThingSpeak veldig enkelt. Hvis du vil lære mer om ThingSpeak og installasjonsprosessen, kan du sjekke ut våre tidligere artikler om emnet.
Arduino-kode for solenergiovervåking ved hjelp av ESP32
Den komplette koden for overvåking av solenergi ESP32 finner du nederst på denne siden. Koden begynner med å definere SSID, passord og noen få andre konstante parametere som vist nedenfor.
// definere WiFi SSID og PWD for uplink. #define WLAN_SSID "xxxx" #define WLAN_PASS "xxxxxxxxxx"
// motstand ved 25 grader C #definer THERMISTORNOMINAL 10000 // temp. for nominell motstand (nesten alltid 25 C) #define TEMPERATURENOMINAL 25 // Beta-koeffisienten til termistoren (vanligvis 3000-4000) #define BCOEFFICIENT 3950 // verdien av den 'andre' motstanden #define SERIESRESISTOR 10000
Termistorens nominelle ohm er gitt ved den nominelle temperaturen. Still denne verdien avhengig av databladet til termistoren. Sett Beta-koeffisienten og seriemotstanden til termistoren.
// definer Analog for Strøm og Spenning const int curr_an_pin = 35; const int volt_an_pin = 34; const int ntc_temp_an_pin = 33;
PIN-kodene er definert her.
#define thingSpeakAddress "xxxxxxxxx" #define channelID xxxxx #define writeFeedAPIKey "xxxxxxx" #define readFeedAPIKey "xxxxxxx" #define readFieldAPIKey "xxxxxxxx" #define readStatusAPIKey "xxxxxxx"
Sett tingSpeakAddress, channelID, Write Feed API Key. Resten av tingene er ikke påkrevd, men er fortsatt nyttige hvis data må mottas fra nettet.
ugyldig oppsett () { // legg oppsettkoden din her, for å kjøre en gang: // sett serieporten til 115200 Serial.begin (115200); // Initialiser seriell forsinkelse (1000); WiFi-modus (WIFI_STA); ThingSpeak.begin (klient); // Initialiser ThingSpeak // todo: opprett en oppgave for å lese en pinne for å få strøm og spenning og beregne watt og temperatur på solcellepanelet xTaskCreate ( wifi_task, / * Task function. * / "Wifi_task", / * Streng med navn på oppgave. * / 1024 * 2, / * Størrelsesstørrelse i byte. * / NULL, / * Parameter sendt som input av oppgaven * / 5, / * Prioritet for oppgaven. * / NULL); / * Oppgavehåndtak. * / Serial.print ("Data Reading."); }
I koden ovenfor initialiseres ThingSpeak-serveren og det opprettes en oppgave som vil få data relatert til solcellepanelet.
I hovedsløyfen registreres solstrømmen og spenningen via en analog pin, og gjennomsnittet gjøres.
flyte solar_curr_adc_val = 0; flyte solar_volt_adc_val = 0; for (i = 0; i <NUMSAMPLES; i ++) { curr_samples = analogRead (curr_an_pin); volt_samples = analogRead (volt_an_pin); temp_samples = analogRead (ntc_temp_an_pin); forsinkelse (10); } // gjennomsnitt alle prøvene ut float curr_avg = 0; flyte volt_avg = 0; flyte temp_avg = 0; for (i = 0; i <NUMSAMPLES; i ++) { curr_avg + = curr_samples; volt_avg + = volt_samples; temp_avg + = temp_samples; } curr_avg / = NUMSAMPLER; volt_avg / = NUMSAMPLER; temp_avg / = NUMSAMPLER; //Serial.print("ADC VALUE = "); //Serial.println(ADC_VALUE); // konverter adc-verdi til spenninger for å få faktisk strøm og spenning. float solar_curr = (curr_avg * 3.3) / (4095); float solar_volt = (volt_avg * 3.3) / (4095); // ved å bruke en spenningsdeler trapper vi ned den faktiske spenningen. // av den grunn multipliserer vi 6 med gjennomsnittlig spenning for å få den faktiske spenningen til solcellepanelet. solar_volt * = 6;
Solspenningen sendes inn ved å multiplisere med 6 da vi opprettet spenningsdeleren som vil dele inngangsspenningen med 6 ganger.
Temperaturen genereres fra termistoren ved hjelp av en logaritmisk formasjon.
// konvertere verdien til motstand temp_avg = 4095 / temp_avg - 1; temp_avg = SERIESRESISTOR / temp_avg; //Serial.print("Thermistor motstand "); //Serial.println(temp_avg); flyte 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; // Inverter steinhart - = 273,15; // konverter absolutt temp til C
Dataene leses hvert 15. sekund.
forsinkelse (1000); telle ++; Serial.print ("."); hvis (count> = 15) { count = 0; Serial.println ("================================================= ============================== "); Serial.print ("Solar Voltage ="); Serial.println (solar_volt); Serial.print ("Solstrøm ="); Serial.println (solar_curr); flyte solar_watt = solar_volt * solar_curr; Serial.print ("Solar Watt ="); Serial.println (solar_watt); Serial.print ("Soltemperatur ="); Serial.println (steinhart); Serial.println ("================================================= ============================== ");
Dataene for respektive felt overføres ved hjelp av funksjonen Thing.Speak.setField (); når WiFi er tilkoblet.
hvis (WiFi.status () == WL_CONNECTED) { ThingSpeak.setField (1, solar_volt); ThingSpeak.setField (2, solar_curr); ThingSpeak.setField (3, solar_watt); ThingSpeak.setField (4, steinhart); // skriv til ThingSpeak-kanalen int x = ThingSpeak.writeFields (channelID, writeFeedAPIKey); hvis (x == 200) { Serial.println ("Oppdatering av kanaler vellykket."); } annet { Serial.println ("Problem med oppdatering av kanal. HTTP-feilkode" + String (x)); } } annet { Serial.println ("\ r \ n ############################################################################################################################################################### ###### ######################## "); Serial.println ("Kunne ikke oppdatere data til thingSpeak Server."); Serial.println ("WiFi ikke tilkoblet…"); Seriell.println ("############################################################################ ############### \ r \ n "); } Serial.print ("Data Reading."); } }
Wi-Fi-oppgaven opprettet i kodebiten nedenfor
void wifi_task (void * parameter) { while (1) { if (WiFi.status ()! = WL_CONNECTED) { Serial.print ("Forsøk på å koble til SSID:"); Serial.println (WLAN_SSID); mens (WiFi.status ()! = WL_CONNECTED) { WiFi.begin (WLAN_SSID, WLAN_PASS); // Koble til WPA / WPA2-nettverk. Endre denne linjen hvis du bruker åpent eller WEP-nettverk Serial.print ("."); forsinkelse (5000); } Serial.println ("\ nKoblet."); Serial.println (); Serial.println ("WiFi-tilkoblet"); Serial.println ("IP-adresse:"); Serial.println (WiFi.localIP ()); } vTaskDelay (1000 / portTICK_PERIOD_MS); } vTaskDelete (NULL); }
Testing og overvåking av data
Solcellepanelet er koblet til kretsen og plassert i sollyset for testing som vist nedenfor.
Komplett arbeid demonstreres i videoen nedenfor. Kretsen vår var i stand til å lese utgangsspenningen, strømmen og strømmen fra panelet og oppdatere den live på Thingspeak-kanalen som vist nedenfor.
Som vi kan se, vises 15-minutters data i grafen ovenfor. Siden dette er et utendørs operasjonsprosjekt, må riktig PCB og en lukket boks brukes. Kapslingen må lages på en slik måte at kretsen forblir vanntett i regn. For å modifisere denne kretsen eller for å diskutere ytterligere aspekter av dette prosjektet, vennligst bruk det aktive forumet til Circuit Digest. Håper du likte opplæringen og lærte noe nyttig.