SOLAR‎ > ‎

ARDUINO Solarladeregler

http://sites.prenninger.com/elektronik/solar/arduino-solarladeregler

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                          Wels, am 2017-02-08

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I**
DIN A4  ausdrucken   (Heftrand 15mm / 5mm)     siehe     http://sites.prenninger.com/drucker/sites-prenninger
********************************************************I*
~015_b_PrennIng-a_elektronik-solar-arduino.solarladeregler (xx Seiten)_1a.pdf



               ARDUINO Solarladeregler Version 2.0

               ARDUINO solar charge controller

                                    SOLAR CHARGE CONTROLLER


Schritt 1: Bauteile und Werkzeuge erforderlich:
Schritt 2: Der Laderegler Works:
Schritt 3: Hauptfunktionen der Solarladeregler:
Schritt 4: Sensing Spannungen, Strom und Temperatur:
Schritt 5: Sensoren Kalibriergeräte
Schritt 6: Ladealgorithmus
Schritt 7: Laststeuerung
Schritt 8: Leistung und Energie
Schritt 9: Schutz
Schritt 10: LED-Anzeige
Schritt 11: LCD-Anzeige
Schritt 12: Brot-Brett Testing
Schritt 13: Netzteil und Anschlussklemmen:
Schritt 14: Montieren Sie die Arduino:
Schritt 15: Löten Sie die Komponenten
Schritt 16: Schließen Sie das Stromsensor
Schritt 17: Stellen Sie die Anzeige und Temperatur-Sensorfeld
Schritt 18: Anschlüsse für Laderegler
Schritt 19: Abschlussprüfung:
Schritt 20: Montage der Hauptplatine:
Schritt 21: Machen Sie Platz für LCD:
Schritt 22: Bohrlöcher:
Schritt 23: Mount Alles:
Schritt 24: Schließen Sie das externe 6-Pin-Klemme:
Schritt 25: Schließen Sie das LCD, Anzeige-Panel und Reset-Taste:
Schritt 26: Ideen und Planung



CLICKOSLO

ARDUINO Solarladeregler (Version 2.0)






Vor einem Jahr begann ich bauen meine eigene Solaranlage, um Strom für mein Dorf bieten house.Initially

Ich habe einen LM317 basierend Laderegler und einen Stromzähler zur Überwachung der system.Finally ich PWM Ladung controller.

In April 2014 Ich habe meine PWM Solarladeregler-Designs auf der Bahn, wurde es sehr beliebt.

Viele Menschen auf der ganzen Welt haben ihre eigenen gebaut.

So viele Studenten haben es für ihre College-Projekt, indem sie Hilfe von me.

I ch habe einige Mails jeden Tag von Menschen mit Fragen in Bezug auf Hard- und Softwareanpassung für unterschiedliche Bemessungssolarpanel und Batterie hergestellt.

Ein sehr großer Teil der E-Mails werden in Bezug auf die Änderung der Laderegler für eine 12Volt Sonnensystem.

Sie können meine anderen Version Laderegler zu sehen

ARDUINO MPPT Solarladeregler (Version-3.0)
ARDUINO Solarladeregler (Version-1)

Um dieses Problem habe ich diese neue Version Laderegler zu lösen, so dass jeder kann es ohne Änderung der Hard- und Software zu verwenden.

Ich kombiniere sowohl die Energiezähler und Laderegler in diesem Entwurf.

Spezifikation der Version-2 Laderegler:
1.Charge Steuerung sowie Energiezähler
2. Automatische Battery Voltage Selection (6V / 12V)
3.PWM Ladealgorithmus mit automatischer Ladesollwert entsprechend der Batteriespannung
4.LED Anzeige für den Ladezustand und Ladezustand
5. 20x4 Zeichen LCD-Display zur Anzeige von Spannungen, Strom, Leistung, Energie und Temperatur.
6.Lightning Schutz
7.Reverse Stromfluss Schutz
8.Short Schluss und Überlastschutz
9. Temperaturkompensation für Lade

Elektrische Daten:
1.Rated Spannung = 6V / 12V
2.Maximale Strom = 10A
3.Maximum Laststrom = 10A
4.Öffnen Laufspannung = 8..11V für 6V System / 15V..25V für 12V System



26 Schritt

Schritt 1: Elektronik-Bauteile


Bauteile:
1.Arduino Nano ( eBay )
2.P-MOSFET ( IRF 9540 x2)
3.Power Diode ( MBR 2045 für 10A und IN5402 für 2A)
4.Buck Converter ( eBay ) oder Spannungsregler ( LM7805 )
5.Temperature Sensor ( LM35 )
6.Current Sensor ( ACS712 )
7.TVS Diode ( P6KE36CA )
8.Transistors ( 2N3904 oder 2N2222)
9.Resistors (100k x 2, x 20k 2,10k x 2,1k x 2, 330 Ohm x 5)
10.Ceramic Kondensatoren (0,1 uF x 2)
11.Electrolytic Kondensatoren (100uF und 10uF)
12. 20x4 I2C LCD ( eBay )
13.RGB LED ( ebay )
14.Bi Farbe LED-
15.Jumper Kabel / Leitungen ( eBay )
16.Header Pins ( männlich , weiblich und rechtwinklig )
17.Heat Sink ( eBay )
18.Fuse Halter und Sicherungen ( eBay )
19.Push Knopf
20.Perforated Board ( eBay )
21.Project Enclosure
22.Screw Klemmen (3x 2pin und 1x 6-polig )
23.Nuts / Schrauben / Bolzen
24.Plastic Basis

Werkzeuge:
1.Soldering Eisen
2.Wire Schneider und Stripper
3.Screw Treiber
4.Drill
5.Dremel
6.Glue Gun
7.Hobby Knife





Schritt 2: Der Laderegler Symbolschaltbild:



Das Herz des Ladereglers ist Arduino Nano Platine arduino MCU erfasst die Solarpanel und Batterie voltages.According, dies zu Spannungen entscheidet, wie es um die Batterie aufzuladen und die Kontrolle der Last.
Die Höhe der Ladestrom wird durch Differenz zwischen Batteriespannung und Ladesollspannungen bestimmt.
Die Steuerung verwendet zwei Stufen Lade algorithm.According zur Ladealgorithmus es gibt eine feste Frequenz PWM-Signal an den Sonnenkollektor seitlich p-MOSFET ist.
Die Frequenz des PWM-Signals ist 490.20Hz (Standardfrequenz für Pin-3).
Das Tastverhältnis 0-100% wird von der Fehlersignal eingestellt.
Der Controller gibt HIGH oder LOW-Befehl an die Lastseite p-MOSFET gemäß der Dämmerung / Dämmerung und Batteriespannung.
Der vollständige schematische angebracht bellow


Schritt 3: Hauptfunktionen der Solarladeregler:

Der Laderegler wird durch die Betreuung der folgenden Punkte konzipiert.
1.Prevent Überladung der Batterie:
Um die an die Batterie durch das Solarpanel zugeführte Energie zu begrenzen, wenn die Batterie () vollständig charged.This in charge_cycle umgesetzt meines Codes.
2.Prevent Battery Over Entladung:
Um die Batterie von elektrischen Lasten zu trennen, wenn die Batterie erreicht niedrigen Stand charge.This in load_control umgesetzt () von meinem Code.
3.Provide Load Control Funktionen:
Zum automatischen Verbinden und Trennen einer elektrischen Last zu einem bestimmten Zeitpunkt. Die Last auf, wenn Sonnenuntergang und AUS, wenn sunrise.This in load_control () meines Codes implementiert.
4.Monitoring Power and Energy:
Um die Belastung Kraft und Energie zu überwachen und anzeigen.
5.Protect von abnormalen Zustand:
Um die Schaltung aus verschiedenen anormalen Situation wie der Blitz zu schützen, Überspannung, Überstrom und Kurzschluss usw.
6.Indicating und zeigt an:
Um anzugeben, und die verschiedenen Parameter angezeigt
7.Serial Kommunikation:
Um verschiedene Parameter zu drucken in Serien monitor





Schritt 4: Sensing Spannungen, Strom und Temperatur:

1.Voltage Sensor:
Die Spannungssensoren verwendet werden, um die Spannung der Solarpanel zu erfassen und battery.It wird durch zwei Spannungsteiler circuits.It besteht aus zwei Widerständen R1 = R2 = 100k und 20k zum Erfassen der Sonnenkollektorspannung umgesetzt ans ähnlich R3 = 100k und R4 = 20k für Batteriespannung zu aus dem R1 und R2 stellen ist mit der Analog-Pin A0 arduino und aus dem R3 und R4 setzen ist mit dem Analog-Pin A1 arduino.

Spannungs-Sensoren für die Solar-Zelle und der Batterie




2.Current Sensor:
Der Stromsensor zur Messung der Belastung current.later dieser Strom wird verwendet, um die Last Leistung zu berechnen und energy.I verwendet ein Loch Effekt Stromsensor verwendet (ACS712-20A)
Strom-Sensor ACS712



3.Temperature Sensor:
Der Temperatursensor wird verwendet, um die Raumtemperatur zu messen.
Ich habe LM35 Temperatursensor, der für -55 °C bis + 150 °C Bereich bewertet wird.

Warum Temperaturüberwachung ist erforderlich?

Chemische Reaktionen der Batterie zu ändern mit temperature.As die Batterie wird wärmer, die Vergasung zu.

