Iot-basierte Solarpanel-Leistungsüberwachung mit esp32 und thingspeak

Im Bereich der erneuerbaren Energien steht die Solarenergie im Vordergrund, da die Energieerzeugung mit Sonnenenergie der einfachste und wirtschaftlich rentabelste Weg für erneuerbare Energien ist. Apropos Solarmodule: Die Ausgangsleistung eines Solarmoduls muss überwacht werden, um eine optimale Leistung der Module zu erzielen. Aus diesem Grund wird ein Echtzeitüberwachungssystem erforderlich. In einem großen Solarkraftwerk kann damit auch die Leistung jedes Panels überwacht werden, um die Staubentwicklung zu identifizieren. Es verhindert auch Fehlerzustände während der Betriebszeit. In einigen unserer vorherigen Artikel haben wir einige Projekte im Zusammenhang mit Solarenergie erstellt, z. B. ein solarbetriebenes Handy-Ladegerät und einen Solarwechselrichter-Schaltkreis usw. Sie können diese überprüfen, wenn Sie nach weiteren Projekten zum Thema Solarenergie suchen.

In diesem Projekt werden wir ein IoT-basiertes Solarstromüberwachungssystem entwickeln, indem wir die auf MPPT (Maximum Power Point Tracker) basierende Batterieladetechnik integrieren, die dazu beiträgt, die Ladezeit zu verkürzen und die Effizienz zu verbessern. Außerdem messen wir die Plattentemperatur, die Ausgangsspannung und den Strom, um den Sicherheitsaspekt der Schaltung zu verbessern. Um das Ganze abzurunden, werden wir die ThingSpeak-Cloud-Dienste verwenden, um die Ausgabedaten von überall auf der Welt zu überwachen. Beachten Sie, dass dieses Projekt eine Fortsetzung des zuvor erstellten MPPT Solar Charge Controller-Projekts ist. Hier überwachen wir die Ausgangsspannung, den Strom und die Leistung des Panels mithilfe der ESP32 IoT-Entwicklungsplatine.

Auswahl der richtigen Komponenten für IoT Enabled Solar Power Monitor

Mit einem Solarmonitor ist es sehr einfach, Fehler in jedem Sonnensystem zu überwachen und zu erkennen. Aus diesem Grund wird die Auswahl von Komponenten beim Entwurf eines solchen Systems zu einem sehr wichtigen Bestandteil. Nachstehend finden Sie eine Liste der von uns verwendeten Teile.

1. ESP32-Entwicklungsplatine
2. MPPT-Schaltung (kann eine beliebige Solarschaltung sein)
3. Ein Shunt-Widerstand (zum Beispiel 1 Ohm 1 Watt - geeignet für bis zu 1A Strom)
4. Eine Lithiumbatterie (7,4 V bevorzugt).
5. Aktive Wi-Fi-Verbindung
6. Temperatursensor für das Solarpanel
7. Spannungsteilerschaltung (siehe Beschreibung)

Esp32 Dev Board:

Für eine IoT-fähige Anwendung ist es wichtig, die richtige Art von Entwicklungsplatine auszuwählen, die die Daten von ihren analogen Pins verarbeiten und über ein beliebiges Verbindungsprotokoll wie Wi-Fi oder in die Cloud senden kann Server. Wir haben uns speziell für ESP32 entschieden, da es sich um einen kostengünstigen Mikrocontroller mit zahlreichen Funktionen handelt. Es hat auch ein eingebautes Wi-Fi-Radio, über das wir sehr einfach eine Verbindung zum Internet herstellen können.

Solar Circuit:

Ein Solarladekreis ist ein Stromkreis, der eine höhere Spannung vom Solarpanel erhält und diese in eine Ladespannung umwandelt, damit der Akku effizient aufgeladen werden kann. Für dieses Projekt verwenden wir die auf LT3562 basierende MPPT-Ladereglerplatine, die wir bereits in einem unserer vorherigen Projekte hergestellt haben. Wenn Sie diese IoT-Aktivierungsüberwachung einbetten möchten, können Sie jede Art von Solarkreis verwenden. Wir haben uns für diese Karte entschieden, weil die Schaltung mit MPPT (Maximum Power Point Tracking) ausgestattet ist, was für Solarpanel-Projekte mit geringem Stromverbrauch von Vorteil ist. Es ist eine effiziente Möglichkeit, eine kleine Lithiumbatterie über ein Solarpanel aufzuladen.

Nebenschlusswiderstand:

