Monitorizarea puterii panoului solar bazat pe IOT utilizând esp32 și thingspeak

În domeniul energiei regenerabile, energia solară este în prim plan, deoarece producerea de energie prin utilizarea puterii soarelui este cea mai ușoară și viabilă din punct de vedere comercial a energiei regenerabile. Vorbind de panouri solare, puterea de ieșire a unui panou solar trebuie monitorizată pentru a obține o putere optimă de ieșire din panouri. Acesta este motivul pentru care devine necesar un sistem de monitorizare în timp real. Într-o centrală solară mare, poate fi utilizată și pentru monitorizarea puterii de la fiecare panou, care ajută la identificarea acumulării de praf. De asemenea, previne orice condiții de defecțiune în timpul funcționării. În unele dintre articolele noastre anterioare, am construit câteva proiecte legate de energia solară, cum ar fi un încărcător de telefon mobil alimentat cu energie solară și un circuit invertor solar, etc. Le puteți verifica dacă căutați mai multe proiecte privind energia solară.

În acest proiect, vom realiza un sistem de monitorizare a energiei solare bazat pe IoT, încorporând tehnica de încărcare a bateriei bazată pe MPPT (Maximum Power Point Tracker), care va ajuta la reducerea timpului de încărcare și la îmbunătățirea eficienței. De asemenea, vom măsura temperatura panoului, tensiunea de ieșire și curentul pentru a îmbunătăți aspectul de siguranță al circuitului. În cele din urmă, pentru a completa totul, vom folosi serviciile cloud ThingSpeak pentru a monitoriza datele de ieșire de oriunde din întreaga lume. Rețineți că acest proiect este o continuare a proiectului MPPT Solar Charge Controller Project pe care l-am construit mai devreme. Aici vom monitoriza tensiunea de ieșire, curentul și puterea panoului utilizând placa de dezvoltare ESP32 IoT.

Alegerea componentelor potrivite pentru monitorul de energie solară activat IoT

Cu un monitor solar, devine foarte ușor de monitorizat și detectat defecțiunile din orice sistem solar. Acesta este motivul pentru care selecția componentelor devine o parte foarte importantă la proiectarea unui astfel de sistem. Mai jos este lista pieselor pe care le-am folosit.

ESP dev placa
Circuitul MPPT (poate fi orice circuit solar)
Un rezistor de șunt (de exemplu 1 Ohm 1 watt - potrivit pentru până la 1A de curent)
O baterie cu litiu (preferat 7.4v).
Conexiune Wi-Fi activă
Senzor de temperatură pentru panoul solar
Circuit divizor de tensiune (vezi descrierea)

Esp32 Dev Board:

Pentru o aplicație activată IoT, este esențial să alegeți tipul corect de placă de dezvoltare care să poată procesa datele de la pinii analogici și să trimită datele prin orice tip de protocol de conexiune, cum ar fi Wi-Fi sau în cloud Server. Am selectat în mod specific ESP32, deoarece este un microcontroler cu costuri reduse, cu multe funcții. De asemenea, are un radio Wi-Fi încorporat prin care ne putem conecta la internet foarte ușor.

Circuit solar:

Un circuit de încărcare solară este un circuit care obține o tensiune mai mare de la panoul solar și îl transformă în tensiune de încărcare, astfel încât să poată încărca eficient bateria. Pentru acest proiect, vom folosi placa de circuite cu controler de încărcare MPPT bazat pe LT3562 pe care am realizat-o deja într-unul din proiectele noastre anterioare. Dar dacă doriți să încorporați această monitorizare a activării IoT, puteți utiliza orice fel de circuit solar. Am ales această placă deoarece circuitul este echipat cu urmărirea punctelor de putere maximă (MPPT), care este benefic pentru proiectele de panouri solare de mică putere. Este un mod eficient de a încărca o baterie mică de litiu de pe un panou solar.

Rezistență la șunt:

Orice rezistor respectă legea ohmului, ceea ce înseamnă că dacă o anumită cantitate de curent curge prin rezistor, va apărea o anumită cantitate de cădere de tensiune. Rezistențele de șunt nu fac excepție și sunt utilizate în mod special pentru a măsura fluxul de curent. Cu toate acestea, în funcție de curentul nominal de curent prin panoul solar, alegeți un rezistor de șunt care va produce o cantitate adecvată de tensiune care poate fi măsurată de unitatea de microcontroler. Dar, în același timp, puterea rezistorului este, de asemenea, un lucru important. Selectarea puterii rezistenței de șunt este de asemenea importantă.