Da die Batterie kälter wird es beständiger gegenüber der Aufladung.

Je nachdem, wie weit die Batterie Temperatur ändert, ist es wichtig, den Lade einzustellen Temperatur changes.So es wichtig ist, den Ladevorgang zu passen für die Temperatureffekte zu berücksichtigen.

Der Temperaturfühler wird die Temperatur der Batterie zu messen, und die Solarladeregler verwendet diese Eingabe, um die Ladungssollwert anpassen required.

The Kompensationswert -. 5 mV / degC / Zelle für Blei-Säure-Batterien (- 30 mV / °C für 12V und 15mV / ºC für 6V Batterie) .

Die negatives Vorzeichen der Temperaturkompensation zeigt, Temperaturerhöhung erfordern eine Verringerung der Ladesollwert.

Für weitere Einzelheiten über Verstehen und Optimieren der Batterietemperaturkompensation
Temperatur Sensor LM35



Schritt 5: Sensoren Kalibriergeräte

Spannungssensoren:
5V = ADC Zahl 1024
1 ADC count = (5/1024) Volt = 0.0048828Volt
Vout = Vin * R2 / (R1 + R2)
Vin = Vout * (R1 + R2) / R2 = R1 100 und R2 = 20
Vin = ADC Zahl * 0,00488 * (120/20) Volt
Aktuelle Sensor:
Wie pro Verkäufer Informationen für ACS 712 Stromsensor
Empfindlichkeit = 100 mV / A = 0.100V / A
Kein Teststrom durch die Ausgangsspannung VCC / 2 = 2,5
ADC count = 1024/5 * Vin und Vin = 2,5 + 0,100 * I (wobei I = Strom)
ADC count = 204,8 (2,5 + 0,1 * I) = 512 + 20.48 * I
=> 20,48 * I = (ADC zählen-512)
=> I = (ADC Zahl / 20.48) - 512 / 20.48
Strom (I) = 0,04882 * ADC -25
Weitere Details zu ACS712
Temperatursensor :
Nach Datenblatt des LM35
Empfindlichkeit = 10 mV / ° C
Temp in ° C = (5/1024) * ADC Zahl * 100
Anmerkung: Die Sensoren werden durch die Annahme, die arduino Vcc = 5V reference.But praktisch kalibriert es nicht 5V always.
So es kann Chancen auf einen falschen Wert aus der tatsächlichen value.It kann auf folgende Weise gelöst werden können.
Die Spannung zwischen Arduino 5V und GND von einem multimeter.Use diese Spannung anstelle von 5V für Vcc in Ihrem code.Hit und versuchen, diesen Wert zu bearbeiten, bis er den aktuellen Wert übereinstimmt.
Beispiel: Ich habe 4.47V anstatt 5V.So die Änderung sollte 4.47 / 1024 = 0,0043652 statt 0.0048828




Schritt 6: Ladealgorithmus


                     3 stages of charging




14,4V nur 2 Stunden
13,8V Normalladen


1. Masse: Bei diesem Modus wird eine vorgegebene maximale Konstantstrommenge (Ampere) in die Batterie eingespeist, da kein PWM vorliegt.
Da der Akku wird aufgeladen, erhöht sich die Spannung der Batterie nach und nach
2. Resorption: Wenn der Akku die Hauptladung eingestellte Spannung erreicht, beginnt die PWM die Spannung konstant zu halten.
Dies dient dazu, Übertemperaturen und Über Ausgasen der Batterie zu vermeiden.
Der Strom wird auf ein sicheres Niveau verjüngen sich wie die Batterie mehr vollständig aufgeladen.
3. Schwimmer: Wenn der Akku vollständig geladen ist, die Ladespannung verringert wird, um eine weitere Erwärmung oder Vergasung der Batterie zu verhindern
Dies ist die ideale Ladeprozedur.
Die vorliegende Ladezyklus Codeblock ist nicht implementiert 3 Stufen charging.I ein einfacher Logik in 2 stages.It funktioniert gut verwenden.
Ich versuche, die folgende Logik für die Umsetzung der 3 Phasen des Ladevorgangs.
Zukunftsplanung für Ladezyklus:
Die Hauptladung beginnt, wenn Solarpanel Spannung größer ist als die Batteriespannung.
Wenn die Batteriespannung 14,4 V erreicht, werden Absorptionsladung eingegeben werden.
Der Ladestrom wird durch eine PWM-Signal reguliert werden kann, um die Batteriespannung auf 14,4 V für eine Stunde zu halten.
Erhaltungsladung wird dann nach einer Stunde ein.
Der Schwimmer Stufe erzeugt eine Erhaltungsladung, die Batteriespannung an 13.6V halten.
Wenn die Batteriespannung unter 13,6 V für 10 Minuten, wird der Ladezyklus wiederholt werden.
Ich bitte Community-Mitglieder, mich zum Schreiben der Teil des Codes, um die oben logic umsetzen helfen:




Schritt 7: Laststeuerung

Um automatisch verbinden und trennen die Last durch die Überwachung der Dämmerung / Dämmerung und Batteriespannung, ist Laststeuerung verwendet.
Der primäre Zweck der Laststeuerung ist, um die Last von der Batterie trennen, um sie von Tiefentladung zu schützen.
Tiefentladung kann den Akku beschädigen.
Die DC-Lastanschluss ist für Low-Power-DC-Last, wie beispielsweise Straßenleuchte konzipiert.
Die PV-Panel selbst als Lichtsensor verwendet.
Unter der Annahme, Solar-Panel-Spannung> 5V bedeutet Dämmerung und bei <5 V Dämmerung.

Unter der Bedingung:

Am Abend, wenn die PV-Spannungspegel fällt unten 5V und Batteriespannung höher als LVD-Einstellung, wird der Controller von der Last und der Last grüne LED leuchtet, drehen.

AUS-Zustand:

Die Last wird in den folgenden zwei Bedingungen abgeschnitten.
1.In am Morgen, wenn die PV-Spannung ist größer als 5V,
2. Wenn die Batteriespannung niedriger als die LVD-Einstellung ist
Die Last rote LED zeigt an, dass Last abgeschaltet.
LVD wird, bezieht sich auf Low Voltage Disconnect







Schritt 8: Leistung und Energie

Leistung:
Power ist Produkt von Spannung (Volt) und Strom (Amp)
P = VxI
Einheit der Leistung ist Watt oder KW
Energie:
Energie Produkt von Leistung (Watt) und Zeit (Stunde)
E = Pxt
Energieeinheit ist Watt Hour oder Kilowattstunde (kWh)
Um die Last Kraft und Energie über Logik überwachen in Software implementiert ist und die Parameter werden in einer 20x4 char LCD angezeigt



Schritt 9: Schutz
VIDEO fehlt
1.Reverse Polaritätsschutz für Solar-Panel
2. Überladeschutz
3. Tiefentladeschutz
4. Kurzschluss- und Überlastschutz
5.Reverse Stromschutz bei Nacht
6.Over Spannungsschutz am Eingang Solarpanel
Für Verpolung und Rückwärtsstromfluss Schutz Ich habe eine Leistungsdiode (MBR2045) .
Power Diode wird verwendet, um große Menge an current.In meinen früheren Design Ich habe eine normale Diode (1N4007) zu behandeln.

Überladung und Tiefentladung Schutz wird durch die Software implementiert.

Überstrom und Überlastschutz wird durch zwei Sicherungen (eine am Solarpaneel Seite und andere auf der Lastseite) implementiert.

Temporäre Überspannungen auftreten, in Stromversorgungssystemen für eine Vielzahl von Gründen, aber blitz bewirkt, dass die schwersten Überspannungen.

Dies gilt vor allem mit PV-Anlagen aufgrund der exponierten Lagen und Systemverbindungs ​​cables.

In dieses neue Design Ich habe eine 600 Watt bidirektionale TVS-Diode (P6KE36CA), um den Blitzschlag und Überspannung am PV terminals.In drücken meinen früheren Entwurf, den ich verwendet, a zener-diode.

Du kann auch eine ähnliche Supressordiode verwenden auf der Lastseite.

Für Auswahlhilfe der TVS-Diode klicken Sie hier

Für die Wahl eines richtigen Teil nicht für TVS-Diode, klicken Sie hier




Schritt 10: LED-Anzeige



Batterieladezustand (SOC) LED:
Ein wichtiger Parameter, der den Energieinhalt der Batterie definiert ist der Ladezustand (SOC).
Dieser Parameter zeigt an, wie viel Ladung in der Batterie vorhanden
Ein RGB-LED wird verwendet, um den Ladezustand der charge.
For Verbindung anzuzeigen beziehen sich die oben schema

Battery LED ------------> Batteriestatus
RED --------------------> Spannung niedrig
GREEN --------------------> Spannung ist gesund
BLUE --------------------> Fully Charged

Last LED:
Ein bi-Farbe (rot / grün) LED für Ladestatus indication.Refer die obige Schema für Verbindung verwendet.
Last LED ---------------------> Ladestatus
GREEN -------------------------> Verbunden (ON)
RED ---------------------------> Getrenntes (OFF)
I sind eine dritte LED zur Anzeige des Solar-Panel-status


Schritt 11: LCD-Anzeige



