Arduino-basierter MPPT Solar-Laderegler für optimale PV-Leistungsausbeute

Komponenten und Zubehör

Komponente	Menge	Hinweis
Arduino Nano R3	1
Spule 100 µH	1	Strombelastbarkeit muss zur benötigten Leistung passen
Power MOSFET N-Kanal	1
Adafruit Standard LCD - 16x2 Weiß auf Blau	1

Benötigte Werkzeuge und Maschinen

• Lötkolben (generic)

Apps und Online-Dienste

• Arduino IDE

Über dieses Projekt

Es gibt viele Laderegler auf dem Markt, aber gewöhnliche billige Laderegler sind nicht effizient für die Nutzung der maximalen Leistung aus Solarpaneelen. Und die effizienten sind sehr teuer.

Deshalb beschloss ich, meinen eigenen Laderegler zu bauen, der effizient und intelligent genug ist, um die Bedürfnisse des Akkus und die Solarbedingungen zu verstehen. Er ergreift geeignete Maßnahmen, um die maximal verfügbare Leistung aus der Sonne zu ziehen und sie sehr effizient in den Akku zu speisen.

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

Unsere Solarpaneele sind "dumm" und nicht intelligent genug, um die Akkubedingungen zu verstehen. Nehmen wir an, wir haben ein 12V/100 Watt Solarpaneel, das eine Ausgabe zwischen 18V-21V liefert (je nach Hersteller), aber Akkus haben eine Nennspannung von 12V. Bei Vollladung sind es 13.6V und bei Tiefentladung 11.0V. Nehmen wir an, unsere Akkus laden bei 13V, die Paneele liefern 18V, 5.5A bei 100% Wirkungsgrad (in der Praxis nicht möglich, aber der Einfachheit halber angenommen). Herkömmliche Regler haben eine PWM-Spannungsregelschaltung, die die Spannung auf 13.6V senkt, ohne Stromgewinn. Sie bieten nur Schutz vor Überladung und Leckstrom zu den Paneelen nachts.

Um diesem Problem entgegenzuwirken, habe ich einen SMPS-Abwärtswandler (Buck Converter) verwendet. Diese Art von Wandler hat einen Wirkungsgrad von über 90%. Selbst 90% gelten als schlecht.

Das zweite Problem ist der nicht-lineare Ausgang von Solarpaneelen. Sie müssen an einer bestimmten Spannung betrieben werden, um die maximal verfügbare Leistung zu ernten. Ihre Ausgabe variiert im Tagesverlauf.

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

Durch die Verwendung von MPPT erzeugen unsere Paneele die maximal verfügbare Leistung und der Buck-Wandler speist diese Ladung effizient in die Akkus ein.

Schritt 2: Wie funktioniert MPPT?

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

In diesem Projekt habe ich die Eingangs- und Ausgangs-VI-Kennlinien verfolgt. Durch Multiplikation der Eingangs- und Ausgangs-VI-Werte erhalten wir die Leistung in Watt.

Angenommen, wir haben 17V 5A, also 17x5 = 85 Watt, zu einem bestimmten Tageszeitpunkt. Gleichzeitig beträgt unsere Ausgabe 13V 6A, also 13x6 = 78 Watt.

Der MPPT erhöht oder verringert die Ausgangsspannung, indem er sie mit der vorherigen Eingangs-/Ausgangsleistung vergleicht. War die vorherige Eingangsleistung höher und die Ausgangsspannung niedriger als die aktuelle, wird die Ausgangsspannung wieder gesenkt, um zum Hochleistungspunkt zurückzukehren. War die Ausgangsspannung hoch, wird die aktuelle Spannung auf das vorherige Niveau erhöht. So oszilliert es um den maximalen Leistungspunkt. Diese Oszillationen werden durch effiziente MPPT-Algorithmen minimiert.

Schritt 3: MPPT auf Arduino implementieren

Dies ist das Gehirn dieses Ladegeräts. Hier ist der Arduino-Code zur Regelung der Ausgabe und Implementierung von MPPT in einem einzigen Codeblock:

