Arduino - PV MPPT Solarladegerät

Notwendige Werkzeuge und Maschinen

Lötkolben (generisch)

Apps und Onlinedienste

Arduino-IDE

Über dieses Projekt

Es gibt viele Laderegler auf dem Markt, aber gewöhnliche billige Laderegler sind nicht effizient für die Verwendung mit maximaler Leistung von Sonnenkollektoren. Und diejenigen, die effizient sind, sind sehr teuer.

Also beschloss ich, meinen eigenen Laderegler zu entwickeln, der effizient und intelligent genug ist, um den Batteriebedarf und die Solarbedingungen zu verstehen. Es ergreift geeignete Maßnahmen, um die maximal verfügbare Energie aus der Solarenergie zu beziehen und sehr effizient in die Batterie zu legen.

Wenn Ihnen meine Bemühungen gefallen, dann stimmen Sie bitte für dieses Tutorial.

Schritt 1:Was ist MPPT und warum brauchen wir es?

Unsere Solarmodule sind dumm und nicht intelligent genug, um den Batteriezustand zu verstehen. Angenommen, wir haben ein 12V/100-Watt-Solarpanel und es liefert je nach Hersteller eine Leistung zwischen 18V-21V, aber Batterien sind für eine Nennspannung von 12V ausgelegt. Bei voller Ladung betragen sie 13,6 V und bei vollständiger Entladung 11,0 V. Nehmen wir nun an, unsere Batterien werden mit 13 V geladen, die Panels liefern 18 V, 5,5 A bei 100% Arbeitseffizienz (nicht möglich, 100% zu haben, aber nehmen wir an). Gewöhnliche Controller haben einen PWM-Spannungsregler ckt, der die Spannung ohne Stromverstärkung auf 13,6 absenkt. Es bietet nur nachts Schutz gegen Überladung und Kriechströme der Panels.

Um diesem Problem zu begegnen, habe ich smps Buck Converter verwendet. Diese Art von Konverter hat einen Wirkungsgrad von über 90%. Sogar 90% gelten als arm.

Das zweite Problem, das wir haben, ist die nichtlineare Leistung von Sonnenkollektoren. Sie müssen mit einer bestimmten Spannung betrieben werden, um die maximal verfügbare Leistung zu ernten. Ihre Leistung variiert im Laufe des Tages.

Um dieses Problem zu lösen, werden MPPT-Algorithmen verwendet. MPPT (Maximum Power Point Tracking), wie der Name schon sagt, verfolgt dieser Algorithmus die maximal verfügbare Leistung von Panels und variiert die Ausgangsparameter, um den Zustand aufrechtzuerhalten.

Durch die Verwendung von MPPT erzeugen unsere Panels also die maximal verfügbare Leistung und der Abwärtswandler wird diese Ladung effizient in die Batterien einspeisen.

Schritt 2:Wie funktioniert MPPT?

Ich werde dies nicht im Detail besprechen. Wenn Sie es also verstehen möchten, sehen Sie sich diesen Link an - Was ist MPPT?

In diesem Projekt habe ich auch die Eingangs-V-I-Eigenschaften und die Ausgangs-V-I verfolgt. Durch Multiplizieren von Input V-I und Output V-I erhalten wir die Leistung in Watt.

Sagen wir, wir haben zu jeder Tageszeit 17 V 5 A, also 17x5 =85 Watt. Gleichzeitig beträgt unsere Leistung 13 V 6A, also 13x6 =78 Watt.

Jetzt erhöht oder verringert MPPT die Ausgangsspannung durch Vergleich mit der vorherigen Eingangs-/Ausgangsleistung.

Wenn die vorherige Eingangsleistung hoch und die Ausgangsspannung niedriger war als die aktuelle, wird die Ausgangsspannung wieder gesenkt, um wieder auf die hohe Leistung zu gelangen. Und wenn die Ausgangsspannung hoch war, wird die aktuelle Spannung auf das vorherige Niveau erhöht. Dadurch schwingt es ständig um den Punkt der maximalen Leistung. Diese Schwingungen werden durch effiziente MPPT-Algorithmen minimiert.