Um die Spannung, Strom, Leistung, Energie und Temperatur angezeigt werden ein 20x4 I2C LCD ist used.
Wenn Sie nicht wollen, um den Parameter anzuzeigen, dann deaktivieren Sie die lcd_display () aus der Leere Schleife () function.
Danach  deaktivieren Sie Anzeige führte zu überwachen die Batterie und Ladezustand.
Sie können diese instructable für I2C LCD beziehen
Laden Sie die Liquid _I2C Bibliothek von hier
Hinweis:
Im Code müssen Sie die I2C-Modul Adresse ein.Sie können die Adresse im Code-Scanner link gegeben verwenden ändern:



Schritt 12: Bread-Board Testschaltung


Es ist immer eine gute Idee, Ihren Kreislauf auf ein Steckbrett zu testen, bevor sie zusammen Löten.
Nach dem Anschluss alles laden Sie die Code zu Code unten angebracht.
Die gesamte Software ist in kleine Funktionsblock für flexibility.Suppose Benutzer gebrochen ist nicht daran interessiert, eine LCD-Anzeige und glücklich mit der LED-Anzeige.
Dann aus der Leere Schleife (). Das ist alles, verwenden Sie einfach die lcd_display deaktivieren ().
In ähnlicher Weise entsprechend der Benutzeranforderung kann er zu ermöglichen und die verschiedenen Funktionen zu deaktivieren.
Laden Sie den Code von meinem GitHub Konto ARDUINO-SOLAR-CHARGE-CONTROLLER-V-2


Schritt 13: Netzteil und Anschlussklemmen:

Klemmen
LOAD
BATTERY

SOLAR






IN                                                                                 OUT
                                 buck converter
Anschlüsse:
In 3 Schraubklemmen für Solareingang, Batterie und Ladeanschluß connections.
Then löten it.I verwendet den mittleren Schraubklemme für Batterieanschluss, links, um es für Solar-Panel und das richtige ist für die Last.

Energieversorgung:
In meinem vorherigen Version die Stromversorgung für Arduino wurde von einer 9V battery.In diese Version die Leistung von der Ladebatterie itself.
Die Batteriespannung Schritt nach unten auf 5 V von einem Spannungsregler (LM7805) aufgenommen ist.
Solder LM7805 Spannungsregler in der Nähe, um die Batterie terminal.Then löten die Elektrolyt-Kondensatoren nach schematic.
At dieser Phase schließen Sie den Akku an der Klemme und überprüfen Sie die Spannung zwischen pin-2 und pin-3 der LM7805.It sollte in der Nähe von 5V sein.
Als ich eine 6V Batterie der LM7805 arbeitet perfectly.But für 12V Batterie ist aufgeheizt nach einiger time.So Ich bitte um eine Wärmesenke für es zu benutzen.

Effiziente Stromversorgung:
Nach einigen Tests habe ich festgestellt, dass der Spannungsregler LM7805 ist nicht der beste Weg, um die Arduino Macht als sie zu verschwenden viel Power in Form heat.
So beschließe ich, es durch eine DC DC-Abwärtswandler ändern, welche hoch ist efficient.If
Sie planen, um diese Steuerung zu machen, ich beraten, um eine Abwärtswandler anstatt LM7805 Spannungsregler zu verwenden.

Buck Converter Anschluss:

IN + -------> BAT +
IN- --------> BAT-
OUT + -----> 5V
OUT- -----> GND
Siehe die oben genannten Abbildungen. Sie können es von zu kaufen eBay





Schritt 14: Montieren Sie die Arduino:













Schneiden Sie 2 Buchsenleiste Streifen 15 Pins each.Place die nano Board für reference.Insert die beiden Überschriften nach dem nano pin.Check es, ob der nano Board ist perfekt, um in it.Then passen löten Rückseite.
Legen Sie zwei Reihen von Stiftleiste auf beiden Seiten des nano borad für externe connections.
Then kommen Sie mit den Lötstellen zwischen Arduino Pin und Kopf pins.See das obige Bild.
Anfangs habe ich vergessen zu Vcc und GND headers.
At dieses Stadium können Sie Überschriften mit 4-pins bis 5-pins für Vcc und GND legen hinzufügen.
Wie Sie sehen können Ich habe den Spannungsregler 5V und GND in den Nano 5V und GND von roten und schwarzen Leiter.
Später ich es entfernt und auf der Rückseite für eine bessere Optik des board.

Schritt 15: Löten Sie die Komponenten





Vor dem Löten der Bauteile machen Löcher in den Ecken zur Befestigung.
Löten Sie alle Komponenten gemäß Schaltplan.
Bewerben Kühlkörper zu zwei MOSFETs sowie Leistungsdiode.
Hinweis:
Die Leistungsdiode MBR2045 zwei Anode und eine cathode.So kurz die beiden Anoden.
Früher habe ich dicker Draht für Stromleitungen und Boden und dünne Drähte für signal.signal.
Dicken Draht ist obligatorisch wie der Regler für höhere current.ausgelegt:


Schritt 16: Schließen Sie das Stromsensor







Nach Anschluss aller Komponenten löten zwei dicken Draht zu Drain des Last-MOSFETs und oberen Anschluß des Lastseite Sicherungshalter.
Dann verbinden diese Leitungen an der Schraubklemme in Stromsensor (ACS 712) .



Schritt 17: Stellen Sie die Anzeige und Temperatur-Sensorfeld













Ich habe zwei meiner schematic.
But führte gezeigt Ich habe eine dritte LEDrt/gn (bi Farbe) zum Anzeigen des Solar-Panel-Status in Zukunft.
Bereiten Sie kleine Größe perforiert Bord shown.Then machen zwei Löcher (3,5 mm) von Bohrer auf links und rechts (für die Montage).
Legen Sie die LEDs und löten sie an der Rückseite der Platine.
Legen Sie eine 3-polig Buchsenleiste für Temperaturfühler und dann löten.
Löten Sie 10 Stifte rechtwinklig Header für externe Verbindung.
Verbinden Sie nun die RGB führte Anodenanschluss mit dem Temperatursensor Vcc (Pin-1).
Löten Sie die Kathodenanschlüsse von zwei bi Farbe führte.
Dann kommen Sie mit den Lötstellen der LEDs Anschluss mit dem headers.
You können einen Aufkleber mit Pin Name für die einfache Kennungen einfügen.



Schritt 18: Anschlüsse für Laderegler



VIDEO fehlt

Schließen Sie den Laderegler an die Batterie zuerst, weil dadurch der Laderegler, um, ob es 6V oder 12V System kalibriert zu werden.
Schließen Sie den Minuspol und dann positiv. Verbinden Sie das Solarpanel (negativ und dann positiv) Endlich verbinden die Last.
Der Laderegler Ladeanschluß ist nur zur DC-Last.
Wie man eine Wechselstromlast laufen?
Wenn Sie den Netzgeräten ausgeführt werden soll, dann müssen Sie benötigen einen Wechselrichter.
Schließen Sie den Wechselrichter direkt an die battery.See die oben picture.





Schritt 19: Abschlussprüfung:
                             buck-boost-converter



Nachdem Sie die Hauptplatine und Anzeigeplatine verbinden Sie den Header mit Drahtbrücken (Buchse-Buchse)
Siehe den Schaltplan in diesem connection.Wrong Verbindung kann die circuits.
So Pflege voll in diesem Stadium zu beschädigen.
Schließen Sie das USB-Kabel mit dem Arduino und laden Sie das code.Remove die usb cable.If Sie die serielle Monitor sehen, dann halten Sie es wollen, dann verbunden.
Sicherung: Im Demo habe ich eine 5A Sicherung im Sicherungs holder.But in die Praxis umgesetzt, legte eine Sicherung mit 120 bis 125% der Kurzschlussstrom.
Beispiel: Ein 100 W Solar-Panel mit Isc = 6.32A muss eine Sicherung 6.32x1.25 = 7,9 oder 8A
So testen?
Ich habe einen Dollar-Boost-Wandler und schwarzem Tuch, um die controller.
The Wandler Eingangsanschlüsse mit Batterie verbunden und der Ausgang mit dem Laderegler Batterieklemme zu testen.
Batterie-Status:
Drehen Sie den Konverter Potentiometer mit einem Schraubendreher an verschiedene Batterie simulieren voltages.
As die Batteriespannungen ändern die entsprechende LED schaltet sich aus und einschalten.
Hinweis: Bei diesem Vorgang sollte Sonnenkollektor getrennt oder mit einem schwarzen Tuch oder Pappe abgedeckt werden.
Morgen- / Abenddämmerung: Zur Simulation der Dämmerung mit einem schwarzen Tuch.
Nacht: Decken Sie das Solarpanel ganz.
Tag: Nehmen Sie den Stoff aus dem Solarpanel.
Transition: verlangsamen das entfernen oder abdecken das Tuch, verschiedene Sonnenkollektorspannungen einzustellen.
Load Control: Nach der Batteriezustand und Morgen- / Abenddämmerung Situation wird die Last ein- und auszuschalten.
Temperatur-Kompensation:
Halten Sie den Temperatursensor, um die Temperatur zu erhöhen und stellen Sie keine kalte Dinge wie Eis, um die temp.It verringern wird sofort auf dem LCD angezeigt werden.
Das kompensierte Ladesollwert kann über die serielle Monitor zu sehen.
Montage der Hauptplatine: Im nächsten Schritt vorwärts werde ich die Herstellung von Gehäuse für diese Ladung controller.

Schritt 20: Montage der Hauptplatine:



Legen Sie die Hauptplatine im Inneren des enclosure.Mark die Lochposition durch einen Bleistift.
Dann bewerben Sie Heißkleber auf die Kennzeichnungsposition.
Setzen Sie die Kunststoffbasis auf den Leim.
Dann legen Sie die Platine über der Basis und schrauben die nuts.

Schritt 21: Machen Sie Platz für LCD:







Schritt 22: Bohrlöcher:

3 LEDs    O Battery   O Load     O Solar    O LM35


Schritt 23: Mount Alles:



Schritt 24: Schließen Sie das externe 6-Pin-Klemme:



Schritt 25: Schließen Sie das LCD, Anzeige-Panel und Reset-Taste:








Schließen Sie das Anzeigefeld und LCD auf der Hauptplatine nach schema. (Verwenden Buchse-Buchse Schaltdrähte)
Einem Anschluß der Rücksetztaste geht RST Arduino und andere geht auf GND.
Schließlich connections.Close die vordere Abdeckung und schrauben it.



Schritt 26: Ideen und Planung






Wie man in Echtzeit Graphen zeichnen?

Es ist sehr interessant, wenn man die Serienmonitorparameter (wie Batterie und Solarspannungen) in einer Grafik auf Ihrem Laptop screen.It plotten kann sehr einfach durchgeführt werden, wenn man weiß wenig über die Verarbeitung.

Um zu wissen, mehr können Sie beziehen Arduino und Processing (Graph Beispiel).

Wie, um die Daten zu retten?

Dies kann leicht durch Verwendung von SD-Karte durchgeführt werden, aber diese sind mehr Komplexität und cost.
To dieses Problem lösen suchte ich über das Internet und fand eine einfache solution.You können Daten in Excel-Tabellen zu speichern.
Für Einzelheiten beziehen Sie können sehen-Sensoren-how-to-Visualisierung-and-save-Arduino-spürte-Daten
Die obigen Bilder aus web.I heruntergeladen angebracht, um zu verstehen, was ich tun möchte, und was Sie tun können.

Zukunftsplanung:
1. Ferndatenerfassung über Ethernet oder WiFi.
2. Stärkere Ladealgorithmus und Laststeuerung
3. Adding ein USB-Ladestation für Smartphones / Tablets
Hoffe, Sie genießen meine instructables.
Bitte machen Sie jeder improvements.Raise ein Eventuelle Anmerkungen Fehler oder Irrtümer.
Folgen Sie mir für weitere Updates und neue spannende Projekte.




Quelle:
http://www.clickoslo.com/arduino-solarladeregler-version-2-0.html
http://www.genstr.com/arduino-solar-laderegler-version-2-0.html
http://www.instructables.com/id/ARDUINO-SOLAR-CHARGE-CONTROLLER-Version-20/
http://www.gunook.com/arduino-solar-charge-controller-version-2-0/






Arduino based PWM Solar Charge Controller
Charge controller as well energy meter 
10 Apr 2015

deba168

ARDUINO-SOLAR-CHARGE-CONTROLLER-V-2





+// ARDUINO SOLAR CHARGE CONTROLLER
+//Version-2.0
+//by deba168,INDIA
+//Dated : 22/10/2014
+
+
+#include <Wire.h>
+#include <LiquidCrystal_I2C.h>

+#define SOL_ADC A0 // Solar panel side voltage divider is connected to pin A0
+#define BAT_ADC A1 // Battery side voltage divider is connected to pin A1
+#define CURRENT_ADC A2 // ACS 712 current sensor is connected to pin A2
+#define TEMP_ADC A3 // LM 35 Temperature is connected to pin A3
+#define AVG_NUM 10 // number of iterations of the adc routine to average the adc readings
+#define BAT_MIN 10.5 // minimum battery voltage for 12V system
+#define BAT_MAX 15.0 // maximum battery voltage for 12V system
+#define BULK_CH_SP 14.4 // bulk charge set point for sealed lead acid battery // flooded type set it to 14.6V
+#define FLOAT_CH_SP 13.6 //float charge set point for lead acid battery
+#define LVD 11.5 //Low voltage disconnect setting for a 12V system
+#define PWM_PIN 3 // pin-3 is used to control the charging MOSFET //the default frequency is 490.20Hz
+#define LOAD_PIN 2 // pin-2 is used to control the load
+#define BAT_RED_LED 5
+#define BAT_GREEN_LED 6
+#define BAT_BLUE_LED 7
+#define LOAD_RED_LED 8
+#define LOAD_GREEN_LED 9
+//--------------------------------------------------------------------------------------------------------------------------
+///////////////////////DECLARATION OF ALL BIT MAP ARRAY FOR FONTS////////////////////////////////////////////////////////////////
+//--------------------------------------------------------------------------------------------------------------------------
+
+byte solar[8] = //icon for solar panel
+{
+ 0b11111,0b10101,0b11111,0b10101,0b11111,0b10101,0b11111,0b00000
+};
+byte battery[8] = //icon for battery
+{
+ 0b01110,0b11011,0b10001,0b10001,0b10001,0b10001,0b10001,0b11111
+};
+
+byte energy[8] = // icon for power
+{
+ 0b00010,0b00100,0b01000,0b11111,0b00010,0b00100,0b01000,0b00000
+};
+/*byte alarm[8] = // icon for alarm
+{
+ 0b00000,0b00100,0b01110,0b01110,0b01110,0b11111,0b00000,0b00100
+};*/
+byte temp[8] = //icon for termometer
+{
+ 0b00100,0b01010,0b01010,0b01110,0b01110,0b11111,0b11111,0b01110
+};
+
+byte charge[8] = // icon for battery charge
+{
+ 0b01010,0b11111,0b10001,0b10001,0b10001,0b01110,0b00100,0b00100,
+};
+byte not_charge[8]=
+{
+ 0b00000,0b10001,0b01010,0b00100,0b01010,0b10001,0b00000,0b00000,
+};
+
+
+//--------------------------------------------------------------------------------------------------------------------------
+///////////////////////DECLARATION OF ALL GLOBAL VARIABLES//////////////////////////////////////////////////////////////////
+//--------------------------------------------------------------------------------------------------------------------------
+float solar_volt=0;
+float bat_volt=0;
+float load_current=0;
+int temperature=0;
+int temp_change=0;
+float system_volt=0;
+float bulk_charge_sp=0;
+float float_charge_sp=0;
+float charge_status=0;
+float load_status=0;
+float error=0;
+float Ep=0;
+int duty =0;
+float lvd;
+float msec=0;
+float last_msec=0;
+float elasped_msec=0;
+float elasped_time=0;
+float ampSecs = 0;
+float ampHours=0;
+float watts=0;
+float wattSecs = 0;
+float wattHours=0;
+
+// Set the pins on the I2C chip used for LCD connections:
+// addr, en,rw,rs,d4,d5,d6,d7,bl,blpol
+LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Set the LCD I2C address // In my case 0x27

+//******************************************************* MAIN PROGRAM START ************************************************

+void setup()
+{
+
+Serial.begin(9600);
+pinMode(BAT_RED_LED,OUTPUT);
+pinMode(BAT_GREEN_LED,OUTPUT);
+pinMode(BAT_BLUE_LED,OUTPUT);
+pinMode(LOAD_RED_LED ,OUTPUT);
+pinMode(LOAD_GREEN_LED,OUTPUT);
+pinMode(PWM_PIN,OUTPUT);
+pinMode(LOAD_PIN,OUTPUT);
+digitalWrite(PWM_PIN,LOW); // default value of pwm duty cycle
+digitalWrite(LOAD_PIN,LOW); // default load state is OFF
+lcd.begin(20,4); // initialize the lcd for 16 chars 2 lines, turn on backlight
+lcd.backlight(); // finish with backlight on
+lcd.createChar(1,solar);
+lcd.createChar(2, battery);
+lcd.createChar(3, energy);
+//lcd.createChar(4,alarm);
+lcd.createChar(5,temp);
+lcd.createChar(6,charge);
+lcd.createChar(7,not_charge);
+lcd.clear();
+}
+


+void loop()
+{
+ read_data(); // read different sensors data from analog pin of arduino
+ system_voltage(); // detect the system voltage according to battery voltage
+ setpoint(); // decide the charge set point according to system voltage
+ charge_cycle(); // pwm charging of battery
+ power(); // calculate the load power and energy
+ load_control(); //control the load
+ led_indication(); // led indica
+ print_data(); // print in serial monitor
+ lcd_display(); // lcd display
+ }


+//************************************************************ PROGRAM END *************************************************
+
+
+//------------------------------------------------------------------------------------------------------

+////////////////// READS AND AVERAGES THE ANALOG INPUTS (SOLRAR VOLTAGE,BATTERY VOLTAGE)////////////////

+//------------------------------------------------------------------------------------------------------
+int read_adc(int adc_parameter)
+{
+
+ int sum = 0;
+ int sample ;
+ for (int i=0; i<AVG_NUM; i++)
+ { // loop through reading raw adc values AVG_NUM number of times
+ sample = analogRead(adc_parameter); // read the input pin
+ sum += sample; // store sum for averaging
+ delayMicroseconds(50); // pauses for 50 microseconds
+ }
+ return(sum / AVG_NUM); // divide sum by AVG_NUM to get average and return it
+}
+//-------------------------------------------------------------------------------------------------------------

+////////////////////////////////////READ THE DATA//////////////////////////////////////////////////////////////

+//-------------------------------------------------------------------------------------------------------------