Căderea de tensiune poate fi calculată folosind formula dată mai jos. Aceasta este cunoscută sub numele de legea lui Ohm -

V = I x R

V este tensiunea care va fi produsă în timpul „I”, adică cantitatea de curent prin cantitatea de rezistență „R”. De exemplu, rezistorul de 1 ohm va produce 1V de cădere de tensiune atunci când 1A de curent curge prin el.

Pentru puterea rezistenței, se poate utiliza formula dată mai jos -

P = I ² R

Unde I este debitul maxim de curent, iar R este valoarea rezistenței. Pentru 1A de curent cu rezistor de 1 Ohm, 1 watt este adecvat pentru disiparea puterii. Cu toate acestea, acest lucru este util pentru proiecte de panouri solare mici, dar nu este deloc potrivit pentru aplicații legate de rețeaua solară. Într-un astfel de caz, tehnica de măsurare a curentului neinvaziv este de fapt ceea ce trebuie utilizat. Într-un astfel de caz, debitul de curent poate fi măsurat cu precizie unde poate fi măsurată o cantitate foarte mică de curent, precum și o cantitate foarte mare de curent.

Baterie cu litiu:

Selectarea bateriei cu litiu este o parte esențială a oricărui proiect care implică panouri solare. Deoarece unitatea de microcontroler care rămâne mereu pornită și verifică și transmite în mod constant datele necesită cel puțin o sută de miliampere de curent pentru o funcționare stabilă.

Capacitatea bateriei ar trebui să fie ceva ce poate alimenta microcontrolerul timp de cel puțin 4-5 zile când soarele nu strălucește din cauza musonului. De asemenea, este important ca curentul de încărcare să fie mai mare decât curentul de încărcare din perspectiva bateriei. Este destul de neobișnuit dacă cineva conectează 100mA de încărcare cu o baterie și furnizează un curent de încărcare, care este mai mic decât atât. Pentru a fi pe partea mai sigură, ar trebui să avem cel puțin 5 ori mai mult curent de încărcare decât curentul de încărcare.

Pe de altă parte, tensiunea bateriei trebuie să fie mai mare decât orice tensiune obișnuită de intrare a regulatorului de tensiune necesară pentru microcontroler. De exemplu, o baterie litiu de 7,4 V ar putea fi conectată atât la regulatorul de tensiune liniar de 3,3 V, cât și la cel de 5,0 V (deoarece regulatorul liniar necesită o tensiune de scădere mai mare decât LDO și comutarea).

În proiectul nostru, am folosit o baterie de 4000 mAH cu un rating de 7.4V. Am folosit un regulator de 5,0V care furnizează suficient curent și ieșire de tensiune pentru ESP32.

Divizor de tensiune:

Un divizor de tensiune este o parte esențială a măsurării tensiunii panoului solar. Ar trebui să alegeți un divizor de tensiune care să împartă tensiunea conform intrării de tensiune I / O a microcontrolerului.

Alegeți rezistențele de mai sus în așa fel încât tensiunea de ieșire a divizorului de tensiune să nu depășească tensiunea maximă I / O a microcontrolerului (3,3V pentru ESP32). Cu toate acestea, se recomandă utilizarea unui potențiometru, deoarece va oferi flexibilitate pentru alegerea oricărui panou solar cu tensiune mai mare sau mai mică și poate seta cu ușurință tensiunea folosind un multimetru.

În cazul nostru, avem un potențiometru în circuitul plăcii MPPT care acționează ca un divizor de tensiune. Am setat divizorul de tensiune cu un factor de divizare de 6V. Am conectat doi multi-metri, unul în intrare și altul în ieșirea potului și am setat valoarea că atunci când tensiunea de intrare este de 18V, ieșirea va fi de 3V, deoarece tensiunea nominală de ieșire a panoului solar este de 18V.

Senzor de temperatură pentru panoul solar:

Ieșirea de putere a panoului solar are o conexiune directă cu temperatura panoului solar. De ce? Deoarece pe măsură ce temperatura unui panou solar începe să crească, curentul de ieșire din panoul solar crește exponențial, în timp ce tensiunea de ieșire începe să se reducă liniar.

