- Valg af de rigtige komponenter til IoT-aktiveret solcellemonitor
- Kredsløbsdiagram til IoT-baseret overvågning af solenergi
- Opsætning af ThingSpeak
- Arduino-kode til overvågning af solenergi ved hjælp af ESP32
- Test og overvågning af data
Inden for vedvarende energi er solenergi i spidsen, fordi produktion af energi ved hjælp af solens kraft er den nemmeste og kommercielt bæredygtige måde at vedvarende energi på. Når vi taler om solpaneler, skal udgangseffekten af et solpaneloutput overvåges for at få optimal effekt fra panelerne. Derfor bliver et realtidsovervågningssystem nødvendigt. I et stort solkraftværk kan det også bruges til at overvåge effektudgangen fra hvert panel, hvilket hjælper med at identificere støvopbygningen. Det forhindrer også eventuelle fejlforhold i driftstiden. I nogle af vores tidligere artikler har vi bygget nogle få solenergirelaterede projekter som f.eks. En solcelledrevet mobiltelefonoplader og solcelleanlægskredsløb osv. Du kan tjekke dem ud, hvis du leder efter flere projekter om solenergi.
I dette projekt laver vi et IoT-baseret solenergiovervågningssystem ved at inkorporere MPPT (Maximum Power Point Tracker) - baseret batteriopladningsteknik, som hjælper med at reducere opladningstiden og forbedre effektiviteten. Vi måler også panelets temperatur, udgangsspænding og strøm for at forbedre kredsløbets sikkerhedsaspekt. Endelig skal vi, for at top det hele, bruge ThingSpeak-cloudtjenesterne til at overvåge outputdataene overalt i verden. Bemærk, at dette projekt er en fortsættelse af MPPT Solar Charge Controller Project, som vi byggede tidligere. Her overvåger vi udgangsspændingen, strømmen og strømmen på panelet ved hjælp af ESP32 IoT-udviklingskortet.
Valg af de rigtige komponenter til IoT-aktiveret solcellemonitor
Med en solskærm bliver det meget let at overvåge og opdage fejl i ethvert solsystem. Derfor bliver komponentvalg en meget vigtig del, når man designer et sådant system. Nedenfor er listen over dele, vi brugte.
- ESP32 dev-kort
- MPPT kredsløb (kan være ethvert solcirkel)
- En shuntmodstand (for eksempel 1 Ohm 1 watt - egnet til op til 1A strøm)
- Et lithiumbatteri (7,4 v foretrukket).
- Aktiv Wi-Fi-forbindelse
- Temperaturføler til solpanel
- Spændingsdelerkredsløb (se beskrivelsen)
Esp32 Dev Board:
For en IoT-aktiveret applikation er det vigtigt at vælge den rigtige type udviklingskort, der er i stand til at behandle dataene fra dens analoge ben og sende dataene via enhver form for forbindelsesprotokol såsom Wi-Fi eller til skyen server. Vi valgte specifikt ESP32, da det er en billig microcontroller med masser af funktioner. Det har også en indbygget Wi-Fi-radio, hvorigennem vi nemt kan oprette forbindelse til internettet.
Solkreds:
Et solopladningskredsløb er et kredsløb, der får højere spænding fra solpanelet og konverterer det ned til en opladningsspænding, så det effektivt kan oplade batteriet. Til dette projekt bruger vi det LT3562-baserede MPPT Charge Controller Circuit Board, som vi allerede har lavet i et af vores tidligere projekter. Men hvis du vil integrere denne IoT-aktiverede overvågning, kan du bruge enhver form for solkredsløb. Vi har valgt dette kort, fordi kredsløbet er udstyret med Maximum Power Point Tracking (MPPT), som er gavnligt for solpanelprojekter med lav effekt. Det er en effektiv måde at oplade et lille lithiumbatteri fra et solpanel.
Shunt-modstand:
Enhver modstand følger ohmens lov, hvilket betyder, at hvis en vis mængde strøm strømmer gennem modstanden, vises en vis mængde spændingsfald. Shuntmodstande er ikke en undtagelse fra dette, og det bruges specifikt til at måle strømmen. Afhængigt af den nominelle strømflow gennem solpanelet skal du dog vælge en shuntmodstand, der producerer en tilstrækkelig mængde spænding, som kan måles af mikrocontrollerenheden. Men på samme tid er modstandens watt også en vigtig ting. Valg af shuntmodstandseffekt er også vigtigt.
Spændingsfaldet kan beregnes ved hjælp af nedenstående formel. Dette er kendt som Ohms lov-
V = I x R
V er den spænding, der produceres under 'I', dvs. mængden af strøm gennem modstanden 'R'. For eksempel vil 1 ohm modstand producere 1V spændingsfald, når 1A strøm strømmer gennem den.
Til modstandens wattforbrug kan nedenstående formel bruges-
P = I 2 R
Hvor I er den maksimale strøm, og R er modstandsværdien. For 1A strøm med 1 ohm modstand er 1 watt tilstrækkelig til strømforsyningen. Dette er dog nyttigt til små solpanelprojekter, men overhovedet ikke egnet til solnettet relaterede applikationer. I et sådant tilfælde er den ikke-invasive strømmålingsteknik faktisk det, der skal bruges. I et sådant tilfælde kan strømmen måles nøjagtigt, hvor en meget lav strøm såvel som en meget høj strøm kan måles.
Lithium-batteri:
Valget af lithiumbatteri er en væsentlig del af ethvert projekt, der involverer solpaneler. Fordi den mikrocontroller-enhed, der altid forbliver tændt og konstant kontrollerer og indsender data, kræver mindst hundrede milliampere strøm for stabil drift.
Batterikapaciteten skal være noget, der kan drive mikrocontrolleren i mindst 4-5 dage, når solen ikke skinner på grund af monsunen. Det er også vigtigt, at ladestrømmen skal være mere end belastningsstrømmen set fra batteriperspektivet. Det er ret usædvanligt, hvis nogen forbinder 100 mA belastning med et batteri og giver en ladestrøm, hvilket er mindre end det. For at være på den sikrere side skal vi have mindst 5 gange mere ladestrøm end belastningsstrømmen.
På den anden side skal batterispændingen være højere end enhver almindelig spændingsregulatorindgangsspænding, der kræves til mikrocontrolleren. For eksempel kan et 7,4 V lithiumbatteri forbindes på tværs af både 3,3 V og 5,0 V lineær spændingsregulator (da lineær regulator kræver højere frafaldsspænding mere end LDO og Switching.)
I vores projekt brugte vi et 4000mAH batteri med en 7.4V rating. Vi brugte en 5.0V regulator, der giver tilstrækkelig strøm og spændingsoutput til ESP32.
Spændingsdeler:
En spændingsdeler er en vigtig del af solpanelets spændingsmåling. Man skal vælge en spændingsdeler, der opdeler spændingen i henhold til microcontroller I / O-spændingsindgangen.
Vælg de ovennævnte modstande på en sådan måde, at spændingsdelerens udgangsspænding ikke bør overstige mikrocontrollerens maksimale I / O-spænding (3,3 V for ESP32). Det tilrådes dog at bruge et potentiometer, fordi det giver fleksibilitet til at vælge ethvert solpanel med højere eller lavere spænding og let kan indstille spændingen ved hjælp af et multimeter.
I vores tilfælde har vi et potentiometer i MPPT-kortkredsløbet, der fungerer som en spændingsdeler. Vi indstiller spændingsdeleren med en divisionsfaktor på 6V. Vi tilsluttede to multimeter, en i indgangen og en anden i udgangen af puljen, og indstillede den værdi, at når indgangsspændingen er 18V, vil udgangen være 3V, da solpanelets nominelle udgangsspænding er 18V.
Temperaturføler til solpanel:
Solpanelets strømudgang har en direkte forbindelse til solpanelets temperatur. Hvorfor? Fordi et solpanels temperatur begynder at stige, øges outputstrømmen fra solpanelet eksponentielt, mens spændingsoutputtet begynder at reducere lineært.
I henhold til effektformlen er Wattage lig med spænding gange strøm (W = V x A), faldende udgangsspænding reducerer også solpanelets udgangseffekt, selv efter stigningen i strømflowet. Nu er det næste spørgsmål, der kommer op i vores sind, hvordan man måler soltemperaturen? Nå, det er ret interessant, da solpaneler generelt udsættes for varmemiljøet, da de udsættes for direkte sollys og af åbenlyse grunde. Den bedste måde at måle solpanelets temperatur på er ved hjælp af en flad temperaturføler. Det anbefales også at bruge et K-termoelement, der er anbragt direkte i solpanelet.
Til vores anvendelse har vi brugt et termistorbaseret temperatursensormodul, som er vist nedenfor.
Kredsløbsdiagram til IoT-baseret overvågning af solenergi
Det komplette kredsløbsdiagram for IoT Enabled Solar Power Monitor er vist nedenfor. Skematisk er enkel. Det røde dash-dot-kort er MPPT-kortet, som vi brugte til dette projekt.
Opsætning af ThingSpeak
Opret en konto med ThingSpeak, og gå til "min kanal", og klik derefter på den nye kanal.
Opret en ny kanal med feltnavne.
Efter indstilling af feltet skal du nu gå til API-nøglefeltet, hvor Write API-nøglen er tilgængelig. Denne nøgle skal angives i koden såvel som i kanal-id'et.
ThingSpeak-adressen kan findes på samme side.
Med ovenstående trin kan du opsætte ThingSpeak meget let. Hvis du vil lære mere om ThingSpeak og dets installationsproces, kan du tjekke vores tidligere artikler om emnet.
Arduino-kode til overvågning af solenergi ved hjælp af ESP32
Den komplette ESP32-overvågningskode for solenergi findes nederst på denne side. Koden begynder med at definere dit SSID, adgangskode og et par andre konstante parametre som vist nedenfor.
// definer WiFi SSID & PWD til uplink. #define WLAN_SSID "xxxx" #define WLAN_PASS "xxxxxxxxxx"
// modstand ved 25 grader C #definer THERMISTORNOMINAL 10000 // temp. for nominel modstand (næsten altid 25 ° C) #definer TEMPERATURENOMINAL 25 // Beta-koefficienten for termistoren (normalt 3000-4000) #definer BCOEFFICIENT 3950 // værdien af den 'anden' modstand #define SERIESRESISTOR 10000
Termistorens nominelle ohm tilvejebringes ved den nominelle temperatur. Indstil denne værdi afhængigt af databladet til termistoren. Sæt termistorens Beta-koefficient og seriemodstandsværdi.
// definer Analog for Strøm og Spænding const int curr_an_pin = 35; const int volt_an_pin = 34; const int ntc_temp_an_pin = 33;
PIN-koder er defineret herover.
#define thingSpeakAddress "xxxxxxxxx" #define channelID xxxxx #define writeFeedAPIKey "xxxxxxx" #define readFeedAPIKey "xxxxxxx" #define readFieldAPIKey "xxxxxxxx" #define readStatusAPIKey "xxxxxxx"
Sæt tingSpeakAddress, channelID, Write Feed API Key. Resten af tingene er ikke påkrævet, men er stadig nyttige, hvis der skal modtages data fra internettet.
ugyldig opsætning () { // sæt din opsætningskode her for at køre en gang: // indstil den serielle port til 115200 Serial.begin (115200); // Initialiser seriel forsinkelse (1000); WiFi.mode (WIFI_STA); ThingSpeak.begin (klient); // Initialiser ThingSpeak // todo: Opret en opgave for at læse en pin for at få strøm og spænding og beregne watt og temperatur på solpanelet xTaskCreate ( wifi_task, / * Task-funktion. * / "Wifi_task", / * Streng med navnet på opgave. * / 1024 * 2, / * Størrelsesstørrelse i byte. * / NULL, / * Parameter bestået som input af opgaven * / 5, / * Prioritet for opgaven. * / NULL); / * Opgavehåndtag. * / Serial.print ("Datalæsning."); }
I ovenstående kode initialiseres ThingSpeak-serveren, og der oprettes en opgave, der får dataene relateret til solpanelet.
I hovedsløjfen registreres solstrømmen og spændingen via en analog pin, og gennemsnittet er gjort.
flyde solar_curr_adc_val = 0; flyde 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); } // gennemsnit alle prøverne ud float curr_avg = 0; flyde volt_avg = 0; flyde 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-værdi til spændinger for at få aktuel strøm og spænding. flyde solar_curr = (curr_avg * 3.3) / (4095); float solar_volt = (volt_avg * 3.3) / (4095); // ved hjælp af en spændingsdeler nedtrapper vi den aktuelle spænding. // af den grund multiplicerer vi 6 med gennemsnitlig spænding for at få solpanelets faktiske spænding. solar_volt * = 6;
Solspændingen sendes ved at gange med 6, da vi oprettede spændingsdeleren, der vil dele indgangsspændingen med 6 gange.
Temperaturen genereres fra termistoren ved hjælp af en logaritmisk formation.
// konverter værdien til modstand temp_avg = 4095 / temp_avg - 1; temp_avg = SERIESRESISTOR / temp_avg; //Serial.print("Thermistor-modstand "); //Serial.println(temp_avg); flyde 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 / Til) steinhart = 1.0 / steinhart; // Inverter steinhart - = 273,15; // konverter absolut temp til C
Dataene læses hvert 15. sekund.
forsinkelse (1000); tælle ++; 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); flyde solar_watt = solar_volt * solar_curr; Serial.print ("Solar Watt ="); Serial.println (solar_watt); Serial.print ("Soltemperatur ="); Serial.println (steinhart); Serial.println ("================================================= ============================== ");
Dataene for de respektive felter transmitteres ved hjælp af funktionen Thing.Speak.setField (); når WiFi er tilsluttet.
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 ("Kanalopdatering er vellykket."); } andet { Serial.println ("Problem med opdatering af kanal. HTTP-fejlkode" + String (x)); } } andet { Serial.println ("\ r \ n ###################################################### ####### ######################### "); Serial.println ("Kunne ikke opdatere data til thingSpeak Server."); Serial.println ("WiFi ikke tilsluttet…"); Serial.println ("###################################################################################### -5 ############### \ r \ n "); } Serial.print ("Datalæsning."); } }
Wi-Fi-opgaven oprettet i nedenstående kodestykke-
void wifi_task (void * parameter) { while (1) { if (WiFi.status ()! = WL_CONNECTED) { Serial.print ("Forsøg på at oprette forbindelse til SSID:"); Serial.println (WLAN_SSID); mens (WiFi.status ()! = WL_CONNECTED) { WiFi.begin (WLAN_SSID, WLAN_PASS); // Opret forbindelse til WPA / WPA2-netværk. Skift denne linje, hvis du bruger åbent eller WEP-netværk Serial.print ("."); forsinkelse (5000); } Serial.println ("\ nForbundet."); Serial.println (); Serial.println ("WiFi-tilsluttet"); Serial.println ("IP-adresse:"); Serial.println (WiFi.localIP ()); } vTaskDelay (1000 / portTICK_PERIOD_MS); } vTaskDelete (NULL); }
Test og overvågning af data
Solpanelet er forbundet med kredsløbet og anbragt i sollyset til test som vist nedenfor.
Det komplette arbejde demonstreres i videoen nedenfor. Vores kredsløb var i stand til at læse udgangsspændingen, strømmen og strømmen fra panelet og opdatere den live på Thingspeak-kanalen som vist nedenfor.
Som vi kan se, vises 15-minutters data i ovenstående graf. Da dette er et udendørs driftsprojekt, skal korrekt PCB sammen med en lukket kasse bruges. Kabinettet skal laves på en sådan måde, at kredsløbet forbliver vandtæt i regn. Brug det aktive forum for Circuit Digest til at ændre dette kredsløb eller diskutere yderligere aspekter af dette projekt. Håber du nød tutorialen og lærte noget nyttigt.