+ void read_data(void)
+ {
+ //5V = ADC value 1024 => 1 ADC value = (5/1024)Volt= 0.0048828Volt
+ // Vout=Vin*R2/(R1+R2) => Vin = Vout*(R1+R2)/R2 R1=100 and R2=20
+ solar_volt = read_adc(SOL_ADC)*0.00488*(120/20);
+ bat_volt = read_adc(BAT_ADC)*0.00488*(120/20);
+ load_current = (read_adc(CURRENT_ADC)*.0488 -25);
+ temperature = read_adc(TEMP_ADC)*0.00488*100;
+
+ }
+ //------------------------------------------------------------------------------------------------------------

+/////////////////////////////////POWER AND ENERGY CALCULATION //////////////////////////////////////////////

+//------------------------------------------------------------------------------------------------------------

+void power(void)
+
+{
+msec = millis();
+elasped_msec = msec - last_msec; //Calculate how long has past since last call of this function
+elasped_time = elasped_msec / 1000.0; // 1sec=1000 msec
+watts = load_current * bat_volt; //Watts now
+ampSecs = (load_current*elasped_time); //AmpSecs since last measurement
+wattSecs = ampSecs * bat_volt; //WattSecs since last measurement
+ampHours = ampHours + ampSecs/3600; // 1 hour=3600sec //Total ampHours since program started
+wattHours = wattHours + wattSecs/3600; // 1 hour=3600sec //Total wattHours since program started
+last_msec = msec; //Store 'now' for next time
+}
+
+//------------------------------------------------------------------------------------------------------------

+/////////////////////////////////PRINT DATA IN SERIAL MONITOR/////////////////////////////////////////////////

+//------------------------------------------------------------------------------------------------------------

+ void print_data(void)
+ {
+ delay(100);
+ Serial.print("Solar Panel Voltage: ");
+ Serial.print(solar_volt);
+ Serial.println("V");
+ Serial.print("Battery Voltage: ");
+ Serial.print(bat_volt);
+ Serial.println("V");
+ Serial.print("Syestem Voltage: ");
+ Serial.print(system_volt);
+ Serial.println("V");
+ Serial.print("Charge Set Point:");
+ Serial.println(bulk_charge_sp);
+ Serial.print("Temperature:");
+ Serial.print(temperature);
+ Serial.println("C");
+ Serial.print("Load Current: ");
+ Serial.print(load_current);
+ Serial.println("A");
+ Serial.print("Power: ");
+ Serial.print(watts);
+ Serial.println("W");
+ Serial.print("Energy: ");
+ Serial.print(wattHours);
+ Serial.println("WH");
+ Serial.print("Duty Cycle :");
+ if (charge_status==1)
+ {
+ Serial.println("99%");
+ Serial.println("BULK CHARGING");
+ }
+ else if (charge_status==2)
+ {
+ Serial.print(Ep);
+ Serial.println("%");
+ Serial.println("FLOAT CHARGING");
+ }
+ else
+ {
+ Serial.println("0%");
+ Serial.println("NOT CHARGING");
+ }
+ if(load_status==1)
+ {
+ Serial.println("LOAD IS CONNECTED");
+ }
+ else
+ {
+ Serial.println("LOAD IS DISCONNECTED");
+ }
+
+ Serial.println("***************************");
+ }
+//----------------------------------------------------------------------------------------------------------------------

+//////////////////////////////////SYSTEM VOLTAGE AUTO DETECT ///////////////////////////////////////////////////////////

+//----------------------------------------------------------------------------------------------------------------------

+void system_voltage(void)
+{
+ if ((bat_volt >BAT_MIN) && (bat_volt < BAT_MAX))
+ {
+ system_volt = 12;
+ }
+ /*
+ else if ((bat_volt > BAT_MIN*2 ) && (bat_volt < BAT_MAX*2))
+ {
+ system_volt=24;
+ }*/
+ else if ((bat_volt > BAT_MIN/2 ) && (bat_volt < BAT_MAX/2))
+ {
+ system_volt=6;
+ }
+
+}
+//---------------------------------------------------------------------------------------------------------------------------
+ ////////////////////////////////////CHARGE SET POINT ///////////////////////////////////////////////////////////////////////
+//---------------------------------------------------------------------------------------------------------------------------
+
+void setpoint(void)
+{
+ temp_change =temperature-25.0; // 25deg cel is taken as standard room temperature
+ // temperature compensation = -5mv/degC/Cell
+ // If temperature is above the room temp ;Charge set point should reduced
+ // If temperature is bellow the room temp ;Charge set point should increased
+ if(system_volt ==12)
+ {
+ bulk_charge_sp = BULK_CH_SP-(0.030*temp_change) ;
+ float_charge_sp=FLOAT_CH_SP-(0.030*temp_change) ;
+ lvd =LVD;
+ }
+
+ else if(system_volt ==6)
+ {
+ bulk_charge_sp = (BULK_CH_SP/2)-(0.015*temp_change) ;
+ float_charge_sp= (FLOAT_CH_SP/2)-(0.015*temp_change) ;
+ lvd=LVD/2;
+ }
+ /*
+ else if (system_volt == 24)
+ {
+ bulk_charge_sp = (BULK_CH_SP*2)-(0.060*temp_change) ;
+ float_charge_sp= (FLOAT_CH_SP*2)-(0.060*temp_change) ;
+ lvd=LVD*2;
+ }
+ */
+
+}
+//--------------------------------------------------------------------------------------------------------------------------------
+ ///////////////////////////////////////////////////PWM CHARGE CYCLE @500 HZ //////////////////////////////////////////////////
+ //-------------------------------------------------------------------------------------------------------------------------------
+void charge_cycle(void)
+{
+ if (solar_volt > bat_volt && bat_volt <= bulk_charge_sp)
+ {
+
+
+ if (bat_volt <= float_charge_sp) // charging start
+ {
+ charge_status = 1; // indicate the charger is in BULK mode
+ duty= 252.45;
+ analogWrite(PWM_PIN,duty); // 99 % duty cycle // rapid charging
+
+
+ }
+ else if (bat_volt >float_charge_sp && bat_volt <= bulk_charge_sp)
+ {
+ charge_status = 2; // indicate the charger is in FLOAT mode
+ error = (bulk_charge_sp - bat_volt); // duty cycle reduced when the battery voltage approaches the charge set point
+ Ep= error *100 ; //Ep= error* Kp // Assume Kp=100
+
+ if(Ep < 0)
+ {
+ Ep=0;
+ }
+ else if(Ep>100)
+ {
+ Ep=100;
+ }
+ else if(Ep>0 && Ep <=100) // regulating
+ {
+ duty = (Ep*255)/100;
+ }
+ analogWrite(PWM_PIN,duty);
+ }
+ }
+ else
+ {
+ charge_status=0; // indicate the charger is OFF
+ duty=0;
+ analogWrite(PWM_PIN,duty);
+ }
+}
+//----------------------------------------------------------------------------------------------------------------------

+/////////////////////////////////////////////LOAD CONTROL/////////////////////////////////////////////////////

+//----------------------------------------------------------------------------------------------------------------------
+
+void load_control()
+{
+ if (solar_volt < 5 ) // load will on when night
+{
+ if(bat_volt >lvd) // check if battery is healthy
+ {
+ load_status=1;
+ digitalWrite(LOAD_PIN, HIGH); // load is ON
+ }
+ else if(bat_volt < lvd)
+ {
+ load_status=0;
+ digitalWrite(LOAD_PIN, LOW); //load is OFF
+ }
+ }
+ else // load will off during day
+ {
+ load_status=0;
+ digitalWrite(LOAD_PIN, LOW);
+ }
+}
+
+
+//-------------------------------------------------------------------------------------------------

+//////////////////////////LED INDICATION////////////////////////////////////

+//-------------------------------------------------------------------------------------------------
+void led_indication(void)
+{
+ battery_led(); //Battery status led indication
+ load_led(); //Load led indication
+}
+
+//----------------------------------------------------------------------------------------------------------------------

+/////////////////////////////////////////////BATTERY LED INDICATION/////////////////////////////////////////////////////

+//----------------------------------------------------------------------------------------------------------------------
+void battery_led(void)
+{
+
+ if( (bat_volt > system_volt) && ( bat_volt <bulk_charge_sp))
+ {
+ leds_off_all();
+ digitalWrite(BAT_GREEN_LED,LOW); // battery voltage is healthy
+ }
+ else if(bat_volt >= bulk_charge_sp)
+ {
+ leds_off_all();
+ digitalWrite(BAT_BLUE_LED,LOW); //battery is fully charged
+ }
+ else if(bat_volt < system_volt)
+ {
+ leds_off_all();
+ digitalWrite(BAT_RED_LED,LOW); // battery voltage low
+ }
+}
+//----------------------------------------------------------------------------------------------------------------------

+/////////////////////////////////////////////LOAD LED INDICATION/////////////////////////////////////////////////////

+//----------------------------------------------------------------------------------------------------------------------
+
+ void load_led()
+ {
+ if(load_status==1)
+ {
+ digitalWrite(LOAD_GREEN_LED,HIGH);
+ }
+ else if(load_status==0)
+ {
+ digitalWrite(LOAD_RED_LED,HIGH);
+ }
+ }
+
+//------------------------------------------------------------------------------------------------------

+//////////////////////// TURN OFF ALL THE LED///////////////////////////////////////////////////////////