Jeder Widerstand folgt dem Ohmschen Gesetz. Wenn also eine bestimmte Strommenge durch den Widerstand fließt, tritt ein bestimmter Spannungsabfall auf. Shunt-Widerstände sind keine Ausnahme und werden speziell zur Messung des Stromflusses verwendet. Wählen Sie jedoch abhängig vom Nennstromfluss durch das Solarpanel einen Shunt-Widerstand, der eine ausreichende Spannung erzeugt, die von der Mikrocontroller-Einheit gemessen werden kann. Gleichzeitig ist aber auch die Leistung des Widerstands wichtig. Die Auswahl der Leistung des Shunt-Widerstands ist ebenfalls wichtig.

Der Spannungsabfall kann mit der unten angegebenen Formel berechnet werden. Dies ist als Ohmsches Gesetz bekannt.

V = I x R.

V ist die Spannung, die während 'I' erzeugt wird, dh die Menge des Stromflusses durch die Menge des Widerstands 'R'. Zum Beispiel erzeugt ein 1-Ohm-Widerstand einen Spannungsabfall von 1 V, wenn 1 A Strom durch ihn fließt.

Für die Leistung des Widerstands kann die folgende Formel verwendet werden:

P = I ² R.

Dabei ist I der maximale Stromfluss und R der Widerstandswert. Für 1A Strom mit 1 Ohm Widerstand ist 1 Watt für die Verlustleistung ausreichend. Dies ist jedoch nützlich für kleine Solarmodulprojekte, jedoch überhaupt nicht für Solarnetzanwendungen geeignet. In einem solchen Fall muss tatsächlich die nicht-invasive Strommesstechnik verwendet werden. In einem solchen Fall kann der Stromfluss genau gemessen werden, wobei eine sehr geringe Strommenge sowie eine sehr hohe Strommenge gemessen werden kann.

Lithium Batterie:

Die Auswahl der Lithiumbatterie ist ein wesentlicher Bestandteil jedes Projekts mit Sonnenkollektoren. Da die Mikrocontrollereinheit, die immer eingeschaltet bleibt und die Daten ständig überprüft und übermittelt, für einen stabilen Betrieb mindestens 100 Milliampere Strom benötigt.

Die Batteriekapazität sollte etwas sein, das den Mikrocontroller mindestens 4-5 Tage lang mit Strom versorgen kann, wenn die Sonne wegen des Monsuns nicht scheint. Es ist auch wichtig, dass der Ladestrom aus Sicht der Batterie größer sein muss als der Laststrom. Es ist ziemlich ungewöhnlich, wenn jemand 100 mA Last mit einer Batterie verbindet und einen Ladestrom liefert, der geringer ist. Um auf der sicheren Seite zu sein, sollten wir mindestens fünfmal mehr Ladestrom als den Laststrom haben.

Andererseits muss die Batteriespannung höher sein als jede übliche Spannungsreglereingangsspannung, die für den Mikrocontroller erforderlich ist. Zum Beispiel könnte eine 7,4-V-Lithiumbatterie sowohl an einen 3,3-V- als auch an einen 5,0-V-Linearspannungsregler angeschlossen werden (da der Linearregler eine höhere Ausfallspannung benötigt als der LDO und das Schalten).

In unserem Projekt haben wir eine 4000-mAH-Batterie mit einer Nennspannung von 7,4 V verwendet. Wir haben einen 5,0-V-Regler verwendet, der ausreichend Strom und Spannung für den ESP32 liefert.

Spannungsteiler:

Ein Spannungsteiler ist ein wesentlicher Bestandteil der Spannungsmessung des Solarpanels. Man sollte einen Spannungsteiler wählen, der die Spannung gemäß dem E / A-Spannungseingang des Mikrocontrollers teilt.

Wählen Sie die oben genannten Widerstände so, dass die Ausgangsspannung des Spannungsteilers die maximale E / A-Spannung des Mikrocontrollers (3,3 V für ESP32) nicht überschreitet. Es wird jedoch empfohlen, ein Potentiometer zu verwenden, da es Flexibilität bei der Auswahl eines Solarpanels mit höherer oder niedrigerer Nennspannung bietet und die Spannung einfach mit einem Multimeter einstellen kann.

In unserem Fall haben wir ein Potentiometer in der MPPT-Platinenschaltung, das als Spannungsteiler fungiert. Wir stellen den Spannungsteiler auf einen Teilungsfaktor von 6V ein. Wir haben zwei Multimeter angeschlossen, einen am Eingang und einen am Ausgang des Topfes, und den Wert so eingestellt, dass bei einer Eingangsspannung von 18 V der Ausgang 3 V beträgt, da die Nennausgangsspannung des Solarpanels 18 V beträgt.

Temperatursensor für das Solarpanel:

Die Leistung des Solarmoduls steht in direktem Zusammenhang mit der Temperatur des Solarmoduls. Warum? Denn wenn die Temperatur eines Solarmoduls zu steigen beginnt, steigt der Ausgangsstrom des Solarmoduls exponentiell an, während sich der Spannungsausgang linear zu verringern beginnt.