Conform formulei de putere, puterea este egală cu tensiunea de curent (W = V x A), scăderea tensiunii de ieșire scade și puterea de ieșire a panoului solar chiar și după creșterea debitului de curent. Acum, următoarea întrebare care ne vine în minte este, cum să măsurăm temperatura solară? Ei bine, este destul de interesant, deoarece panourile solare sunt în general expuse mediului de căldură, deoarece sunt expuse la lumina directă a soarelui și din motive evidente. Cel mai bun mod de a măsura temperatura panoului solar este prin utilizarea unui senzor de temperatură de suprafață plană. De asemenea, se sugerează utilizarea unui termocuplu de tip K plasat direct în panoul solar.

Pentru aplicația noastră, am folosit un modul senzor de temperatură bazat pe termistor, care este prezentat mai jos.

Diagrama circuitului pentru monitorizarea energiei solare bazată pe IoT

Schema completă a circuitului pentru monitorul de energie solară activat IoT este prezentată mai jos. Schema este simplă. Placa cu puncte roșii roșii este placa MPPT pe care am folosit-o pentru acest proiect.

Configurarea ThingSpeak

Creați un cont cu ThingSpeak și accesați opțiunea „canalul meu”, apoi faceți clic pe canalul nou.

Creați un canal nou cu numele câmpurilor.

Acum, după setarea câmpului, accesați câmpul Chei API unde este disponibilă Scrierea cheii API. Această cheie trebuie să fie furnizată în cod, precum și în ID-ul canalului.

Adresa ThingSpeak poate fi găsită pe aceeași pagină.

Cu pașii de mai sus, puteți configura ThingSpeak foarte ușor. Dacă doriți să aflați mai multe despre ThingSpeak și procesul său de configurare, puteți consulta articolele noastre anterioare pe această temă.

Cod Arduino pentru monitorizarea energiei solare utilizând ESP32

Codul complet de monitorizare a energiei solare ESP32 poate fi găsit în partea de jos a acestei pagini. Codul începe cu definirea SSID-ului, parolei și altor câțiva parametri constanți, așa cum se arată mai jos.

// definiți WiFi SSID și PWD pentru legătura în sus. #define WLAN_SSID "xxxx" #define WLAN_PASS "xxxxxxxxxx"

// rezistență la 25 grade C #defini TERMISTORNOMINAL 10000 // temp. pentru rezistența nominală (aproape întotdeauna 25 C) #define TEMPERATURENOMINAL 25 // Coeficientul beta al termistorului (de obicei 3000-4000) #define BCOEFFICIENT 3950 // valoarea „celuilalt” rezistor #define SERIESRESISTOR 10000

Ohmii nominali ai termistorului sunt furnizați la temperatura nominală. Setați această valoare în funcție de foaia tehnică a termistorului. Puneți coeficientul beta și valoarea rezistorului de serie al termistorului.

// definește Analog pentru curent și tensiune const int curr_an_pin = 35; const int volt_an_pin = 34; const int ntc_temp_an_pin = 33;

Codurile PIN sunt definite aici.

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

Puneți thingSpeakAddress, channelID, Write Feed API Key. Restul lucrurilor nu sunt necesare, dar sunt totuși utile dacă trebuie primite date de pe web.

void setup () { // puneți codul de configurare aici, pentru a rula o dată: // setați portul serial la 115200 Serial.begin (115200); // Inițializați întârzierea în serie (1000); WiFi.mode (WIFI_STA); ThingSpeak.begin (client); // Inițializați ThingSpeak // todo: creați o sarcină pentru a citi un pin pentru a obține curent și tensiune și calculați watt și temperatura panoului solar xTaskCreate ( wifi_task, / * Funcția de sarcină. * / "Wifi_task", / * Șir cu numele de task. * / 1024 * 2, / * Dimensiunea stivei în octeți. * / NULL, / * Parametru transmis ca intrare a sarcinii * / 5, / * Prioritatea sarcinii. * / NULL); / * Mâner de sarcină. * / Serial.print („Citirea datelor”); }

În codul de mai sus, serverul ThingSpeak este inițializat și se creează o sarcină care va obține datele referitoare la panoul solar.

În bucla principală, curentul și tensiunea solară sunt detectate printr-un pin analogic și media se face.

float solar_curr_adc_val = 0; float 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); întârziere (10); } // mediați toate eșantioanele plutitoare curr_avg = 0; float volt_avg = 0; float temp_avg = 0; pentru (i = 0; i <NUMSAMPLES; i ++) { curr_avg + = curr_samples; volt_avg + = volt_samples; temp_avg + = temp_samples; } curr_avg / = NUMSAMPLES; volt_avg / = NUMSAMPLES; temp_avg / = NUMSAMPLES; //Serial.print("ADC VALUE = "); //Serial.println(ADC_VALUE); // convertiți valoarea adc la tensiuni pentru a obține curent și tensiune reală. float solar_curr = (curr_avg * 3.3) / (4095); float solar_volt = (volt_avg * 3.3) / (4095); // folosind un divizor de tensiune coborâm tensiunea reală. // din acest motiv înmulțim 6 cu tensiune medie pentru a obține tensiunea reală a panoului solar. solar_volt * = 6;

