All-in-One Solarstrom-Zentrale: Laderegler, Wechselrichter, Powerbank & LED-Lampe

Komponenten und Zubehör

	Microchip Technology Atmega8	×	1
	Buck Converter	×	1
	SparkFun LED - 3W Aluminum PCB (5er Pack, Warmweiß)	×	1
	Nokia 5110 Display	×	1
	SparkFun Kühlkörper	×	1
	SparkFun N-Kanal MOSFET	×	4
	SparkFun P-Kanal MOSFET	×	1
	Solarpanel 40 Watt oder weniger für 12V-System	×	1
	SparkFun Lithium-Ionen-Akku - 18650 Zelle	×	1
	DC-DC 0,9V-5V zu USB Modul 5V DC Boost Step-up	×	1
	Allzweck-Transistor NPN	×	1
	12-0-12/220 Mittelanzapf-Transformator	×	1
	1N4007 – Hochspannungs-, Hochstrom-Diode	×	1
	Male-Header 36 Position 1 Row Long (0,1")	×	1
	Schieberschalter	×	1
	SparkFun Taster 12mm	×	1
	Arduino Proto Shield	×	1
	Strip/Vero/Proto Board 8x11 cm	×	1
	Arduino UNO	×	1
	Arduino Nano R3	×	1
	Arduino Mega 2560	×	1
	Low FW Voltage Schottky Diode 5822	×	1
	Kondensator 10 µF	×	1
	Kondensator 100 nF	×	1

Notwendige Werkzeuge und Maschinen

	Lötkolben
	Bohrmaschine
	Heißklebepistole

Apps und Online-Dienste

	Arduino IDE
	AutoDesk 123D

Über dieses Projekt

Über dieses Projekt

Ich hatte einige Solarpaneele, 12-V-Batterien, Transformatoren und mehr herumliegen – sie schrien förmlich danach, sinnvoll genutzt zu werden. So entstand dieses Gerät: eine komplette kleine PV-Lösung auf einer Platine. Lass uns kurz klären, was was macht:

• Laderegler: Regelt das Laden des DC-Speichers/Akkus vom Solarmodul und das Entladen durch die Last, um die Batterielebensdauer zu verlängern.
• Wechselrichter: Wandelt Gleichstrom in Wechselstrom für AC-Lasten um.
• Powerbank: Stellt 5V DC über USB für mobile Geräte bereit (tragbares/Off-Grid-Laden).
• Notlampe: Sehr helle LED-Lichtquelle für Stromausfall, Camping, Outdoor-Aktivitäten nach Einbruch der Dunkelheit.

Mein Gerät vereint all diese Funktionen. Die letzten beiden werden unabhängig vom on-board Li-Ion-Akku versorgt. Mit einem Solarmodul (bis 100 Watt), einer 12-V-Bleibatterie und einem Transformator können alle Optionen genutzt werden.

Proto-Version auf UNO

Die erste Version entstand auf einem UNO-Board mit minimaler Hardware und minimalen Funktionen. Nokia-Display direkt aufgesteckt, MOSFET-Shield für Laden/Entladen. Keine Menüsteuerung, kein Wechselrichter, kein PWM-Laden, keine tollen Features – nur Ein/Aus-Laden und Anzeige von Batterie- und Panelspannung. Erfüllt den Zweck, aber ohne Charme!

Vollausgestattete Version auf Lochrasterplatine

Dann entwickelte ich diese Version mit folgenden Features:

• PWM-Solarladeregler bis 100 Watt Panel
• Rechteck-Wechselrichter Mini 60 Watt
• Bis zu drei 12V-DC-Lastausgänge steuerbar
• Primärer DC-Lastausgang mit Auto-Ein/Aus-Funktion
• Unabhängige USB-Powerbank
• Buck-Regler-Modul
• Onboard-LED-Lampe mit Blink- und Helligkeitssteuerung

Zwei Taster/Schalter für Scroll- und Select-Menü auf Nokia 5110 Display. Rückseite mit Heißkleber isoliert gegen Kurzschlüsse an metallischen Gegenständen!

Weitere Komfortfunktionen: Ein/Aus-Schalter für Display-Hintergrundbeleuchtung, Trennung des Buck-Reglers für unabhängigen Betrieb durch Abschalten vom internen Akku.

Menünavigation auf Nokia 5110 mit User-Button:

Lernen wir etwas Technisches!

Laderegler können On/Off, PWM oder MPPT sein. On/Off ist die einfachste Form (meine V1), die den Ladestrom nicht drosselt, wenn die Batterie sich der Vollladung nähert.

PWM verringert den Ladestrom allmählich, je voller die Batterie wird. Vorteile:

• Hilft, verlorene Kapazität zurückzugewinnen und Batterie zu desulfatieren
• Erhöht die Fähigkeit der Batterie, mehr Ladung aufzunehmen
• Hält hohe durchschnittliche Batteriekapazitäten bis 95 %
• Gleicht abweichende Zellen aus
• Reduziert Batterieerwärmung und Gasung → verhindert Elektrolytverlust
• Verlangsamt Alterung und verlängert Systemlebensdauer

PWM holt aber nicht die maximale elektrische Leistung aus PV-Modulen, da es das Panel nahe der Batteriespannung betreibt. MPPT löst dies: ein einstellbarer Buck-Boost-Wandler, der mehr Solarenergie nutzt.

Wechselrichter: Rechteck, modifizierter Sinus, reiner Sinus. Rechteck ist simpel, gut für kleine DC-Lasten (Glühlampen, CFL, Tischventilatoren, Lötkolben), aber nicht für Induktionsmotoren/empfindliche Geräte (Klirrfaktor). Modifizierter Sinus ist besser. Reiner Sinus ist optimal, aber hardwaremäßig komplex, Software anspruchsvoll, teuer.

Ein Buck-Regler ist ein Schritt-abwärts DC-DC-Wandler. Hier lädt ein Buck-Modul den 4,2V Li-Ion-Akku, der Controller (Arduino + Display), Powerbank und LED-Lampe versorgt.

USB-Powerbank ist im Grunde ein DC-DC-Boost, der 3,3–4,2V vom Li-Ion/LiPo-Akku auf 5V USB-Busspannung wandelt. Er hat auch einen Buck zum Laden des Akkus. In meinem Projekt nimmt das Buck-Modul Energie vom Panel für den internen Akku.

Funktionsweise der Hardware

Vorab: Bild aller Anschlüsse am Gerät:

Das System hat diverse Hardware für verschiedene Zwecke. Das Gehirn ist der AVR Atmega8A (auch Atmega328P mit geringfügigen Änderungen nutzbar, siehe unten), programmiert in Arduino.

Ein frischer Atmega8A wird mit Arduino Optiboot8 Bootloader gebrannt. Man kann auch einen gebootloadeten Arduino Mini/Atmega328 kaufen.

Controller, Display, LED-Lampe und Powerbank werden vom on-board Li-Ion-Akku gespeist. Zwei Taster für Menünavigation (hardware-entprellt über Kondensatoren). Schieberschalter zum Ein-/Ausschalten.

Solarladen: P-MOSFET getrieben von 2N2222-Transistorschaltung, PWM-gesteuert vom Mikrocontroller basierend auf externer Batteriespannung. Strom fließt vom Panel durch P-MOSFET zur Bleibatterie. Bei Vollladung MOSFET abschalten. Spannung fällt, bei 13,6V wieder Laden mit niedrigem Duty Cycle (Erhaltungsladung).

12V-DC-Last: N-MOSFET, Gate vom Mikrocontroller gesteuert.

Onboard-LED-Lampe: Auch N-MOSFET, Gate PWM-gesteuert für Helligkeit.

Wechselrichter-Block: 2 N-MOSFETs, abwechselnd Ein/Aus zur AC-Simulation. Mit externem Mittelanzapf-Transformator entsteht Rechteck-AC.

Funktionsweise: Strom fließt durch Mittelanzapfung der Step-up-Spule in abwechselnder Richtung. Oberer MOSFET an, unterer aus → Strom nach oben. Umgekehrt → Strom nach unten. Beide MOSFETs müssen mit doppelter AC-Frequenz toggeln.

Für 50 Hz AC: abwechselnde Rechteckwelle an 12-0-12V/220V Transformator-Niederspannungsseite. 50 Hz = 20 ms pro Welle → 10 ms pro Halbwelle → 100-mal pro Sekunde Gate-Signale toggeln.

Warnung!!!: AC-Spannung ist lebensgefährlich – Tod/Verletzung möglich! Niemals HV-Seite des Transformators mit bloßer Hand berühren!

Wenn Wechselrichter nicht genutzt wird, erlaubt „2XDC Last“ zwei weitere 12V-DC-Lasten am Wechselrichter-Anschluss.

Magie der Software

Zwei Code-Versionen: Einmal alles in einem Arduino-Tab, einmal aufgeteilt in Tabs nach Funktionen.

Beispiel für Generalisierung:

• Get_ADCVal() misst Panel-, internen und externen Batteriespannung, mittelt 20 Samples, aktualisiert Variablen.
• Context_Control() steuert Benutzerinteraktion, Aktionen, Display-Update.
• Charging_Control(), Discharging_Control(), Load_Control() als Hintergrund-Funktionen (Closed Loop): Batteriespannung überwachen, Auto-Last, Über-/Tiefentladungsschutz.

Benutzereingaben über interrupt-getriebene Taster: INT0/INT1 ISRs ändern volatile Variablen dp und ds. Variable level zusammen mit dp (Display-Zeiger) und ds (Display-Inhalt) ermöglicht Menünavigation und Aktionen.

16-Bit-Timer1 erzeugt alle 10 ms Timer-Overflow-Interrupt und toggelt PIN_INVP und PIN_INVN bei aktivem Wechselrichter.

Alle Lcd_...() Funktionen steuern das Display.

Atmega8A vs. Atmega328P (Uno)

System lässt sich einfach auf Atmega328P/Uno portieren – folgende Änderungen im Code:

TIMSK durch TIMSK1 ersetzen
#define ADC_VREF 2.69 durch #define ADC_VREF 1.11 ersetzen
#define ADCVDIV_R1 22 durch #define ADCVDIV_R1 8.2 ersetzen

Hardware: Statt 22 kΩ Widerstand 8,2 kΩ für Spannungsteiler (Panel/Batterie auf ADC-Messbereich).

Aktionsvideos

Ich schaue lieber Videos als Text. Falls du ähnlich tickst, genieße die Videos (im Original eingebettet).

Verbesserungspotenzial

Flash-Speicher des Atmega8A war erschöpft. Konnte nicht hinzufügen:

• Software-gesteuerter Überlast/Kurzschlussschutz
• Grafische Icons und Logo
• Energiemessung und Logging
• Backup-Zeit-Schätzung und Alarm
• Laptop-Ladeoption
• Unterstützung für 6V-Systeme
• Bluetooth-Laststeuerung
• Timer-basierte Laststeuerung
• RTC-Uhr für weitere Features
• IoT-Anbindung

Atmega328P (Uno) oder Arduino Mega wären besser für all diese Optionen. Aber es funktioniert, ich bin zufrieden.

Zusätzliche Ressourcen

• Arduino 1.0.6 mit Atmega8-Board-Support herunterladen
• Arduino.exe → Tools > Board > Optiboot8
• Bootloader brennen (Methode beachten)
• Code kompilieren und hochladen

Code

Single Tab Code (Arduino)

#define PIN_SCE 12
#define PIN_RESET 13
#define PIN_DC 8
#define PIN_SDIN 7
#define PIN_SCLK 6
#define PIN_INVP 4
#define PIN_INVN 5
#define PIN_LOAD 9 // 12V DC Last
#define PIN_LAMP 10 // WEISSE LED LAMPE
#define PIN_BATTPWM 11 // Treibt PMOS für Ext Batt Laden
#define PIN_BATTint_Sense A2
#define PIN_SOLAR_Sense A0
#define PIN_BATText_Sense A3
#define ADC_VREF 2.695 // interne Referenzspannung, ~1.11V für Arduino Uno/Atmega328P, hier Atmega8A gibt das!
#define ADCVDIV_R1 22 // 22K Spannungsteiler unterer Widerstand
#define ADCVDIV_R2 175 // 175K oberer Widerstand
//const uint8_t skulljoke[] PROGMEM ={2,} ; // PIN 2 & 3 ALS INTERRUPT SCHALTER
// PIN 0 & 1 ALS PROGRAMMIERUNG
// PIN RESET ALS
#define LCD_C LOW
#define LCD_D HIGH
#define LCD_X 84
#define LCD_Y 48
uint8_t x=0;
uint8_t level=0;
uint8_t blinker=0;
boolean Load_Auto_Enable=0;
float maxADC_Voltage=0.0;
float BattInt_Voltage=0.0;
float BattExt_Voltage=0.0;
float PV_Voltage=0.0;
volatile int y=0;
volatile uint8_t dp =0;
volatile uint8_t ds =0;
volatile boolean cycle=0;
volatile uint8_t cdc_level =0;

void setup(void) {
  LcdInitialise();
  LcdClear();
  LcdString("*ARDUBOY PV*");
  LcdString(" CONTROLLER,");
  LcdString("AC INVERTER,");
  LcdString("POWER BANK, ");
  LcdString("LAMP THING!!");
  delay(3000);
  analogReference(INTERNAL);
  maxADC_Voltage=(ADC_VREF/ADCVDIV_R1)*(ADCVDIV_R1+ADCVDIV_R2);
  pinMode(PIN_LOAD,OUTPUT);
  digitalWrite(PIN_LOAD,LOW);
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(0, SW1, FALLING);
  pinMode(3, INPUT_PULLUP);
  attachInterrupt(1, SW2, FALLING);
}

void loop(void) {
  Get_ADCVal();
  Context_Control();
  Charging_Control();
  Discharging_Control();
  Load_Control();
  LcdClear();
}

// ADC Messung
void Get_ADCVal(void) {
  int I=0, J=0, K=0;
  for(x=0;x<20;x++) {
    I+=analogRead(PIN_BATTint_Sense);
    J+=analogRead(PIN_BATText_Sense);
    K+=analogRead(PIN_SOLAR_Sense);
  }
  BattInt_Voltage=I/20.0;
  BattExt_Voltage=J/20.0;
  PV_Voltage=K/20.0;
  BattInt_Voltage=maxADC_Voltage*BattInt_Voltage/1023.0;
  BattExt_Voltage=maxADC_Voltage*BattExt_Voltage/1023.0;
  PV_Voltage=maxADC_Voltage*PV_Voltage/1023.0;
}

// Display & Steuerung
void Context_Control(void) {
  if(ds==0) {show_menu();}
  if(ds==1 && dp == 0) {show_info(); delay(100);}

  // 1. Untermenü: DC Last
  if(ds==1 && dp == 1) {
    level=1; dp=0;
    while(level==1) {
      int temp=ds;
      LcdClear(); show_load_ctrl(); delay(250);
      if (dp==0){ if(ds!=temp){Load_Auto_Enable=0; digitalWrite(PIN_LOAD,LOW);}}
      if (dp==1){ if(ds!=temp){Load_Auto_Enable=0; digitalWrite(PIN_LOAD,HIGH);}}
      if (dp==2){ if(ds!=temp){Load_Auto_Enable=1;}}
      if (dp==3){show_load_ctrl(); delay(250); level=0; dp=0; ds=0;}
    }
  }

  // 2. Untermenü: Wechselrichter
  if(ds==1 && dp == 2) {
    level=2; dp=0;
    while(level==2) {
      int temp=ds;
      show_inv_ctrl(); delay(250); LcdClear();
      if (dp==0){ if(ds!=temp){Timer1_Init();}}
      if (dp==1){ if(ds!=temp){Timer1_DeInit();}}
      if (dp==2){ if(ds!=temp){Timer1_DeInit(); digitalWrite(PIN_INVP,1); digitalWrite(PIN_INVN,1);}}
      if (dp==3){show_inv_ctrl(); delay(250); level=0; dp=0; ds=0;}
    }
  }

  // 3. Untermenü: LED Lampe
  if(ds==1 && dp == 3) {
    level=3; dp=0;
    while(level==3) {
      int temp=ds;
      LcdClear(); show_led_ctrl(); delay(250);
      if (dp==0){blinker=0; if(ds!=temp) {if(y<=255){y+=15; analogWrite(PIN_LAMP,y);}}}
      if (dp==1){blinker=0; if(ds!=temp) {if(y>=0){y-=15; analogWrite(PIN_LAMP,y);}}}
      if (dp==2){ if(ds!=temp) {blinker^=1; analogWrite(PIN_LAMP,127); delay(250); analogWrite(PIN_LAMP,0);}}
      if (dp==3){show_led_ctrl(); delay(250); level=0; dp=0; ds=0;}
    }
  }

  if(blinker==1) {analogWrite(PIN_LAMP,0);}
  delay(250);
  if(blinker==1) {analogWrite(PIN_LAMP,127);}
}

// Menü-Texte für Nokia 5110
void show_menu(void) {
  LcdXY(0,dp); LcdString("->");
  LcdXY(15,0); LcdString("Sys Info");
  LcdXY(15,1); LcdString("DC Load+");
  LcdXY(15,2); LcdString("AC Load~");
  LcdXY(15,3); LcdString("LED Lamp");
}

void show_info(void) {
  LcdXY(0,0); LcdString("Bat_I="); LcdNumtoString(BattInt_Voltage); LcdString("v");
  LcdXY(0,1); LcdString("Bat_E="); LcdNumtoString(BattExt_Voltage); LcdString("v");
  LcdXY(0,2); LcdString("Sol_P="); LcdNumtoString(PV_Voltage); LcdString("v");
  LcdXY(0,3);
  if(BattExt_Voltage > 8.0) LcdString("Batt Conn OK"); else LcdString("Connect Batt");
  if (PV_Voltage > 10.5 && cdc_level!=3 && cdc_level!=0) LcdString("Charging:ON "); else LcdString("Charging:OFF");
  if (TCNT1 >= 45535) LcdString("Inverter:ON"); else LcdString("Inverter:OFF");
}

void show_load_ctrl(void) {
  LcdXY(0,dp); LcdString("->");
  LcdXY(15,0); LcdString("Load Off");
  LcdXY(15,1); LcdString("Load On");
  LcdXY(15,2); LcdString("Load Auto");
  LcdXY(15,3); LcdString("Return");
  LcdXY(0,4); LcdString("Must Connect");
  LcdXY(0,5); LcdString("12V DC Load");
}

void show_inv_ctrl(void) {
  LcdXY(0,dp); LcdString("->");
  LcdXY(15,0); LcdString("AC Inv On");
  LcdXY(15,1); LcdString("AC Inv Off");
  LcdXY(15,2); LcdString("2XDC Load");
  LcdXY(15,3); LcdString("Return");
  LcdXY(0,4); LcdString("2XDC Load,NO");
  LcdXY(0,5); LcdString("TRANSFORMER!");
}

void show_led_ctrl(void) {
  LcdXY(0,dp); LcdString("->");
  LcdXY(15,0); LcdString("LED ++");
  LcdXY(15,1); LcdString("LED --");
  LcdXY(15,2); LcdString("LED Blk");
  LcdXY(15,3); LcdString("Return");
  LcdXY(0,4); LcdString("LED DISABLEs");
  LcdXY(0,5); LcdString("When INVR On");
}

// Interrupt ISRs
void SW1() { dp++; if(dp>3) dp=0; }
void SW2() { ds^=1; }

ISR(TIMER1_OVF_vect) {
  noInterrupts();
  TCNT1 = 45535;
  cycle^=1;
  if(cycle==0) {
    digitalWrite(PIN_INVP,HIGH); delayMicroseconds(1);
    digitalWrite(PIN_INVN,LOW); delayMicroseconds(1);
  }
  if(cycle==1) {
    digitalWrite(PIN_INVP,LOW); delayMicroseconds(1);
    digitalWrite(PIN_INVN,HIGH); delayMicroseconds(1);
  }
  interrupts();
}

// Nokia 5110 Funktionen (ASCII-Tabelle, LcdCharacter, LcdClear, LcdInitialise, LcdString, LcdWrite, LcdXY, LcdNumtoString)
// ... (Code gekürzt, vollständig im Original)

void LcdCharacter(char character) { ... }
void LcdClear(void) { ... }
void LcdInitialise(void) { ... }
void LcdString(char *characters) { ... }
void LcdWrite(byte dc, byte data) { ... }
void LcdXY(int x,int y) { ... }
void LcdNumtoString(float number) { ... }

// Hintergrund-Schleifen-Steuerung
void Load_Control(void) {
  if (Load_Auto_Enable == 1 && PV_Voltage < 4.5 && cdc_level > 0) digitalWrite(PIN_LOAD,HIGH);
  if (Load_Auto_Enable == 1 && (PV_Voltage > 10.5 || cdc_level==0)) digitalWrite(PIN_LOAD,LOW);
}

void Charging_Control(void) {
  // BattExt: 14.3V Laden aus, 13.5V oder darunter Laden an, 10.8V Last aus, 12.5V Last an
  // Verhindert Ladeversuche bei Nacht (PV=0V)
  if (PV_Voltage > 10.5 && BattExt_Voltage > 8.0) {
    if (BattExt_Voltage <= 12.5) { analogWrite(PIN_BATTPWM,255); cdc_level = 0; }
    else if (BattExt_Voltage <= 12.9) { analogWrite(PIN_BATTPWM,200); cdc_level = 1; }
    else if (BattExt_Voltage <= 13.3) { analogWrite(PIN_BATTPWM,160); cdc_level = 1; }
    else if (BattExt_Voltage <= 13.6) { analogWrite(PIN_BATTPWM,120); cdc_level = 2; }
    else if (BattExt_Voltage <= 13.9 && cdc_level == 2) { analogWrite(PIN_BATTPWM,80); cdc_level = 2; }
    else if (BattExt_Voltage <= 14.3 && cdc_level == 2) { analogWrite(PIN_BATTPWM,40); cdc_level = 2; }
    // Überlastsperre
    if (BattExt_Voltage > 14.3) { analogWrite(PIN_BATTPWM,0); cdc_level = 3; }
  } else { analogWrite(PIN_BATTPWM,0); cdc_level = 3; }
}

void Discharging_Control(void) {
  if (BattExt_Voltage <= 10.8) {
    cdc_level = 0;
    digitalWrite(PIN_LOAD,LOW);
    Timer1_DeInit();
  }
}

// Timer1 Funktionen (AVR-Style)
void Timer1_Init(void) {
  noInterrupts();
  pinMode(PIN_INVP,OUTPUT); pinMode(PIN_INVN,OUTPUT);
  TCCR1A = 0; TCCR1B = 0;
  // 50Hz AC = 20ms Welle = 2x 10ms Pulse
  // 100Hz Toggle -> 16MHz/8 = 2M Zyklen/s -> 20000 Zyklen pro 10ms
  // Timer1 16-bit: Start bei 65535-20000 = 45535
  TCNT1 = 45535;
  TCCR1B |= (1 << CS11); // Prescaler 8
  TIMSK |= (1 << TOIE1); // Overflow Interrupt aktivieren
  interrupts();
}

void Timer1_DeInit(void) {
  noInterrupts();
  TCCR1A = 0; TCCR1B = 0; TCNT1 = 0;
  digitalWrite(PIN_INVP,LOW); digitalWrite(PIN_INVN,LOW);
  interrupts();
}

Full Code (C/C++)

Code organisiert & lesbar – nur Download.

Bootloader (C/C++)

Nur Download.

Schaltpläne