Gemäß der Leistungsformel ist die Leistung gleich der Spannung mal dem Strom (W = V x A). Eine Verringerung der Ausgangsspannung verringert auch die Ausgangsleistung des Solarpanels auch nach Erhöhung des Stromflusses. Die nächste Frage, die uns jetzt in den Sinn kommt, ist, wie man die Sonnentemperatur misst. Nun, es ist ziemlich interessant, da Sonnenkollektoren im Allgemeinen der Wärmeumgebung ausgesetzt sind, da sie direktem Sonnenlicht ausgesetzt sind und aus offensichtlichen Gründen. Der beste Weg, um die Temperatur von Solarmodulen zu messen, ist die Verwendung eines Temperatursensors für flache Oberflächen. Es wird auch empfohlen, ein Thermoelement vom Typ K zu verwenden, das direkt im Solarpanel platziert ist.

Für unsere Anwendung haben wir ein Temperatursensormodul auf Thermistorbasis verwendet, das unten gezeigt wird.

Schaltplan für die IoT-basierte Überwachung der Solarenergie

Das vollständige Schaltbild für den IoT Enabled Solar Power Monitor ist unten dargestellt. Das Schema ist einfach. Das rote Strichpunktbrett ist das MPPT-Brett, das wir für dieses Projekt verwendet haben.

Einrichten des ThingSpeak

Erstellen Sie ein Konto bei ThingSpeak, gehen Sie zur Option "Mein Kanal" und klicken Sie dann auf " Neuer Kanal".

Erstellen Sie einen neuen Kanal mit den Feldnamen.

Wechseln Sie nun nach dem Festlegen des Felds zum Feld API-Schlüssel, in dem der API-Schlüssel schreiben verfügbar ist. Dieser Schlüssel muss im Code sowie in der Kanal-ID angegeben werden.

Die ThingSpeak-Adresse finden Sie auf derselben Seite.

Mit den obigen Schritten können Sie ThingSpeak sehr einfach einrichten. Wenn Sie mehr über ThingSpeak und seinen Einrichtungsprozess erfahren möchten, lesen Sie unsere vorherigen Artikel zu diesem Thema.

Arduino-Code für die Überwachung der Solarenergie mit ESP32

Den vollständigen ESP32-Code zur Überwachung der Solarenergie finden Sie unten auf dieser Seite. Der Code beginnt mit der Definition Ihrer SSID, Ihres Passworts und einiger anderer konstanter Parameter, wie unten gezeigt.

// WiFi SSID & PWD für Uplink definieren. #define WLAN_SSID "xxxx" #define WLAN_PASS "xxxxxxxxxx"

// Widerstand bei 25 Grad C #define THERMISTORNOMINAL 10000 // temp. für Nennwiderstand (fast immer 25 ° C) #define TEMPERATURENOMINAL 25 // Der Beta-Koeffizient des Thermistors (normalerweise 3000-4000) #define BCOEFFICIENT 3950 // der Wert des 'anderen' Widerstands #define SERIESRESISTOR 10000

Der Thermistor-Nennohm wird bei der Nenntemperatur bereitgestellt. Stellen Sie diesen Wert abhängig vom Datenblatt des Thermistors ein. Geben Sie den Beta-Koeffizienten und den Vorwiderstandswert des Thermistors ein.

// Analog für Strom und Spannung definieren const int curr_an_pin = 35; const int volt_an_pin = 34; const int ntc_temp_an_pin = 33;

Die PINs werden hier definiert.

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

Geben Sie den thingSpeakAddress, channelID, Write Feed API Key ein. Der Rest der Dinge ist nicht erforderlich, aber dennoch nützlich, wenn Daten aus dem Web empfangen werden müssen.

void setup () { // Gib deinen Setup-Code hier ein, um ihn einmal auszuführen: // setze die serielle Schnittstelle auf 115200 Serial.begin (115200); // Serielle Verzögerung initialisieren (1000); WiFi.mode (WIFI_STA); ThingSpeak.begin (Client); // ThingSpeak initialisieren // Aufgabe: Erstellen Sie eine Aufgabe, um einen Pin zum Abrufen von Strom und Spannung zu lesen und Watt und Temperatur des Solarpanels zu berechnen. XTaskCreate ( wifi_task, / * Task-Funktion. * / "Wifi_task", / * String mit dem Namen Aufgabe. * / 1024 * 2, / * Stapelgröße in Bytes. * / NULL, / * Parameter als Eingabe der Aufgabe übergeben * / 5, / * Priorität der Aufgabe. * / NULL); / * Aufgabenhandle. * / Serial.print ("Daten lesen"); }}

Im obigen Code wird der ThingSpeak-Server initialisiert und eine Aufgabe erstellt, die die Daten zum Solarpanel abruft.

In der Hauptschleife werden der Solarstrom und die Sonnenspannung über einen analogen Pin erfasst und der Durchschnitt ermittelt.

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); Verzögerung (10); } // Durchschnitt aller Samples aus 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 / = NUMSAMPLES; volt_avg / = NUMSAMPLES; temp_avg / = NUMSAMPLES; //Serial.print("ADC VALUE = "); //Serial.println(ADC_VALUE); // ADC-Wert in Spannungen umwandeln, um den tatsächlichen Strom und die Spannung zu erhalten. float solar_curr = (curr_avg * 3.3) / (4095); float solar_volt = (volt_avg * 3,3) / (4095); // Mit einem Spannungsteiler verringern wir die tatsächliche Spannung. // Aus diesem Grund multiplizieren wir die 6 mit der durchschnittlichen Spannung, um die tatsächliche Spannung des Solarpanels zu erhalten. Solar_Volt * = 6;