+//------------------------------------------------------------------------------------------------------
+void leds_off_all(void)
+{
+
+ digitalWrite(BAT_RED_LED,HIGH);
+ digitalWrite(BAT_GREEN_LED,HIGH);
+ digitalWrite(BAT_BLUE_LED,HIGH);
+ digitalWrite(LOAD_RED_LED, LOW);
+ digitalWrite(LOAD_GREEN_LED, LOW);
+}
+//------------------------------------------------------------------------------------------------------

+//////////////////////// LCD DISPLAY///////////////////////////////////////////////////////////

+//------------------------------------------------------------------------------------------------------
+void lcd_display()
+{
+ lcd.setCursor(0, 0);
+ lcd.write(1);
+ lcd.setCursor(2, 0);
+ lcd.print(solar_volt);
+ lcd.print("V");
+ lcd.setCursor(14, 0);
+ lcd.write(5);
+ lcd.setCursor(16, 0);
+ lcd.print(temperature);
+ lcd.write(0b11011111);
+ lcd.print("C");
+ lcd.setCursor(0,1);
+ lcd.write(2);
+ lcd.setCursor(2, 1);
+ lcd.print(bat_volt);
+ lcd.print("V");
+ lcd.setCursor(14, 1);
+ lcd.write(2);
+ if((charge_status==1) | (charge_status== 2))
+ {
+ lcd.write(6);
+ }
+ else
+ {
+ lcd.write(7);
+ }
+ lcd.setCursor(0,2);
+ lcd.write(3);
+ lcd.setCursor(2,2);
+ lcd.print(load_current);
+ lcd.print("A");
+ lcd.setCursor(13,2);
+ lcd.print(watts);
+ lcd.print("W");
+ lcd.setCursor(0,3);
+ lcd.print("Energy:");
+ lcd.print(wattHours);
+ lcd.print("WH");
+
+
+
+
+
+}



https://github.com/deba168/ARDUINO-SOLAR-CHARGE-CONTROLLER-V-2/commit/9d69428f2e50930a617bc8b01e9cb448802108d8



ARDUINO-SOLAR-CHARGE-CONTROLLER-V-1

Arduino based PWM Solar Charge Controller

https://www.instructables.com/id/ARDUINO-SOLAR-CHARGE-CONTROLLER-PWM/



ARDUINO-SOLAR-CHARGE-CONTROLLER-V-2

An arduino based PWM Solar Charge Controller



MPPT_Master

ARDUINO MPPT SOLAR CHARGE CONTROLLER (Version-3.0)

Problem in V-3:

Während meines Prototyping hatte ich ein kritisches Problem.

Das Problem war, dass wenn ich die Batterie an den Controller anschließe, die Verbindung zwischen der Batterie und dem Schalter (Abwärtswandler) sehr heiß wird

und dann der MOSFET Q3 ausbrennt Kurzschluss des MOSFET-Q3.

So fließt Strom vom Batterie-MOSFET Q3-GND, was unerwartet ist.

Aktualisierung: 29.07.2016
Ich arbeite nicht mehr an diesem Projekt wegen einiger Probleme.

Dieser Controller funktioniert nicht ! ! !
Versuchen Sie also nicht zu bauen, wenn Sie nicht genügend Kenntnisse in diesem Bereich haben.
Sie können Ideen aus diesem Projekt übernehmen.

https://www.instructables.com/id/ARDUINO-SOLAR-CHARGE-CONTROLLER-Version-30/

http://www.gunook.com/arduino-mppt-solar-charge-controller-version-3-0/


Arduino-MPPT

Forked from aplavins/Arduino-MPPT

Arduino based Maximum Power Point Tracking (MPPT) solar charge controller




Solar-Powered-WiFi-Weather-Station

An ESP8266 based solar weather station

You can find all of my projects on : https://www.opengreenenergy.com/




********************************************************I*

LiPo Batterie   z.B. Handy-Akkus 3,7V / 2,2Ah

Solar Charger Shield V2.2   11/07/2014    für 5Vdc

Seeed Studio Shield SLD80227P   SKU 106990020
watterott Art.Nr.: 106990020


Das mit den Boards Arduino UNO, kompatible Shield von Seeed Studio versetzt Sie in die Lage, an Ihren Stromkreis einen LiPo-Akku anzuschließen, der über den USB-Port oder über Solarzellen geladen wird.
Außerdem können am seeed Studio Shield SLD80227P verschiedene Batterien zwischen 2,7V und 4,2V angeschlossen werden.
Am Ausgang stehen 5 V zur Verfügung.


IC CN3065  Lithium Ion Battery Charger for Solar-Powered Systems
http://cdn2.boxtec.ch/pub/seeed/DSE-CN3065.pdf


reichelt 

ARD SHD SOLAR V2 :: Arduino Shield - Solar Ladegerät v2.2


LM3224
CN3083


Der Solar Charger ist ein Shield für die Arduino Plattform. Er ermöglicht eine adaptive Energieversorgung.
Es lassen sich Akkus von 2,7-4,2V anschließen am Ausgang stehen dann 5V mit bis zu 700mA zur Verfügung.
Über den USB-Anschluss ist es ebenfalls möglich den Akku zu Laden.

Beschreibung
Der Solar Charger ist ein anreihbares Shield für Aduino-kompatible Plattformen mit adaptiver Akkuladefunktion für das Aufladen im Feldeinsatz.
Verwendet werden können Akkus von 3,0 - 4,2 V bis 5 V Output.
Oder das Board wird mit einem Lithiumakku und Solarmodul zu einer autonomen Sensoreinheit erweitert; es kann bis zu 600 mA Strom liefern.
Zum Aufladen kann auch ein USB-Anschluss verwendet werden.

Das Solar Charger Shield ist ein staperlbares Shield für Arduino-kompatible Plattformen.
Es ermöglicht angepasste Batteriespeisung und kann zum Aufladen von Batterien und natürlich zum Speisen eines Arduino kompatiblen Boards verwendet werden.
Mit einer LiPo Batterie und einem Solar Panel kann so schnell und einfach ein autonomes Sensor System aufgebaut werden.
Das Board kann bis zu 600mA liefern.

Technische Merkmale
• Output abschaltbar
• Kurzschlussschutz
• 3W Ausgangsleistung bei Anschluss eines Akkus
• Dauerladestrom bis 900 mA
• Anzeige für Akkustatus (rot: lädt; grün: voll aufgeladen)
• Micro-USB-Anschluss

Technische Daten
• Akkueingangsspannung: 3,0 ... 4,5 V
• USB-Eingangsspannung: 4,75 ... 5,25 V
• Eingangsspannung Solarteil: 4,8 ... 6 V 

Eingangsspannung Solarzelle: 5V (Solarzelle nicht im Lieferumfang enthalten)
Maximale Ausgangsspannung: 5V / 700 mA
• max. Ausgangsstrom (mit Akku): 3 W (600 mA bei 5 V)
• Brummspannung: < 100 mV bei 500 mA

LiPo-Batterie 3,7V nicht im Lieferumfang enthalten
• Abmessungen: 68x53x20mm


Hersteller : SEEED
Artikelnummer des Herstellers : 106990020


IC ETA1036 3W, 0.85V Startup Voltage, Synchronous Step-Up Converter with Real-Shutdown and Short-Circuit Protection in SOT23-5 
Datenblatt ETA1036



Programmierbeispiel
Sie können die Batteriespannung anhand des folgenden Beispiels messen:
/*
 Solar charger shield voltage measurement example. Connect VBAT pin to analog pin A0.

 The pin measures 2.0 V when not under direct exposre to sunlight and 5V when exposed to sunlight.

 This example code is in the public domain.

 */

// These constants won't change.  They're used to give names
// to the pins used:
const int analogInPin = A0;  // Analog input pin that the VBAT pin is attached to


int BatteryValue = 0;        // value read from the VBAT pin
float outputValue = 0;        // variable for voltage calculation

void setup() {
    // initialize serial communications at 9600 bps:
    Serial.begin(9600);
}

void loop() {
    // read the analog in value:
    BatteryValue = analogRead(analogInPin);
    // Calculate the battery voltage value
    outputValue = (float(BatteryValue)*5)/1023*2;
    // print the results to the serial monitor:
    Serial.print("Analog value = " );
    Serial.print(BatteryValue);
    Serial.print("\t voltage = ");
    Serial.println(outputValue);
    Serial.println("V \n");

    // wait 10 milliseconds before the next loop
    // for the analog-to-digital converter to settle
    // after the last reading:
    delay(10);
}


https://www.seeedstudio.com/Solar-Charger-Shield-v2.2-p-2391.html
http://wiki.seeedstudio.com/Solar_Charger_Shield_V2.2/
https://www.watterott.com/de/Solar-Charger-Shield-V22
https://www.generationrobots.com/media/Shield%20chargeur%20pour%20panneaux%20solaires/Solar_Charger_Shield_.pdf








********************************************************I*


        Arduino based MPPT Solar Charge Controller

ARDUINO basierte MPPT SOLARLADEREGLER


Schaltplan und Code finden Sie auf meiner Website ARDUINO basierte MPPT SOLARLADEREGLER

https://www.electronicslovers.com/2015/09/arduino-based-mppt-solar-charge.html

Was ist Mppt (Maximum Power Point tracking)?
"Wir verwenden MPPT Algorithmus, um die maximal verfügbare Leistung aus der Photovoltaik-Modul unter bestimmten Bedingungen bekommen"
Wie funktioniert MPPT? Warum entspricht 150W Solar-Panel nicht auf 150 w?