// Iout = Ausgangsstrom // Vout = Ausgangsspannung // Vin = Eingangsspannung
// Pin = Eingangsleistung, Pin_previous = letzte Eingangsleistung
// Vout_last = letzte Ausgangsspannung, Vout_sense = aktuelle Ausgangsspannung

void regulate(float Iout, float Vin, float Vout) {
  if ((Vout > Vout_max) || (Iout > Iout_max) || 
      ((Pin > Pin_previous && Vout_sense < Vout_last) || 
       (Pin < Pin_previous && Vout_sense > Vout_last))) {
    if (duty_cycle > 0) { duty_cycle -= 1; }
    analogWrite(buck_pin, duty_cycle);
  } else if ((Vout < Vout_max) && (Iout < Iout_max) && 
             ((Pin > Pin_previous && Vout_sense > Vout_last) || 
              (Pin < Pin_previous && Vout_sense < Vout_last))) {
    if (duty_cycle < 240) { duty_cycle += 1; }
    analogWrite(buck_pin, duty_cycle);
  }
  Pin_previous = Pin;
  Vin_last = Vin;
  Vout_last = Vout;
}

Schritt 4: Buck Converter (Abwärtswandler)

Ich habe einen N-Kanal-MOSFET für den Buck Converter verwendet. Normalerweise wählt man P-Kanal-MOSFETs für High-Side-Schaltung, und wenn man N-Kanal für denselben Zweck wählt, wird ein Treiber-IC oder eine Bootstrap-Schaltung benötigt.

Aber ich habe die Buck-Converter-Schaltung modifiziert, um Low-Side-Schaltung mit N-Kanal-MOSFET zu ermöglichen. Ich verwende N-Kanal, weil diese kostengünstig sind, hohe Leistungsdaten haben und geringere Leistungsverluste aufweisen. Dieses Projekt verwendet den IRFZ44N Logic-Level-MOSFET, der direkt von einem Arduino-PWM-Pin angesteuert werden kann.

Für höhere Lastströme sollte man einen Transistor verwenden, um 10V am Gate anzulegen, um den MOSFET vollständig in Sättigung zu treiben und die Leistungsverluste zu minimieren. Das habe ich ebenfalls getan.

Wie im Schaltplan zu sehen, habe ich den MOSFET auf der Minus-Seite platziert, wodurch die +12V vom Panel als Masse dienen. Diese Konfiguration ermöglicht die Verwendung eines N-Kanal-MOSFETs für den Buck Converter mit minimalen Bauteilen.

Aber es hat auch Nachteile: Da beide Seiten getrennte Minus-Spannungen haben, gibt es keine gemeinsame Referenzmasse mehr. Die Spannungsmessung wird dadurch sehr knifflig.

Ich habe den Arduino an die Solareingangsklemmen angeschlossen, wobei seine Minus-Leitung als Masse für den Arduino dient. Die Eingangsspannung können wir hier leicht mit einem Spannungsteiler messen. Aber die Ausgangsspannung lässt sich nicht so einfach messen, da wir keine gemeinsame Masse haben.

Hier ist der Trick: Statt die Spannung am Ausgangskondensator zu messen, messe ich die Spannung zwischen den beiden Minus-Leitungen. Mit Solar-Minus als Masse für den Arduino und Ausgabe-Minus als Messsignal. Der erhaltene Wert muss von der gemessenen Eingangsspannung subtrahiert werden, um die echte Ausgangsspannung am Ausgangskondensator zu erhalten.

Vout_sense_temp = Vout_sense_temp * 0.92 + float(raw_vout) * volt_factor * 0.08; // Spannung zwischen Eingangs-GND und Ausgangs-GND messen
Vout_sense = Vin_sense - Vout_sense_temp - diode_volt; // Spannungsdifferenz zwischen den beiden Massen in Ausgangsspannung umrechnen

Für Strommessungen habe ich ACS712-Stromsensoren verwendet. Diese werden vom Arduino gespeist und am Eingangs-GND angeschlossen.