Schritt 3:MPPT auf Arduino implementieren

Dies ist das Gehirn dieses Ladegeräts. Unten ist der Arduino-Code, um die Ausgabe zu regulieren und MPPT in einem einzigen Codeblock zu implementieren.

// Iout =Ausgangsstrom// Vout =Ausgangsspannung// Vin =Eingangsspannung// Pin =Eingangsleistung, Pin_vorherige =letzte Eingangsleistung// Vout_last =letzte Ausgangsspannung, Vout_sense =aktuelle Ausgangsspannungvoid Regulieren (float Iout, float Vin, float Vout) {
 if((Vout>Vout_max) || (Iout>Iout_max) || ((Pin>Pin_vorher &&Vout_senseVout_last ))) { if(Arbeitszyklus>0) { Arbeitszyklus -=1; } analogWrite (buck_pin,duty_cycle); } else if ((VoutPin_vorher &&Vout_sense>Vout_last) || (Pin Arbeitszyklus+=1; } analogWrite (buck_pin,duty_cycle); } Pin_vorheriger =Pin; Vin_last =Vin;Vout_last =Vout;} 

Schritt 4:Buck-Konverter

Ich habe N-Kanal-Mosfet verwendet, um den Abwärtswandler zu machen. Normalerweise wählen Leute P-Kanal-Mosfet für High-Side-Switching und wenn sie N-Kanal-Mosfet für den gleichen Zweck wählen, ist ein Treiber-IC erforderlich oder Boot-Strapping ckt.

Aber ich habe den Abwärtswandler ckt so modifiziert, dass er eine Low-Side-Umschaltung mit N-Kanal-Mosfet hat. Ich verwende N-Kanal, weil dies kostengünstig ist, eine hohe Nennleistung und eine geringere Verlustleistung bietet. Dieses Projekt verwendet IRFz44n-Mosfet mit Logikpegel, sodass es direkt von einem Arduino-PWM-Pin angesteuert werden kann.

Für einen höheren Laststrom sollte man einen Transistor verwenden, um 10 V am Gate anzulegen, um den Mosfet vollständig in die Sättigung zu bringen und die Verlustleistung zu minimieren. Ich habe das gleiche getan.

Wie Sie in ckt oben sehen können, habe ich den Mosfet auf -ve-Spannung gelegt und somit +12 V vom Panel als Masse verwendet. Diese Konfiguration ermöglicht es mir, einen N-Kanal-Mosfet für Abwärtswandler mit minimalen Komponenten zu verwenden.

Aber es hat auch einige Nachteile. Da Sie beide Seiten -Ve-Spannung getrennt haben, haben Sie keine gemeinsame Bezugsmasse mehr. Daher ist das Messen von Spannungen sehr schwierig.

Ich habe das Arduino an Solareingangsklemmen angeschlossen und seine -Ve-Leitung als Masse für Arduino verwendet. Wir können die Eingangsspannung an dieser Stelle leicht messen, indem wir einen Spannungsteiler ckt gemäß unserer Anforderung verwenden. Aber wir können die Ausgangsspannung nicht so einfach messen, da wir keine gemeinsame Masse haben.

Dafür gibt es jetzt einen Trick. Anstatt die Spannung am Ausgangskondensator zu messen, habe ich die Spannung zwischen zwei -Ve-Leitungen gemessen. Verwenden von Solar -Ve als Masse für den Arduino und Ausgang -Ve als zu messendes Signal / Spannung. Der Wert, den Sie mit dieser Messung erhalten haben, sollte von der gemessenen Eingangsspannung abgezogen werden und Sie erhalten die tatsächliche Ausgangsspannung am Ausgangskondensator.

Vout_sense_temp=Vout_sense_temp*0.92+float(raw_vout)*volt_factor*0.08; // Spannung über Eingangsmasse und Ausgangsmasse messen.
 Vout_sense=Vin_sense-Vout_sense_temp-diode_volt; // Spannungsdifferenz zwischen zwei Erdungen in Ausgangsspannung ändern..  