Zum Beispiel kaufte Sie ein Solar-Panel aus dem Markt die 7 Ampere auslöscht. unter Anklage ist die Einstellung einer Batterie, 12 Volt: 7 Ampere mal 12 Volt = 84w konfiguriert (P = V * ich)
Sie verloren mehr als 66 Watt - aber Sie zahlten für 150 Watt.
Das 66 Watt ist nicht überall, aber es ist wegen dem schlechten Spiel der solar Strom und Batterie Ausgangsspannung.

Nach der Verwendung von MPPT-Algorithmus kann man die maximal verfügbare Leistung
Batterie wird ist jetzt 12 Ampere bei 12 Volt Ausgangsleistung ist gleich p = V * ich p = 12 * 12 = 144w, jetzt Sie noch fast 144 Watt haben, und jeder glücklich ist.

Angabe der Projekt-
1. dieses Projekt basiert auf MPPT (Maximum Power Point Tracker) Algorithmus
2. LED-Anzeige, die geringe Mitte zeigen und hohe Gebühr Stat
3. LCD (20 x 4 Zeichen) Display für die Anzeige von Leistung, Strom, Spannungen etc.
4. Blitz /Over Spannung Schutz
5. Schutz für Reverse Stromfluss
6. Über einen Kurzschlussschutz
7 & laden. Protokollierung von Daten über WiFi
8. Laden Sie Ihr Handy, Tabletten alle Gadgets Throug USB Port elektrische Spezifikationen:

1. Nennspannung = 12V
2. max. Eingangsstrom = 5A
3. Last aktuelle Unterstützung bis zu 10A =
4. In put Spannung = Solar-Panel 12 bis 24V
5.Power von Solar-Panel = 50 Watt

Selbstgebauter MPPT-Laderegler (Maximum Power Point Tracking)

Arduino-basierter MPPT-Laderegler | Alternative Energie | erneuerbare Energien | saubere Energie
Was ist Mppt (Maximum Power Point Tracking)?

Wir verwenden den MPPT-Algorithmus, um die maximal verfügbare Energie aus dem Photovoltaik-Modul unter bestimmten Bedingungen zu extrahieren.
MPPT ist ein beliebtestes Werkzeug, das uns hilft, Sonnenenergie (erneuerbare Energiequelle) effizient zu nutzen.
Wenn wir das Diagramm der CO2-Fußabdrücke reduzieren wollen, müssen wir uns in Richtung saubere Energie bewegen, die erneuerbare Energie genannt wird (Energie, die wir aus natürlichen Ressourcen bekommen können), wie SOLAR, HYDRO, WIND e.t.c sonst werden wir direkt in Richtung Globale Erwärmung gehen.
Jedes Land muss sich auf die Grüne Energie, besonders auf die CHINA, konzentrieren, da es mit 63% CO2 den Hauptbeitrag leistet Alternative Energie.
Wie funktioniert MPPT? Warum 150W Solarpanel nicht gleich 150 Watt?
Zum Beispiel haben Sie ein neues Solarpanel vom Markt gekauft, das 7 Ampere Strom liefern kann, unter der Ladung ist die Einstellung einer Batterie auf 12 Volt konfiguriert: 7 Ampere x 12 Volt = 84W (P = V * I)
Sie haben mehr als 66 verloren Watt - aber Sie haben für 150 Watt bezahlt.
Das 66 Watt geht nirgends hin, aber es liegt an der schlechten Übereinstimmung von Solarausgangsstrom und Batteriespannung.

Nach der Verwendung des MPPT-Algorithmus können wir die maximale verfügbare Leistung erreichen.
Battery gets ist jetzt 12 Ampere bei 12 Volt Ausgangsleistung ist gleich p = V * I p = 12 * 12 = 144W
Jetzt haben Sie noch fast 144 Watt, und alle sind glücklich.


Specification of the project
1.This project is Based on MPPT (Maximum power point tracker) algorithm
2. LED indication to show the low mid and high level of charge stat
3. LCD (20×4 character ) display for displaying power,current,voltages etc
4. Lightning /Overvoltage Protection
5. Protection For Reverse power flow
6. Overload & Short Circuit Protection
7. Logging data through WiFi
8.Charge your Cellphone, tablets any gadgets through USB port

Electrical specifications:
1.Rated Voltage= 12V
2.Maximum input current = 5A
3.Load current support up to =10A
4. Input Voltage = Solar panel 12 to 24V
5.power of Solar panel = 50 Watts


Bauteile-Liste:

Widerstände
3x 200R, 3x330R, 1x 1k, 2x 10k, 2x 20k, 2x 100k, 1x 470k
bidirectional TVS-Suppresor-Diode 2x P6KE36CA    36V / 12A
ARDUINO Nano
Stromsensor  ACS712-5A
Buck-Konverter  LM2596
WiFi-Modul  ESP8266
LCD-Display  20x4 I2C
MOSFETs  4x IRFZ44N
MOSFET-Treiber  IR2104
3,3V Linearregler  AMS-1117
Transistor  2N2222
Dioden 2x 1N4148, 1x 1N4007
Kondensatoren 4x 0,1 uF, 3x 10uF, 1x 100uF, 1x 220uF
Induktivität 1x 33uH - 5A
5mm LEDs rot, gelb, grün
Sicherungen 5A mt

Libraries Required For Arduino IDE : 