Tensiunea solară este transmisă prin înmulțirea cu 6 pe măsură ce am creat divizorul de tensiune care va împărți tensiunea de intrare de 6 ori.

Temperatura este generată de termistor folosind o formațiune logaritmică.

// convertiți valoarea în rezistență temp_avg = 4095 / temp_avg - 1; temp_avg = SERIESRESISTOR / temp_avg; //Serial.print("Rezistență termistor "); //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; // Inversează steinhart - = 273,15; // convertiți temperatura absolută în C

Datele sunt citite la fiecare 15 secunde.

întârziere (1000); conta ++; Serial.print ("."); if (număr> = 15) { număr = 0; Serial.println ("============================================== ============================ "); Serial.print ("Solar Voltage ="); Serial.println (solar_volt); Serial.print ("Curent solar ="); Serial.println (solar_curr); float solar_watt = solar_volt * solar_curr; Serial.print ("Solar Watt ="); Serial.println (solar_watt); Serial.print ("Temperatura solară ="); Serial.println (steinhart); Serial.println ("============================================== ============================ ");

Datele pentru câmpurile respective sunt transmise utilizând funcția Thing.Speak.setField (); când WiFi este conectat.

if (WiFi.status () == WL_CONNECTED) { ThingSpeak.setField (1, solar_volt); ThingSpeak.setField (2, solar_curr); ThingSpeak.setField (3, solar_watt); ThingSpeak.setField (4, steinhart); // scrie pe canalul ThingSpeak int x = ThingSpeak.writeFields (canalID, writeFeedAPIKey); if (x == 200) { Serial.println ("Actualizarea canalelor a reușit."); } else { Serial.println ("Problemă la actualizarea canalului. Cod de eroare HTTP" + Șir (x)); } } else { Serial.println ("\ r \ n ######################################### ######################## "); Serial.println ("Nu s-au putut actualiza datele pe serverul thingSpeak."); Serial.println ("WiFi nu este conectat…"); Serial.println ("################################################# ############### \ r \ n "); } Serial.print („Citirea datelor”); } }

Sarcina Wi-Fi creată în fragmentul de cod de mai jos-

void wifi_task (void * parametru) { while (1) { if (WiFi.status ()! = WL_CONNECTED) { Serial.print ("Se încearcă conectarea la SSID:"); Serial.println (WLAN_SSID); while (WiFi.status ()! = WL_CONNECTED) { WiFi.begin (WLAN_SSID, WLAN_PASS); // Conectați-vă la rețeaua WPA / WPA2. Schimbați această linie dacă utilizați rețea deschisă sau WEP Serial.print ("."); întârziere (5000); } Serial.println ("\ nConectat."); Serial.println (); Serial.println („WiFi conectat”); Serial.println ("adresa IP:"); Serial.println (WiFi.localIP ()); } vTaskDelay (1000 / portTICK_PERIOD_MS); } vTaskDelete (NULL); }

Testarea și monitorizarea datelor

Panoul solar este conectat la circuit și plasat în lumina soarelui pentru testare așa cum se arată mai jos.

Funcționarea completă este demonstrată în videoclipul de mai jos. Circuitul nostru a reușit să citească tensiunea, curentul și puterea de ieșire de pe panou și să le actualizeze în direct pe canalul lucrurilor de vârf, așa cum se arată mai jos.

După cum putem vedea, datele de 15 minute sunt prezentate în graficul de mai sus. Deoarece acesta este un proiect de funcționare în aer liber, trebuie utilizat PCB adecvat împreună cu o cutie închisă. Carcasa trebuie realizată astfel încât circuitul să rămână rezistent la apă în ploaie. Pentru a modifica acest circuit sau pentru a discuta despre alte aspecte ale acestui proiect, utilizați cu amabilitate forumul activ al Circuit Digest. Sper că ți-a plăcut tutorialul și ai învățat ceva util.