- A megfelelő alkatrészek kiválasztása az IoT-kompatibilis napenergia-figyelőhöz
- Áramkör az IoT alapú napenergia-figyeléshez
- A ThingSpeak beállítása
- Arduino kód a napenergia megfigyeléséhez ESP32 használatával
- Adatok tesztelése és figyelése
A megújuló energiák területén a napenergia áll az élen, mert az energiatermelés a nap erejének felhasználásával a megújuló energia legegyszerűbb és kereskedelmi szempontból életképes módja. A napelemekről szólva a napelemek kimeneti teljesítményét ellenőrizni kell annak érdekében, hogy a panelek optimális teljesítményt kapjanak. Ezért válik szükségessé a valós idejű felügyeleti rendszer. Egy nagy naperőműben azt is lehet használni, hogy ellenőrizzék az egyes panelek teljesítményét, ami segít azonosítani a por felhalmozódását. Megakadályozza az üzem közben fellépő hibahelyzeteket is. Néhány korábbi cikkünkben néhány napenergiával kapcsolatos projektet építettünk, például napelemes mobiltelefon-töltőt és napelemes inverter áramkört, stb. Ezeket megnézheti, ha további napenergia-projekteket keres.
Ebben a projektben IoT-alapú napenergia-figyelő rendszert készítünk az MPPT (Maximum Power Point Tracker) alapú akkumulátor-töltési technika beépítésével, amely segít csökkenteni a töltési időt és javítani a hatékonyságot. Ezenkívül megmérjük a panel hőmérsékletét, a kimeneti feszültséget és az áramot az áramkör biztonsági szempontjainak javítása érdekében. Végül, mindennek tetejébe a ThingSpeak felhőszolgáltatásokat fogjuk használni a kimeneti adatok megfigyelésére a világ bármely pontjáról. Vegye figyelembe, hogy ez a projekt az MPPT Solar Charge Controller Project folytatása, amelyet korábban építettünk. Itt figyelni fogjuk a panel kimeneti feszültségét, áramerősségét és teljesítményét az ESP32 IoT fejlesztői kártya segítségével.
A megfelelő alkatrészek kiválasztása az IoT-kompatibilis napenergia-figyelőhöz
A napelemes monitorral nagyon egyszerűvé válik bármely naprendszer hibájának megfigyelése és felderítése. Ezért válik az alkatrészválasztás nagyon fontos részévé egy ilyen rendszer megtervezésekor. Az alábbiakban felsoroljuk az általunk használt alkatrészeket.
- ESP32 dev tábla
- MPPT áramkör (bármely napelemes áramkör lehet)
- Söntellenállás (például 1 Ohm 1 watt - 1A áramig használható)
- Lítium akkumulátor (7,4 V előnyben részesítendő).
- Aktív Wi-Fi kapcsolat
- Hőérzékelő a napelemhez
- Feszültségosztó áramkör (lásd a leírást)
Esp32 Dev Board:
Az IoT-kompatibilis alkalmazásokhoz elengedhetetlen a megfelelő típusú fejlesztőkártya kiválasztása, amely képes lesz feldolgozni az adatokat az analóg csapokról, és bármilyen típusú kapcsolatprotokollon keresztül, például Wi-Fi-n vagy felhőben továbbíthatja az adatokat szerver. Kifejezetten az ESP32-t választottuk, mivel ez egy olcsó mikrovezérlő, rengeteg funkcióval. Ezenkívül beépített Wi-Fi rádióval rendelkezik, amelyen keresztül nagyon egyszerűen csatlakozhatunk az internethez.
Napenergia áramkör:
A napelemes töltőáramkör olyan áramkör, amely nagyobb feszültséget kap a napelemről, és átalakítja azt töltési feszültséggé, hogy hatékonyan töltse fel az akkumulátort. Ehhez a projekthez az LT3562 alapú MPPT töltésvezérlő áramköri lapot fogjuk használni, amelyet már az egyik korábbi projektünkben készítettünk. De ha be akarja ágyazni ezt az IoT engedélyezés-felügyeletet, akkor bármilyen napkapcsolót használhat. Ezt a táblát választottuk, mert az áramkör maximális teljesítménypont-követéssel (MPPT) van ellátva, ami előnyös az alacsony fogyasztású napelemes projekteknél. Ez egy hatékony módszer egy kis lítium akkumulátor töltésére egy napelemről.
Shunt ellenállás:
Bármely ellenállás betartja az ohm törvényét, ami azt jelenti, hogy ha egy bizonyos áram áramlik át az ellenálláson, akkor bizonyos mértékű feszültségesés jelenik meg. A sönt ellenállások nem kivételek ez alól, és kifejezetten az áramlás mérésére szolgál. A napelemen átmenő névleges áramtól függően azonban válasszon olyan söntellenállást, amely megfelelő mennyiségű feszültséget állít elő, amelyet a mikrovezérlő egység mérhet meg. De ugyanakkor az ellenállás teljesítménye is fontos dolog. A söntellenállás teljesítményének megválasztása szintén fontos.
A feszültségesés kiszámítható az alábbi képlettel. Ezt Ohm törvényének nevezik.
V = I x R
V az „I” során keletkező feszültség, azaz az „R” ellenállás mennyiségén átáramló áram mennyisége. Például az 1 ohmos ellenállás 1 V feszültségesést okoz, amikor 1 A áram áramlik át rajta.
Az ellenállás teljesítményére az alábbi képlet használható:
P = I 2 R
Ahol I a legnagyobb áramáram, és R az ellenállás értéke. 1 A 1 Ohmos ellenállású áram esetén 1 watt elegendő az energiaelvezetéshez. Ez azonban hasznos kis napelemes projekteknél, de egyáltalán nem alkalmas napenergia-hálózattal kapcsolatos alkalmazásokhoz. Ilyen esetben valójában a nem invazív árammérési technikát kell használni. Ilyen esetben az áramáram pontosan mérhető, ahol nagyon alacsony árammennyiség, valamint nagyon magas árammérés mérhető.
Lítium akkumulátor:
A lítium elem kiválasztása elengedhetetlen része minden olyan projektnek, amely napelemeket tartalmaz. Mivel az a mikrovezérlő egység, amely mindig be van kapcsolva, és folyamatosan ellenőrzi és benyújtja az adatokat, a stabil működéshez legalább száz milliamper áramra van szükség.
Az akkumulátor kapacitásának olyannak kell lennie, amely legalább 4-5 napig képes táplálni a mikrovezérlőt, amikor a monszun miatt nem süt a nap. Fontos az is, hogy az akkumulátor szempontjából a töltési áramnak nagyobbnak kell lennie, mint a terhelési áram. Egészen szokatlan, ha valaki 100mA terhelést köt össze egy akkumulátorral, és töltőáramot biztosít, ami ennél kisebb. A biztonságosabb oldalon legalább ötször nagyobb töltőárammal kell rendelkeznünk, mint a terhelési áram.
Másrészt az akkumulátor feszültségének magasabbnak kell lennie, mint a mikrovezérlőhöz szükséges szokásos feszültségszabályozó bemeneti feszültség. Például egy 7,4 V-os lítium akkumulátor csatlakoztatható mind a 3,3 V, mind az 5,0 V-os lineáris feszültségszabályozóra (mivel a lineáris szabályozónak nagyobb kiesési feszültségre van szüksége, mint az LDO-nak és a kapcsolásnak).
Projektünkben 4000mAH akkumulátort használtunk, 7,4V névleges értékkel. 5,0 V-os szabályozót használtunk, amely elegendő áram- és feszültségkimenetet biztosít az ESP32 számára.
Feszültségosztó:
A feszültségosztó elengedhetetlen része a napelem feszültségmérésének. Olyan feszültségosztót kell választani, amely felosztja a feszültséget a mikrovezérlő I / O feszültség bemenetének megfelelően.
A fenti ellenállásokat úgy válassza meg, hogy a feszültségosztó kimeneti feszültsége ne haladja meg a mikrovezérlő maximális I / O feszültségét (ESP32 esetén 3,3 V). Javasoljuk azonban, hogy használjon potenciométert, mert ez rugalmasságot biztosít bármelyik magasabb vagy alacsonyabb feszültségű napelem kiválasztásához, és a multiméter segítségével könnyen beállíthatja a feszültséget.
Esetünkben az MPPT kártya áramkörében van egy potenciométer, amely feszültségosztóként működik. A feszültségosztót 6V osztási tényezővel állítjuk be. Két több métert csatlakoztattunk, egyet az edény bemenetébe, egy másikat az edény kimenetébe, és beállítottuk azt az értéket, hogy amikor a bemeneti feszültség 18V, a kimenet 3V lesz, mivel a napelem névleges kimeneti feszültsége 18V.
Hőmérséklet-érzékelő a napelemhez:
A napelem teljesítménye közvetlen kapcsolatban áll a napelem hőmérsékletével. Miért? Mivel amikor a napelem hőmérséklete növekszik, a napelem kimeneti áramának exponenciális növekedése növekszik, miközben a kimeneti feszültség lineárisan csökken.
A teljesítmény képletének megfelelően a teljesítmény megegyezik a feszültség és az áram szorzatával (W = V x A), a kimenő feszültség csökkenése a napelem kimeneti teljesítményét az áramáram növekedése után is csökkenti. Most a következő kérdés jut eszünkbe, hogyan lehet mérni a nap hőmérsékletét? Nos, meglehetősen érdekes, mivel a napelemeket általában hőhatás éri, mivel közvetlen napfénynek van kitéve és nyilvánvaló okokból. A napelemes hőmérséklet mérésének legjobb módja egy sík felületű hőmérséklet-érzékelő. Javasoljuk továbbá egy K típusú hőelem használatát, amely közvetlenül a napelemben helyezkedik el.
Alkalmazásunkhoz egy termisztor alapú hőmérséklet-érzékelő modult használtunk, amely az alábbiakban látható.
Áramkör az IoT alapú napenergia-figyeléshez
Az IoT által engedélyezett napenergia-monitor teljes kapcsolási rajza az alábbiakban látható. A vázlat egyszerű. A piros kötőjeles tábla az MPPT tábla, amelyet ehhez a projekthez használtunk.
A ThingSpeak beállítása
Hozzon létre egy fiókot a ThingSpeak segítségével, és lépjen a „Saját csatornám” lehetőségre, majd kattintson az Új csatorna elemre.
Hozzon létre egy új csatornát a mezők nevével.
A mező beállítása után lépjen az API kulcsok mezőbe, ahol elérhető az API írási kulcs. Ezt a kulcsot meg kell adni a kódban, valamint a csatornaazonosítót.
A ThingSpeak cím ugyanazon az oldalon található.
A fenti lépésekkel nagyon egyszerűen beállíthatja a ThingSpeak programot. Ha többet szeretne megtudni a ThingSpeakről és annak telepítési folyamatáról, akkor tekintse meg a témával kapcsolatos korábbi cikkeinket.
Arduino kód a napenergia megfigyeléséhez ESP32 használatával
A teljes ESP32 napenergiát ellenőrző kód az oldal alján található. A kód az SSID, a Jelszó és néhány egyéb állandó paraméter megadásával kezdődik, az alábbiak szerint.
// definiálja a WiFi SSID-t és a PWD-t az uplink számára. #define WLAN_SSID "xxxx" #define WLAN_PASS "xxxxxxxxxx"
// ellenállás 25 ° C-on #define THERMISTORNOMINAL 10000 // hőmérséklet. a névleges ellenálláshoz (szinte mindig 25 C) #define TEMPERATURENOMINAL 25 // A termisztor béta együtthatója (általában 3000-4000) #define BCOEFFICIENT 3950 // az "egyéb" ellenállás értéke #define SERIESRESISTOR 10000
A termisztor névleges ohmja a névleges hőmérsékleten van megadva. Állítsa be ezt az értéket a termisztor adatlapjától függően. Tegye a termisztor béta együtthatóját és soros ellenállásának értékét.
// definiáljuk az Analóg elemet az áramerősségre és feszültségre const int curr_an_pin = 35; const int volt_an_pin = 34; const int ntc_temp_an_pin = 33;
A PIN-kódok itt vannak meghatározva.
#define thingSpeakAddress "xxxxxxxxx" #define channelID xxxxx #define writeFeedAPIKey "xxxxxxx" #define readFeedAPIKey "xxxxxxx" #define readFieldAPIKey "xxxxxxxx" #define readStatusAPIKey "xxxxxxx"
Tedd a thingSpeakAddress, channelID, Write Feed API Key tételt. A többi dologra nincs szükség, de akkor is hasznosak, ha adatokat kell kapni a webről.
void setup () { // tegye ide a beállító kódot, hogy egyszer fusson: // állítsa a soros portot 115200-ra Serial.begin (115200); // Soros késés inicializálása (1000); WiFi.mode (WIFI_STA); ThingSpeak.begin (kliens); // inicializálása ThingSpeak // TODO: hozzon létre egy feladatot, hogy olvastam egy pin kap a jelenlegi és a feszültség és számítani watt és hőmérséklete a napelem xTaskCreate ( wifi_task, / * Feladat funkciót. * / „Wifi_task” / * String neve feladat. * / 1024 * 2, / * Veremméret bájtokban. * / NULL, / * A paraméter bemeneteként átadott paraméter * / 5, / * A feladat prioritása. * / NULL); / * Feladat fogantyú. * / Serial.print ("Adatolvasás".); }
A fenti kódban a ThingSpeak szervert inicializálják, és létrehoznak egy feladatot, amely megkapja a napelemre vonatkozó adatokat.
A fő hurokban a szoláráramot és -feszültséget analóg csapon keresztül érzékelik, és az átlag megtörténik.
float solar_curr_adc_val = 0; float solar_volt_adc_val = 0; mert (i = 0; i <SZÁMMINTÁK; i ++) { curr_samples = analogRead (curr_an_pin); volt_minták = analogRead (volt_an_pin); temp_samples = analogRead (ntc_temp_an_pin); késés (10); } // átlagolja az összes mintát float curr_avg = 0; úszó volt_avg = 0; float temp_avg = 0; mert (i = 0; i <SZÁMMINTÁK; i ++) { curr_avg + = curr_samples; volt_avg + = volt_minták; temp_avg + = temp_sample; } curr_avg / = SZÁMLAMINT; volt_avg / = SZÁMMINTÁK; temp_avg / = SZÁMMINTÁK; //Serial.print("ADC VALUE = "); //Serial.println(ADC_VALUE); // átalakítja az ADC értékét feszültségekké a tényleges áram és feszültség megszerzéséhez. float solar_curr = (áram_avg * 3,3) / (4095); float solar_volt = (volt_avg * 3.3) / (4095); // feszültségosztó használatával lelépünk a tényleges feszültségről. // emiatt szorozzuk a 6-ot átlagfeszültséggel, hogy megkapjuk a napelem tényleges feszültségét. szolár_volt * = 6;
A napfeszültséget úgy adjuk meg, hogy megszorozzuk 6-mal, amikor létrehoztuk azt a feszültségosztót, amely hatszorosára osztja a bemenő feszültséget.
A hőmérsékletet a termisztorból állítják elő logaritmikus képződmény felhasználásával.
// az érték átalakítása ellenállás temp_avg = 4095 / temp_avg - 1 értékre; temp_avg = SERIESRESISTOR / temp_avg; //Serial.print("Termisztor ellenállás "); //Serial.println(temp_avg); úszó steinhart; steinhart = temp_avg / THERMISTORNOMINAL; // (R / Ro) steinhart = log (steinhart); // ln (R / Ro) steinhart / = HATÉKONYSÁG; 1 / B * ln (R / Ro) Steinhart + = 1,0 / (TEMPERATURENOMINAL + 273,15); + (1 / To) steinhart = 1,0 / steinhart; // Steinhart fordítása - = 273,15; // az abszolút hőmérséklet konvertálása C-re
Az adatokat 15 másodpercenként olvassuk le.
késés (1000); szám ++; Soros.nyomtatás ("."); if (szám> = 15) { szám = 0; Serial.println ("=============================================== ============================ "); Serial.print ("Napfeszültség ="); Soros.println (szolár_volt); Soros.nyomtatás ("Solar Current ="); Soros.println (szolár_árfolyam); float solar_watt = solar_volt * solar_curr; Soros.nyomtatás ("Solar Watt ="); Soros.println (szolár_watt); Soros.nyomtatás ("Nap hőmérséklete ="); Soros.println (steinhart); Serial.println ("=============================================== ============================ ");
A megfelelő mezők adatait a Thing.Speak.setField () függvény segítségével továbbítják ; amikor a WiFi csatlakozik.
if (WiFi.status () == WL_CONNECTED) { ThingSpeak.setField (1, solar_volt); ThingSpeak.setField (2, solar_curr); ThingSpeak.setField (3, szolár_watt); ThingSpeak.setField (4, steinhart); // írjon a ThingSpeak csatornára int x = ThingSpeak.writeFields (channelID, writeFeedAPIKey); if (x == 200) { Serial.println ("A csatornák frissítése sikeres."); } else { Serial.println ("Probléma a csatorna frissítésében. HTTP hibakód" + String (x)); } } else { Serial.println ("\ r \ n ######################################################### ######################### "); Serial.println ("Nem sikerült frissíteni az adatokat a thingSpeak szerverre."); Serial.println ("A WiFi nincs csatlakoztatva…"); Serial.println ("################################################################## ################ r \ n "); } Serial.print ("Adatolvasás".); } }
Az alábbi kódrészletben létrehozott Wi-Fi feladat-
void wifi_task (void * paraméter) { while (1) { if (WiFi.status ()! = WL_CONNECTED) { Serial.print ("SSID-hez való csatlakozás megkísérlése:"); Soros.println (WLAN_SSID); while (WiFi.status ()! = WL_CONNECTED) { WiFi.begin (WLAN_SSID, WLAN_PASS); // Csatlakozás WPA / WPA2 hálózathoz. Változtassa meg ezt a sort, ha nyitott vagy WEP hálózatot használ a Serial.print ("."); késés (5000); } Serial.println ("\ nConnected."); Soros.println (); Serial.println ("WiFi csatlakoztatva"); Serial.println ("IP-cím:"); Serial.println (WiFi.localIP ()); } vTaskDelay (1000 / portTICK_PERIOD_MS); } vTaskDelete (NULL); }
Adatok tesztelése és figyelése
A napelem csatlakozik az áramkörhöz és napfénybe kerül tesztelés céljából az alábbiak szerint.
A teljes munkát az alábbi videó szemlélteti. Áramkörünk képes volt kiolvasni a kimeneti feszültséget, áramot és energiát a panelről, és élőben frissíteni a dolgok csúcsán az alábbiak szerint.
Mint láthatjuk, a fenti grafikonon 15 perces adatok láthatók. Mivel ez egy szabadtéri üzemeltetési projekt, megfelelő nyomtatott áramköri lapot és egy mellékelt dobozt kell használni. A burkolatot úgy kell elkészíteni, hogy az áramkör esőben vízálló maradjon. Ennek az áramkörnek a módosításához vagy a projekt további szempontjainak megvitatásához kérjük, használja a Circuit Digest aktív fórumát. Remélem, tetszett a bemutató, és valami hasznosat tanultál.