Remember: Make a New Folder ( Folder name should be same as library names like TimerOne and LiquidCrystal_I2C. Paste these Two Folders in Arduino/LIbrary.


https://www.electronicslovers.com/2015/09/arduino-based-mppt-solar-charge.html
http://www.genstr.com/arduino-basierte-mppt-solarladeregler.html





********************************************************I*

             Arduino PWM solar charge controller

Wie man einen sehr kleinen, einfachen und billigen PWM-Solarladeregler mit Arduino Pro Mini für 12V Inselnetzinstallationen macht.
Die Größe der Leiterplatte entspricht der Größe der Pro Mini-Platine, sodass sie zusammengefügt werden können. PCB-Pläne sind für universelle Prototyp-Platine.


Arduino PWM Solarladereglerschaltung 4

Der Anschluss und die Verwendung dieses Arduino Solarladereglers ist sehr einfach - es gibt 2 Eingangskabel vom Solarpanel (+ und -) und 2 Ausgangskabel zum Bleiakku.
Der Boden von Solarpanel und Batterie ist zusammengefügt.
Jede Last sollte direkt an den Batterieklemmen angeschlossen werden und der Laderegler wird automatisch den Rest übernehmen.



Arduino misst regelmäßig die Batteriespannung der Bleibatterie
und schaltet den MOSFET entsprechend dem erkannten Wert ein, um die Batterie vom Solarpanel zu laden
und schaltet den MOSFET aus, wenn die Batterie voll ist.
Wenn die Batterie mit Strom versorgt wird, erkennt der Controller den Spannungsabfall und beginnt sofort wieder, den Akku zu laden.
Während der Nacht, wenn das Solarpanel nicht mehr produziert, wartet der Controller, bis das Panel wieder startet.






Positive Führung zum Solarpanel erfordert Schottky-Schutzdiode direkt auf dem Kabel (in Schrumpfschlauch verpackt).
Es ist nicht in der Hauptplatine enthalten, da es dadurch einfacher ist, es zu ersetzen und gleichzeitig abzukühlen.
Sie könnten die Platine leicht etwas länger machen, um in eine andere Art von Diode zu passen.

Schaltplan & Funktionsbeschreibung:






Die Funktion basiert auf dem N-Kanal-MOSFET IRF3205 in der High-Side der Schaltung.
Dies erfordert eine Gate-Spannung von mehr als 12 V, um den MOSFET richtig zu öffnen.
Um die Notwendigkeit eines externen MOSFET-Treibers wegzulassen, wird er von einer Ladungspumpe angetrieben,
die mit Dioden, zwei Kondensatoren und zwei Arduino-PWM-Ausgangspins (3 und 11) erzeugt wird.
Pin A1 misst die Batteriespannung und Pin 9 steuert den Ein- / Ausschaltzyklus des MOSFET.
Die integrierte Arduino Pro Mini-LED, die an Pin 13 angeschlossen ist, zeigt das aktuelle PWM-Tastverhältnis an.

Löschen Sie die Code-Zeile 
analogWrite(13, 255 - pulseWidth); // pwm to LED
wenn die blinkende LED stört.

ARDUINO UNO R3 mit ATmega328p

Spannungsregler und alle Kondensatoren (C6, C5 und C4) könnten möglicherweise ausgeschlossen werden, da ein Regler im Arduino Pro Mini enthalten ist.
Da ich aber billiges Clone-Board verwende, bin ich nicht bereit, auf seine Fähigkeit zu zählen, höhere Spannungen als 12V für längere Zeiträume aufrechtzuerhalten.
LP2950 ist sehr günstig und effektiv bis 30 Volt, also lohnt es sich auf jeden Fall an Bord zu haben.



PCB - Ansicht von oben




PCB - Ansicht von oben und unten:



Bauteileliste

Arduino
Pro Mini ATmega328P 5V 16MHz
Low-Power Voltage Regulator
IC1=LP2950ACZ-5.0
Transistors
T1=2N3904 npn
T2, T3=2N3906 pnp
N-channel MOSFET
T4=IRF3205
Resistors
R1=82k (1%)
R2=20k (1%)
R4, R4, R5= 220k  / 0,4W
R6=4,7k                 / 0,4W
Diodes
D1, D2, D3, D4, D5=1N4148
D6=P6KE33CA
D7=90SQ035 / 10SQ045 or any similar Schottky diode 35V minimum 9A  (nicht 1N5408 nur 3Amp und nicht Schottky-Diode)
(10A 45V from eBay: https://goo.gl/6WDnYq or 20A 45V from eBay: https://goo.gl/xUKvGu)
Capacitors
C1, C2=47nF/50V  ceramic
C3=220pF/100V ceramic
C4=100nF/50V ceramic
C5=4,7uF/10V tantal
C6, C7=1uF/35V tantal


Arduino code – basic version 1:

void setup() {
TCCR2A = TCCR2A | 0x30;
TCCR2B = TCCR2B & 0xF8 | 0x01;
analogWrite(11, 117);
analogWrite(3, 137);
// Serial.begin(9600);
}
 
const int setPoint = 13.5 * 20 / (20+82) * 1024 / 5;
int measurement = 0;
int pulseWidth = 0;
int difference = 0;
int stepSize = 0;
 
void loop() {
measurement = analogRead(A1);
difference = abs(setPoint - measurement);
stepSize = difference;
if (measurement < setPoint) { pulseWidth += stepSize; if (pulseWidth > 255) pulseWidth = 255;
}
if (measurement > setPoint)
{
pulseWidth -= stepSize;
if (pulseWidth < 0) pulseWidth = 0; } // Serial.println(pulseWidth); analogWrite(9, pulseWidth); analogWrite(13, 255 - pulseWidth); // pwm to LED delay(10); }


Arduino code – Version 1.1
Code mit besserem Blinken von pin-13 integrierte LED nach PWM-Pulsen:

const int setPoint = 13.5 * 20 / (20+82) * 1024 / 5;
int measurement = 0;
int pulseWidth = 0;
int difference = 0;
int stepSize = 0;
int calculation = 0;
int led = 13;

void setup() {
TCCR2A = TCCR2A | 0x30;
TCCR2B = TCCR2B & 0xF8 | 0x01;
analogWrite(11, 117);
analogWrite(3, 137);
// Serial.begin(9600);
pinMode(led, OUTPUT);
}

void loop() {
measurement = analogRead(A1);
calculation = setPoint - measurement;
difference = abs(calculation);
stepSize = difference;

if (measurement < setPoint) { pulseWidth += stepSize; if (pulseWidth > 255) pulseWidth = 255;
analogWrite(led, 0); // pwm to LED
}
if (measurement > setPoint)
{
pulseWidth -= stepSize;
if (pulseWidth < 0) pulseWidth = 0; analogWrite(led, 255); // pwm to LED } // Serial.println(pulseWidth); analogWrite(9, pulseWidth); delay(10);

}


Arduino code download: arduino-pwm-solar-charge-controller.ino
Version 1.1 code download: arduino-pwm-solar-charge-controller-v1.1.ino



Schaltplan und Code dieses Ladereglers ist von Julian Ilett, er ist der Mastermind hinter dieser cleveren Sache.
All dies ist nur eine ausgefeilte Dokumentation und ein passendes PCB-Design, um perfekt in das Arduino Pro Mini Board zu passen.
Er teilt Videos von effektiveren Arduino MPPT Laderegler, aber seine Konstruktion ist viel komplizierter und das Projekt ist noch nicht fertig.

Wenn Sie den Code oder die Konstruktion in irgendeiner Weise verbessern, teilen Sie Ihre Verbesserung bitte in den Kommentaren




Version 1.2

Maybe I figured it out. You only set inverted mode for OC2B – pin 3 in TCCR2A and no presampling in TCCR2B. No interrupts, timer is used. If I am right, my only question is, if the both analogWrite values will be the same, e.g. 127, will that make higher voltage on charge pump? It seemes to me, that You intentionally change the values, so some pulses should be overlapped and slightly decreasing the maximum voltage of charge pump. Is that right?
Hi, Dickson charge pump with diodes should not have overlapping waveforms. Having something like a 10% reduction in pulse width so the signals don’t overlap improves efficiency of the charge pump.


Thank You very much for explaining and sorry for the name :-). I have last question. You wrote: “During the night, when solar panel stops producing, controller waits until panel starts to output again.”
But there is nothing in code what could do that, in my opininon, the controller will set pulsewidth 255 during the night, but there will be no power coming out of the panel. Is that right? I want to use it my car, for charging battery in winter with 18V/1A solar panel, but i will add some discharge pulses because of desulfatation. I have charger with 2051 which charge 9 pulses and 1 discharge pulse, when it reach 13.8V, it charge 1 pulse + 1 discharge puls. But it is powered by small transformer 24V/2W and it’s not suitable for solar panel.

Right, arduino loops until solar panel starts producing power again in the morning. Interesting idea about desulfatation, maybe you could use code modification i made some time ago. I added RGB led to visually indicate charging and state of batteries, its used on my solar setup and works great.

https://www.arduined.eu/files/arduino-pwm-solar-charge-controller-v2-rgb-led.ino

You could modify the voltage values for your needs and add some discharge circuit activation when battery is fully charged on line

} else if ((batteryVoltage > 13.40) && (batteryVoltage < 13.80)) {
setColor(0, 255, 0); // green
}

For RGB i used this cheap common anode LED with 1k or 4k7 resistors on pins 5,6,7

https://www.ebay.com/itm/10Pcs-LED-DIFFUSED-RGB-common-anode-4-PINS-F5-5MM-Super-Bright-Bulb-Lamp/221993821141

When charging RGB blinks green, when not charging and batteries are above 13.4 Volts it stays green.
Between 13 to 13.4 its bright yellow, below 13 Volts dimmer yellow and when battery bank drops below 12.50 it gets red


const int setPoint = 13.5 * 20 / (20+82) * 1024 / 5;
// http://www.ohmslawcalculator.com/voltage-divider-calculator
int measurement = 0;
int pulseWidth = 0;
int difference = 0;
int stepSize = 0;
int calculation = 0;
int led = 13;
float batteryVoltage = 0;
int redPin = 7; // RGB LED red pin
int greenPin = 6; // RGB LED green pin
int bluePin = 5; // RGB LED blue pin


void setup() {
  TCCR2A = TCCR2A | 0x30;
  TCCR2B = TCCR2B & 0xF8 | 0x01;
  analogWrite(11, 117);
  analogWrite(3, 137);
  // Serial.begin(9600);
  pinMode(led, OUTPUT);
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}


void loop() {
  measurement = analogRead(A1);
  calculation = setPoint - measurement;
  difference = abs(calculation);
  stepSize = difference;

  /*
    Measuring DC Voltage using Arduino
    https://startingelectronics.org/articles/arduino/measuring-voltage-with-arduino/
  */
  batteryVoltage = (analogRead(A1) * 4.99 / 1024) * 5.161;
  
    /*
       Serial.print("analogRead: ");
       Serial.println(analogRead(A1));
       Serial.print("batteryVoltage: ");
       Serial.println(batteryVoltage);
       Serial.print(" ");
    */

  if (measurement < setPoint)
  {
    pulseWidth += stepSize;
    if (pulseWidth > 255) pulseWidth = 255;
    analogWrite(led, 0); // pwm to LED
    setColor(0, 0, 0); // turn off RGB
  }
  if (measurement > setPoint)
  {
    pulseWidth -= stepSize;
    if (pulseWidth < 0) pulseWidth = 0;
    analogWrite(led, 255); // pwm to LED
  }
  analogWrite(9, pulseWidth);
  
  if (batteryVoltage < 12.00) {
    setColor(0, 0, 0); // turn off RGB
  } else if ((batteryVoltage > 12.00) && (batteryVoltage < 12.50)) {
    setColor(255, 0, 0); // red
  } else if ((batteryVoltage > 12.50) && (batteryVoltage < 13.00)) {
    setColor(155, 155, 0);// yellow
  } else if ((batteryVoltage > 13.00) && (batteryVoltage < 13.40)) {
    setColor(255, 255, 0);// yellow
  } else if ((batteryVoltage > 13.40) && (batteryVoltage < 13.80)) {
    setColor(0, 255, 0); // green
  } else if (batteryVoltage > 14.40) {
    setColor(255, 0, 255); // red
  }

  delay(10);
}

void setColor(int red, int green, int blue)
{
red = 255 - red;
green = 255 - green;
blue = 255 - blue;
analogWrite(redPin, red);
analogWrite(greenPin, green);
analogWrite(bluePin, blue);
}


https://www.arduined.eu/arduino-solar-charge-controller/
https://www.arduined.eu/files/arduino-pwm-solar-charge-controller-v2-rgb-led.ino
http://www.ohmslawcalculator.com/voltage-divider-calculator
https://startingelectronics.org/articles/arduino/measuring-voltage-with-arduino/

https://www.youtube.com/watch?v=MdgYXxQW0hA
http://www.irf.com/product/HiRel-Products-HiRel-Schottkys-Rectifiers-HiRel-Schottkys/_/N~1nje2p
https://youtu.be/db1JZUecYlI
https://www.youtube.com/watch?v=ZnOdGsqDfI8&list=PLpGbjnsmeLnCb7Oqr6zBZKd7dTDH8fZhn






DIN A4  ausdrucken
********************************************************I*
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE







Comments