http://sites.schaltungen.at/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
DIN A4  ausdrucken   (Heftrand 15mm / 5mm)     siehe     http://sites.schaltungen.at/drucker/sites-prenninger
~015_b_PrennIng-a_elektronik-solar-arduino.solarladeregler (xx Seiten)_1a.pdf

Untergeordnete Seiten (17):

               ARDUINO Solarladeregler Version 2.0

                                    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 chhabe 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

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:

https://github.com/deba168
deba168Arduino based PWM Solar Charge Controller

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

Solar_charge_controller-v2.ino

+// 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

MPPT-V3.1

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

Datenblatt ETA1036
Datenblatt CN3065

Der Solar Charger ist ein Shieldfür die Arduino Plattform. Er ermöglichteine 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.

Hersteller : SEEED
Artikelnummer des Herstellers : 106990020

/* 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 toint BatteryValue = 0;        // value read from the VBAT pinfloat outputValue = 0;        // variable for voltage calculationvoid 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

Libraries Required For Arduino IDE : 

• TimerOne.h – Click Here To Download This Library 
• LiquidCrystal_I2C – Click Here To Download This Library

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.

PCB - Ansicht von oben

PCB - Ansicht von oben und unten:

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