Die Sonnenspannung wird durch Multiplikation mit 6 abgegeben, während wir den Spannungsteiler erstellt haben, der die Eingangsspannung durch das 6-fache teilt.

Die Temperatur wird vom Thermistor unter Verwendung einer logarithmischen Formation erzeugt.

// konvertiere den Wert in Widerstand temp_avg = 4095 / temp_avg - 1; temp_avg = SERIESRESISTOR / temp_avg; //Serial.print("Thermistor Widerstand "); //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; // Steinhart umkehren - = 273.15; // absolute Temperatur in C umwandeln

Die Daten werden alle 15 Sekunden gelesen.

Verzögerung (1000); count ++; 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 ("Solartemperatur ="); Serial.println (Steinhart); Serial.println ("====================================================== =========================== ");

Die Daten für die jeweiligen Felder werden mit der Funktion Thing.Speak.setField () übertragen; wenn das WiFi verbunden ist.

if (WiFi.status () == WL_CONNECTED) { ThingSpeak.setField (1, solar_volt); ThingSpeak.setField (2, solar_curr); ThingSpeak.setField (3, solar_watt); ThingSpeak.setField (4, steinhart); // schreibe in den ThingSpeak-Kanal int x = ThingSpeak.writeFields (channelID, writeFeedAPIKey); if (x == 200) { Serial.println ("Kanalaktualisierung erfolgreich."); } else { Serial.println ("Problem beim Aktualisieren des Kanals. HTTP-Fehlercode" + String (x)); } } else { Serial.println ("\ r \ n ######################################## ######################## "); Serial.println ("Fehler beim Aktualisieren der Daten auf thingSpeak Server."); Serial.println ("WiFi nicht verbunden…"); Serial.println ("################################################ ################ \ r \ n "); } Serial.print ("Daten lesen"); } }

Die Wi-Fi-Aufgabe, die im folgenden Code-Snippet erstellt wurde.

void wifi_task (void * parameter) { while (1) { if (WiFi.status ()! = WL_CONNECTED) { Serial.print ("Versuch, eine Verbindung zur SSID herzustellen:"); Serial.println (WLAN_SSID); while (WiFi.status ()! = WL_CONNECTED) { WiFi.begin (WLAN_SSID, WLAN_PASS); // Verbindung zum WPA / WPA2-Netzwerk herstellen. Ändern Sie diese Zeile, wenn Sie das offene oder WEP-Netzwerk Serial.print (".") Verwenden. Verzögerung (5000); } Serial.println ("\ nConnected."); Serial.println (); Serial.println ("WiFi verbunden"); Serial.println ("IP-Adresse:"); Serial.println (WiFi.localIP ()); } vTaskDelay (1000 / portTICK_PERIOD_MS); } vTaskDelete (NULL); }}

Daten testen und überwachen

Das Solarpanel ist mit dem Stromkreis verbunden und wird zum Testen wie unten gezeigt ins Sonnenlicht gestellt.

Die gesamte Arbeitsweise wird im folgenden Video demonstriert. Unsere Schaltung war in der Lage, die Ausgangsspannung, den Strom und die Leistung vom Panel abzulesen und live auf dem Dingspeak-Kanal zu aktualisieren, wie unten gezeigt.

Wie wir sehen können, sind in der obigen Grafik 15-Minuten-Daten dargestellt. Da es sich um ein Betriebsprojekt im Freien handelt, muss eine geeignete Leiterplatte zusammen mit einer beiliegenden Box verwendet werden. Das Gehäuse muss so hergestellt sein, dass der Stromkreis bei Regen wasserdicht bleibt. Um diese Schaltung zu ändern oder weitere Aspekte dieses Projekts zu diskutieren, nutzen Sie bitte das aktive Forum von Circuit Digest. Ich hoffe, Ihnen hat das Tutorial gefallen und Sie haben etwas Nützliches gelernt.