Für Strommessungen habe ich ACS-712 Strommessmodule verwendet. Sie wurden von Arduino mit Strom versorgt und mit dem Eingang GND verbunden.

Interne Timer werden modifiziert, um 62,5 kHz PWM an Pin D6 zu gewinnen, der zum Ansteuern des MOSFET verwendet wird. Eine Ausgangssperrdiode ist erforderlich, um einen Sperrstrom- und Verpolungsschutz bereitzustellen. Verwenden Sie zu diesem Zweck eine Schottky-Diode mit dem gewünschten Nennstrom. Der Wert der Induktivität hängt von den Anforderungen an die Frequenz und den Ausgangsstrom ab. Sie können online verfügbare Abwärtswandler-Rechner verwenden oder 100uH 5A-10A Last verwenden. Überschreiten Sie niemals den maximalen Ausgangsstrom des Induktors um 80%-90%.

Schritt 5:Letzte Nachbesserung

Sie können Ihrem Ladegerät auch zusätzliche Funktionen hinzufügen. Meine haben ein LCD zur Anzeige der Parameter und 2 Schalter, um Eingaben vom Benutzer entgegenzunehmen.

Ich werde den endgültigen Code aktualisieren und das ckt-Diagramm sehr bald vervollständigen.

Schritt 6:Tatsächlicher Schaltplan, Stückliste und Code

AKTUALISIEREN:

Ich habe den Code, die BOM und die Schaltung hochgeladen. Es unterscheidet sich ein wenig von meinem, weil es einfacher ist, dieses zu machen.

Code

• Solar_charger_tutorial_code.ino

Solar_charger_tutorial_code.inoArduino