Interne Timer wurden modifiziert, um 62,5 kHz PWM an Pin D6 zu erzeugen, der den MOSFET treibt. Eine Ausgangs-Sperrdiode ist erforderlich für Rückstrom- und Verpolungsschutz – eine Schottky-Diode mit gewünschter Strombelastbarkeit. Der Spulenwert hängt von Frequenz und Ausgangsstrom ab. Online-Buck-Converter-Rechner oder 100µH 5A-10A Last verwenden. Die maximale Ausgangsstrom der Spule nie um mehr als 80-90% überschreiten.

Schritt 5: Feinschliff

Sie können zusätzliche Funktionen hinzufügen. Meines hat ein LCD zur Anzeige der Parameter und 2 Schalter für Benutzereingaben. Ich werde den finalen Code und den vollständigen Schaltplan bald aktualisieren.

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

UPDATE: Ich habe den Code, die Stückliste und den Schaltplan hochgeladen. Er unterscheidet sich leicht von meinem, da dieser einfacher zu bauen ist.

Solar_charger_tutorial_code.ino

Code

Solar_charger_tutorial_code.ino (Arduino)

///////////////////////////////////////////////////////////////////////////////////////
// Terms of use
///////////////////////////////////////////////////////////////////////////////////////
#include <LiquidCrystal.h>
#include <avr/wdt.h>
#include <EEPROM.h>

#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 4

uint8_t auto_mode = 1;
float Pin = 0, Pout = 0, Pin_previous = 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 heat_sink_temp;
float Vin_sense;
uint8_t duty_cycle = 0;
float volt_factor = 0.05376; // Zum Kalibrieren der Spannungsmessungen anpassen
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 column, int row);
void UI();
void set_limits(int cmd, int temp);
void mem_read();
void mem_write();
void mppt();

void setup() {
  wdt_disable();
  watchdogSetup();
  Serial.begin(115200);
  mem_read();
  pinMode(light, OUTPUT);
  pinMode(charge_led, OUTPUT);
  digitalWrite(charge_led, LOW);
  digitalWrite(light, HIGH);
  pinMode(led, OUTPUT);
  pinMode(fan, OUTPUT);
  pinMode(menu, INPUT);
  pinMode(button, INPUT);
  digitalWrite(menu, HIGH);
  digitalWrite(button, HIGH);
  TCCR0B = TCCR0B & 0b11111000 | 0x01; // PWM auf Max... 62.5 kHz
  analogWrite(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);
  // ... Initialisierung der ADC-Werte ...
}

void watchdogSetup(void) {
  cli();
  wdt_reset();
  WDTCSR |= (1 << WDCE) | (1 << WDE);
  WDTCSR = (1 << WDIE) | (1 << WDE) | (1 << WDP3) | (0 << WDP2) | (0 << WDP1) | (1 << WDP0);
  sei();
}

ISR(WDT_vect) {
  Serial.println("WDT reset.");
  asm volatile (" jmp 0");
}

void regulate(float Iout, float Vin, float Vout) {
  mode = "Buck mode";
  if ((Vout > Vout_max) || (Iout > Iout_max) || 
      ((Pin > Pin_previous && Vin_sense < Vin_last) || 
       (Pin < Pin_previous && Vin_sense > Vin_last))) {
    if (duty_cycle > 0) { duty_cycle -= 1; }
    analogWrite(buck_pin, duty_cycle);
  } else if ((Vout < Vout_max) && (Iout < Iout_max) && 
             ((Pin > Pin_previous && Vin_sense > Vin_last) || 
              (Pin < Pin_previous && Vin_sense < Vin_last))) {
    if (duty_cycle < 250) { duty_cycle += 1; }
    analogWrite(buck_pin, duty_cycle);
  }
  Pin_previous = Pin;
  Vin_last = Vin;
}

// ... weitere Funktionen: auto_cutoff, soft_start, lcd_show, lcd_num, UI, mem_save, mem_read, set_limits, loop ...

Der vollständige Code ist sehr umfangreich und enthält Watchdog-Timer, EEPROM-Speicherung, Benutzeroberfläche über Tasten, Lüftersteuerung und mehr.

Schaltpläne