///////////////////////////////////////////// //////////////////////////////////////////Nutzungsbedingungen///// //////////////////////////////////////////////// /////////////////////////////////DIE SOFTWARE WIRD "WIE BESEHEN", OHNE JEGLICHE GEWÄHRLEISTUNG, AUSDRÜCKLICH BEREITGESTELLT ODER//IMPLIZIERT, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF DIE GARANTIEN DER MARKTFÄHIGKEIT,//EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND NICHTVERLETZUNG. IN KEINEM FALL HAFTEN DIE AUTOREN ODER URHEBERRECHTSINHABER FÜR JEGLICHE ANSPRÜCHE, SCHÄDEN ODER ANDERE // HAFTUNG, OB AUS VERTRAGLICHEM, SCHLECHTER ODER ANDERWEITIGEM, DIE AUS ODER IN VERBINDUNG MIT DER SOFTWARE ODER DER VERWENDEN ODER ANDERES HANDELN IN//DER SOFTWARE./////////////////////////////////////// //////////////////////////////////////////////#include #include #include #define vin_pin A1#define vout_pin A0#define iout_pin A2#define iin_pin A3#define lm35 A4#define fan 5#define buck_pin 6#define menu 3#define button 2#define led 13#define charge_led A5#define light 4uint8_t auto_mode=1;float Pin=0,Pout=0,Pin_vorher=0;float Efficiency=0.0;int raw_vin=0, raw_vout=0, raw_iout =0,raw_iin=0, raw_lm35=0;float Vout_boost=14.5,Vout_max=15.0, Iout_max=5.0, Vout_float=13.5, Iout_min=0.00,Vin_thresold=10.0;float Iout_sense,Iin_sense,Iin;float Vout_sense,Vin_last;float;float Vin_sense;uint8_t duty_cycle =0;float volt_factor =0.05376; // diesen Wert ändern, um Spannungsmesswerte zu kalibrieren...String mode="";bool startup=true, lcd_stat=true,charge=true,mppt_init =true;unsigned int count=0;LiquidCrystal lcd(7, 8, 9, 10, 11, 12);void lcd_show(String data,int Spalte, int row);void UI();void set_limits(int cmd,int temp);void mem_read();void mem_write();void mppt(); Void setup () {wdt_disable (); WatchdogSetup(); // Geben Sie Ihren Setup-Code hier ein, um ihn einmal auszuführen:Serial.begin(115200);mem_read();pinMode(light,OUTPUT);pinMode(charge_led,OUTPUT);digitalWrite(charge_led,LOW);digitalWrite(light,HIGH);pinMode(led,OUTPUT);pinMode(lüfter,OUTPUT);pinMode(menu,INPUT);pinMode(button,INPUT);digitalWrite(menu,HIGH);digitalWrite(button,HIGH);TCCR0B =TCCR0B &0b11111000 | 0x01; / set pwm at Max... 62.5 KhzanalogWrite(buck_pin,0);lcd.begin(16,2);lcd_show("Solar Charger",0,0);delay(64000);wdt_reset();delay(64000);wdt_reset();lcd_show("Vi Vb Ib", 0,0);//////////////////for(int i=0;i<10;i++) { raw_iout +=analogRead(iout_pin)-513;raw_iin +=analogRead(iin_pin)-513;raw_vin +=analogRead(vin_pin);raw_vout +=analogRead(vout_pin);raw_lm35 +=analogRead(lm35);delay(2); } raw_iout=raw_iout/10; raw_iin=raw_iin/10; raw_vout=raw_vout/10; raw_vin=raw_vin/10; Iout_sense=float(raw_iout)*5/1023/0.066; Iin_sense=float(raw_iin)*5/1023/0.066; Vout_sense_temp=float(raw_vout)*volt_factor; Vin_sense=float(raw_vin)*volt_factor; // heat_sink_temp =raw_lm35*0.48; // 0,0049*1000/10 // heat_sink_temp =heat_sink_temp-273.15; // Kommentar entfernen, wenn LM235 verwendet wird} //////////void watchdogSetup (void) {cli (); // alle Interrupts deaktivierenswdt_reset(); // WDT-Timer zurücksetzen // Watchdog-Konfigurationsmodus aufrufen:WDTCSR |=(1<Vout_max) || (Iout>Iout_max) || ((Pin>Pin_vorher &&Vin_senseVin_last))) { if(duty_cycle>0) { duty_cycle-=1; } analogWrite (buck_pin,duty_cycle); } else if((VoutPin_vorher &&Vin_sense>Vin_last) || (PinIout_min+1){ charge =true; } ///////////// if((Vout>Vout_max) &&(Iout
 80.0) { Duty_cycle =0; analogWrite (buck_pin,duty_cycle); Serial.println ("Abschaltung bei Überhitzung"); lcd_show("Überhitzungsfehler ",0,1); wdt_reset(); for(int i=0;i<10;i++){digitalWrite(led,HIGH); digitalWrite (charge_led, LOW); Verzögerung (4000); digitalWrite (charge_led, HIGH); digitalWrite (led, LOW); Verzögerung (4000); } wdt_reset(); aufrechtzuerhalten. Sonst { Gebühr =wahr; digitalWrite (charge_led, HIGH); regulieren (Iout_sense, Vin_sense, Vout_sense); digitalWrite (led, LOW); }}void soft_start() { for(int i=0;i<20;i++) {Regulieren(Iout_sense, Vin_sense, Vout_sense);Serial.print("Vin=");Serial.println(Vin_sense);Serial.print ("Vout=");Serial.println(Vout_sense);Serial.print("Iout=");Serial.println(Iout_sense);Serial.print("Duty cycle=");Serial.println(duty_cycle);Serial .print("Lademodus:");Serial.println(mode);Serial.println("Softstart aktiviert"); Verzögerung (32000); } start=false; mppt_init =false;}void lcd_show(String data,int column,int row) {lcd.setCursor(column,row); if(data.length()>0) { for(int i=0;i
45.0){ digitalWrite(lüfter,HIGH);}else if(heat_sink_temp<37.0){ digitalWrite(lüfter,LOW);}count++;}

Schaltpläne