Integrierter Solarladeregler, Wechselrichter, PowerBank, Lampe

Notwendige Werkzeuge und Maschinen

	Lötkolben (generisch)
	Bohrmotor
	Heißklebepistole (generisch)

Apps und Onlinedienste

	Arduino-IDE
	AutoDesk 123D

Über dieses Projekt

Über dieses Projekt

Ich habe ein paar Sonnenkollektoren, 12-Volt-Batterien, Transformatoren und noch ein paar andere Sachen, die eine Weile herumliegen und laut schreien, um sie sinnvoll zu nutzen. Dies ist die Geburtsstunde dieses Gerätes - komplette kleine PV-Lösung auf einer einzigen Platine. Lassen Sie uns zuerst überprüfen, was was bewirkt, sollen wir?

• Ein Laderegler ist ein Gerät, das das Laden des Gleichstromspeichers/der Batterie von einem Photovoltaik-Solarpanel und das Entladen der Batterie durch die Last regelt, um die Batterielebensdauer zu verlängern.
• Ein Wechselrichter ist ein Gerät, das Gleichstrom in Wechselstromform umwandelt, um Wechselstromlasten zu betreiben.
• Power Bank versorgt Gadgets/Mobilgeräte mit 5V DC über den USB-Anschluss zum tragbaren Laden oder netzunabhängigen Laden.
• Notfalllampe ist eine superhelle LED-Lichtquelle, die bei Stromausfall, Camping und Outdoor-Aktivitäten nach Einbruch der Dunkelheit verwendet werden kann.

Dieses Gerät, das ich gemacht habe, hat all diese Funktionen, die letzten beiden Funktionen werden unabhängig von der integrierten Lithium-Ionen-Batterie unterstützt. Mit einem Solarpanel (bis 100 Watt), einem 12 Volt Bleiakku und einem Transformator lassen sich alle Möglichkeiten nutzen.

Proto-Version auf Uno

Die erste Version wurde auf Uno Board mit minimaler Hardware und minimalen Optionen entwickelt. Das Nokia Display wurde direkt montiert und ein MOSFETs-Shield wurde entwickelt, um das Laden/Entladen des Akkus zu unterstützen. Es gibt keine Menüsteuerung, keinen Wechselrichter, kein PWM-Laden und coole Funktionen! Laden Sie einfach ein / aus und zeigen Sie die Batterie- und Panel-Spannungspegel an. Macht den Job, hat aber keinen Charme!

Vollwertige Version auf Protoboard

Dann habe ich dieses neue mit folgenden Funktionen entwickelt:

• PWM Solarladeregler bis 100 Watt Panel
• Square Wave Mini 60 Watt Wechselrichter
• Bis zu drei 12-Volt-DC-Laststeuerung
• Primäre DC-Last unterstützt automatische Ein-/Ausschaltfunktionen
• Eine unabhängige USB-Powerbank
• Buck-Regler-Modul
• Notfall-LED-Lampe an Bord mit Blink- und Helligkeitssteuerung

2-Tasten-/Schaltergesteuertes Scrollen und Auswählen basierendes Menü zur Benutzersteuerung, Anzeige von Optionen und Statusinformationen auf dem Nokia 5110 Display. Sehr cool! Rückseite ist heißklebeisoliert für Kurzschlussschutz gegen metallische Gegenstände!

Es gibt einige praktischere Funktionen wie den Ein-/Ausschalter für die Hintergrundbeleuchtung des Displays, der das Geld für den unabhängigen Betrieb durch Abschalten vom internen Akku trennt.

Der Zugriff auf das Menü auf dem Display des Nokia 5110 mit der Benutzertaste wird hier gezeigt:

Lass uns ein paar technische Sachen lernen!

Der Laderegler kann vom Typ On/Off, PWM oder MPPT sein. On/Off ist die einfachste Form (meine Version 1 - Bild oben) eines Controllers, der den Ladestrom nicht drosselt, wenn sich die Batteriespannung der vollen Ladespannung nähert.

Wobei PWM den Ladestrom allmählich verringert, wenn die Batterie voll wird. Der PWM-Controller hat folgende Vorteile:

• Hilft verlorene Batteriekapazität wiederherzustellen und eine Batterie zu entsulfatieren
• Erhöht die Fähigkeit des Akkus, mehr Ladung aufzunehmen
• Behalten Sie eine hohe durchschnittliche Batteriekapazität von bis zu 95 % bei
• Driftende Batteriezellen ausgleichen, damit interne Zellen das gleiche Potenzial erreichen können
• Reduzieren Sie die Erwärmung und Gasbildung der Batterie und verhindern Sie so Elektrolytverlust
• Verlangsamt die Alterung und verlängert die Lebensdauer des Systems

PWM kann jedoch nicht den größten Teil der elektrischen Leistung aus PV-Solarmodulen herausholen, da es das Panel in die Nähe der Batteriespannung zieht. MPPT ist die Lösung für dieses Problem, bei dem es sich im Grunde um einen einstellbaren DC-DC-Abwärts-/Aufwärtswandler handelt, der im Vergleich zu einem PWM-Controller den größten Teil der Solarenergie umwandeln kann.

Wechselrichter können Rechteckwellen-, modifizierte Sinuswellen- und reine Sinuswellentypen sein. Der Rechteckwellen-Wechselrichter ist sehr einfach im Design und gut genug für kleine DC-Lasten wie AC-Lampen, CFL-Lampen, Tischventilatoren, Lötkolben, aber nicht für Induktionsmotoren, empfindliche Geräte / Netzteile wegen harmonischer Verzerrung empfohlen.

Die modifizierte Sinuswelle ist eine Art verzögerte Sinuswelle, die aus Rechteckwellen erzeugt wird, besser als einfache Rechteckwellen-Wechselrichter. Sinus-Wechselrichter eignen sich am besten für alle Arten von Lasten, sind jedoch komplex in der Hardwareentwicklung, schwierig zu bedienenden Softwarealgorithmen und teuer in der Herstellung.

Ein Abwärtsregler ist ein DC-DC-Abwärtswandler, hier habe ich ein Abwärtsmodul verwendet, um den 4,2 V Li-Ion-Akku aufzuladen, der den Controller (Arduino + Display), eine unabhängige USB-Powerbank und eine integrierte LED-Lampe mit Strom versorgt.

Jetzt ist die USB-Powerbank im Grunde ein DC-DC-Boost, der einen Spannungsbereich unter 5 (wie 3,3 bis 4,2 Volt) von einem Li-Ion- oder LiPo-Akku auf 5 Volt umwandeln kann, was die USB-Busspannung ist, mit der mobile Geräte geladen werden können .

Es hat auch einen Abwärtswandler zum Aufladen dieser Batterie. In meinem Projekt nimmt das Buck-Modul etwas Saft aus dem Panel, um den internen (an Bord) Akku aufzuladen.

Funktionsweise der Hardware

Bevor wir ins Detail gehen, überprüfen Sie dieses Bild von allem, was mit dem Gerät verbunden ist:

Das System verfügt über verschiedene Hardware für unterschiedliche Zwecke. Natürlich ist das Gehirn ein AVR Atmega8A Mikrocontroller (kann mit geringfügigen Änderungen verwendet werden, siehe unten), der in Arduino programmiert ist.

Ein frischer Atmega8A wird mit dem Arduino Optiboot8 Bootloader gebrannt, Sie können einen Bootloaded Arduino Mini/Atmega328 kaufen, um den Ärger zu vermeiden.

Der Controller, das Display, die LED-Lampe und die Powerbank werden über den integrierten Lithium-Ionen-Akku mit Strom versorgt. Zwei kurzzeitige Berührungstasten dienen dem Zugriff auf das angezeigte Menü, mit dem der Benutzer verschiedene Funktionen des Geräts bedienen kann. Die Schalter werden durch parallel geschaltete Glättungskondensatoren hardwaremäßig entprellt.

Ein Schiebeschalter ermöglicht das Ein- und Ausschalten des Geräts nach Bedarf.

Die Solarladefunktion wird von einem P-MOSFET ausgeführt, der von einer 2N2222-Transistor-basierten Treiberschaltung angesteuert wird, die über PWM vom Mikrocontroller gesteuert wird. Die PWM wird basierend auf dem externen Batteriespannungspegel gesteuert. Strom von Sonnenkollektoren fließt durch P-MOSFET zur Blei-Säure-Batterie. Wenn die Batterie vollständig geladen ist, wird der MOSFET vom Mikrocontroller ausgeschaltet. Nachdem der Ladevorgang ausgeschaltet wurde, beginnt die Batteriespannung allmählich zu sinken, wenn sie 13,6 Volt erreicht, wird der Ladevorgang mit niedrigem Arbeitszyklus wieder aufgenommen, um die Erhaltungsladung aufrechtzuerhalten.

Die 12-Volt-Gleichstromlast wird über einen N-MOSFET gesteuert, indem sein Gate-Pin vom Mikrocontroller gesteuert wird.

Die On-Board-LED-LAMPe wird ebenfalls über einen NMOS angesteuert. Das Gate dieses MOSFET ist PWM-gesteuert zur Helligkeitsanpassung der LED.

Der Wechselrichterblock besteht aus 2 N-MOSFETs, die abwechselnd ein- und ausgeschaltet werden, um Wechselstrom zu simulieren. Durch Hinzufügen eines externen Mittelanzapfungstransformators kann eine Rechteckwellen-Wechselstromversorgung realisiert werden.

Die folgende Abbildung erläutert die Wechselrichteraktion:

Indem Strom durch die Mittelanzapfung der Spule eines Aufwärtstransformators in entgegengesetzter Richtung fließen kann, kann alternativ unter Verwendung von MOSFETs eine Wechselspannung in der Sekundärseite erzeugt werden. Dies geschieht, weil der Strom nach oben fließt, wenn der obere MOSFET eingeschaltet und der untere MOSFET ausgeschaltet ist. Aber wenn der obere MOSFET ausgeschaltet ist und der untere MOSFET eingeschaltet ist, fließt Strom nach unten.

Beide MOSFETs müssen mit der doppelten Wechselstromfrequenz umgeschaltet werden. Überprüfen Sie das nächste Bild, um es zu verstehen:

Um 50 Hz Wechselstrom zu erzeugen, wird eine alternierende Rechteckwelle auf die Niederseite des 12-0-12V/220V Mittelabgriffstransformators angewendet. 50 Hz bedeutet 20 ms Zeit für jede Welle.

Aus diesem Grund werden 20 ms/2 =10 ms oder 100 Mal die Gate-Signale umgeschaltet, die an die den Transformator ansteuernden MOSFETs (Inverter-MOSFETs) angelegt werden.

Warnung !!! :Wechselspannung ist tödlich für Menschen, kann Tod/Verletzung verursachen! Berühren Sie die HV-Seite des Transformators niemals mit bloßen Händen!

Wenn die Wechselrichterfunktion nicht verwendet wird, ermöglicht die Option 2XDC Load die Verwendung von zwei weiteren 12-Volt-DC-Lasten an der Wechselrichterklemme.

Magie der Software

Es werden zwei Codesätze bereitgestellt, einer ist vollständiger Code in einem einzigen Arduino-Tab, ein anderer ist Tabbed-Code gemäß separater Funktionen.

Ich habe eine Gruppe von Aufgaben zu einer einzigen Funktion verallgemeinert.

Zum Beispiel:

Get_ADCVal() misst die Spannungen des Panels, der internen Batterie und der externen Batterie, nimmt 20 Abtastungen, mittelt diese Werte und aktualisiert die Informationen zur variablen Haltespannung.

Context_Control() führt die Benutzerinteraktion, Aktionssteuerung, Info-Aktualisierung bei anzeigebezogenen Aktivitäten durch.

Charging_Control() , Discharging_Control(), Load_Control() sind Hintergrundfunktionen, die als CLOSE LOOP für das System fungieren, den Batteriespannungspegel überwachen, die Auto-Load-Funktion, die Überladungs-/Tiefentladungsschutzsteuerung usw. steuern.

Benutzereingaben werden durch Interrupt-gesteuerte kurzzeitige Druckschalter gesammelt. Wenn diese Schalter gedrückt werden, werden INT0/INT1-bezogene ISR ausgeführt. Zwei flüchtige Variablen dp und ds Änderungen. Eine weitere dritte Variable Ebene zusammen mit dp (Anzeigezeiger ->) und ds (Anzeigeinhaltsauswahl) ermöglicht es dem Benutzer, durch Menüs/Untermenüs zu navigieren und Aktionen nach Bedarf auszuführen.

Der 16-Bit-TImer1 des AVR ist so konfiguriert, dass er alle 10 ms einen Timer-Überlauf-Interrupt generiert und PIN_INVP und PIN_INVN umkehrt, wenn die Wechselrichterfunktion eingeschaltet ist.

Alle Funktionen von Lcd_....() haben etwas mit der Anzeigesteuerung zu tun.

Atmega8A vs Atmega328P (Uno)

Das System kann leicht aktualisiert werden, um mit Atmega328P/Uno zu arbeiten, indem die folgenden Änderungen am Code vorgenommen werden. Suchen und ersetzen

 TIMSK mit TIMSK1#define ADC_VREF 2.69 mit #define ADC_VREF 1.11 #define ADCVDIV_R1 22 mit #define ADCVDIV_R1 8.2  

Im Hardwareteil müssen Sie einen 8,2 K-Widerstand anstelle von 22 K verwenden um das Panel zu verkleinern, Batteriespannungen auf den ADC-Messbereich.

Action-Videos

Normalerweise lese ich nicht nur Worte über ein Projekt, sondern gehe zuerst auf das Video ein. Wenn Sie wie ich sind, genießen Sie die Videos:

Umfang der Verbesserung

Mir ging der Flash-Speicher in Atmega8A aus. Einige wichtige Funktionen konnten nicht hinzugefügt werden, z. B.:

• Softwaregesteuerter Überlast-/Kurzschlussschutz
• Einige grafische Symbole und ein Logo
• Energiemessung und Protokollierung
• Schätzung und Alarm für Backup-Zeit
• Laptop-Ladeoption
• Unterstützung für das 6-Volt-System
• Bluetooth-Laststeuerung
• Timerbasierte Laststeuerung
• Eine RTC-Uhr für weitere coole Funktionen
• IoT-vernetzte Lösung

Wenn Sie vorhaben, so etwas zu erstellen, vergessen Sie nicht, einige dieser Funktionen hinzuzufügen!

Atmega328P (Uno) oder Arduino Mega könnten ein besserer Kandidat für all diese Optionen sein.

Wie auch immer, es macht seinen Job, ich bin damit zufrieden.

Zusätzliche Ressourcen

• Laden Sie Arduino 1. 0. 6 mit Atmega8-Board-Unterstützung herunter
• Öffne Arduino.exe, gehe zu Tools> Board> Optiboot8
• Bootloader mit dieser Methode brennen
• Code kompilieren und hochladen

Code

• Einzel-Tab-Code
• Vollständiger Code
• Bootloader

Einzel-Tab-Code Arduino

#define PIN_SCE 12#define PIN_RESET 13#define PIN_DC 8#define PIN_SDIN 7#define PIN_SCLK 6#define PIN_INVP 4#define PIN_INVN 5#define PIN_LOAD 9 // 12 V DC Last#define PIN_LAMP 10 // WEISSES LED-LICHT #define PIN_BATTPWM 11 // Treibt PMOS für das Laden externer Batterien an #define PIN_BATTint_Sense A2#define PIN_SOLAR_Sense A0#define PIN_BATText_Sense A3#define ADC_VREF 2.695 // interne Referenzspannung, ca. 1.11V für Arduino Uno aka Atmega328P, hier mein Atmega328P! define ADCVDIV_R1 22 // 22 K Spannungsteiler unterer Widerstand#define ADCVDIV_R2 175 // 175 K Spannungsteiler oberer Widerstand //const uint8_t skulljoke[] PROGMEM ={2,};// PIN 2 &3 VERWENDET ALS INTERRUPT SWITCH// PIN 0 &1 AS PROGRAMMIERUNG // PIN RESET AS#define LCD_C LOW#define LCD_D HIGH#define LCD_X 84#define LCD_Y 48uint8_t x=0;uint8_t level=0;uint8_t blinker=0; boolean Load_Auto_Enable=0;float maxADC_Voltage=0.0;float BattInt_Voltage=0.0;float BattExt_Voltage=0.0;float PV_Voltage=0.0;volatile int y=0;volatile uint8_t dp =0;volatile uint8_t ds =0;volatile0;volatile=0;volatile0;volatile uint8_t cdc_level =0; //int i;void setup (void) { LcdInitialise (); LcdClear(); LcdString("*ARDUBOY PV*"); LcdString(" STEUERUNG,"); LcdString("Wechselrichter,"); LcdString("POWER BANK, "); LcdString("LAMP THING!!"); Verzögerung (3000); analogReferenz (INTERN); maxADC_Voltage=(ADC_VREF/ADCVDIV_R1)*(ADCVDIV_R1+ADCVDIV_R2); pinMode (PIN_LOAD, OUTPUT); digitalWrite (PIN_LOAD, LOW); pinMode(2, INPUT_PULLUP); attachInterrupt (0, SW1, FALLING); // Interrupt für Swithc 1 pinMode (3, INPUT_PULLUP); attachInterrupt(1, SW2, FALLING); // Interrupt für Swithc 2 }void loop (void){ Get_ADCVal();Context_Control();Charging_Control();Discharging_Control();Load_Control();LcdClear();;}// /////////// ADC ///////////////void Get_ADCVal(void){int I=0;int J=0;int K=0;for( x=0;x<20;x++) {I=I+analogRead(PIN_BATTint_Sense);J=J+analogRead(PIN_BATText_Sense);K=K+analogRead(PIN_SOLAR_Sense); }// Durchschnittsspannung BattInt_Voltage=I/20.0;BattExt_Voltage=J/20.0;PV_Voltage=K/20.0;BattInt_Voltage=maxADC_Voltage*BattInt_Voltage/1023.0;BattExt_Voltage=maxADC_Voltage*BattExt_Voltage/1023.0/1023.0; ////////// Anzeige und Steuerung //////////////void Context_Control(void){ if(ds==0) ​​{show_menu();} if(ds==1 &&dp ==0) {show_info(); delay(100);} //LcdClear();Get_ADCVal();}///////////////////////Öffnet das 1. Untermenü ////// ////////////////////// if(ds==1 &&dp ==1) { level=1; dp=0; while(level==1) { int temp=ds; LcdClear(); show_load_ctrl();delay(250); if (dp==0){ if(ds!=temp){Load_Auto_Enable=0;digitalWrite(PIN_LOAD,LOW);}} if (dp==1){if(ds!=temp){Load_Auto_Enable=0; digitalWrite(PIN_LOAD,HIGH);}} if (dp==2){ if(ds!=temp){Load_Auto_Enable=1;}} if (dp==3){show_load_ctrl();delay(250);level=0;dp=0;ds=0;} } }//////////////////////Zweites Untermenü aufrufen /////////// ///////////////////if(ds==1 &&dp ==2) { level=2; dp=0; while(level==2) { int temp=ds; show_inv_ctrl();delay(250); LcdClear(); if (dp==0){ if(ds!=temp){Timer1_Init();}} if (dp==1){ if(ds!=temp){Timer1_DeInit();}} if (dp==2 ){ if(ds!=temp){Timer1_DeInit();digitalWrite(PIN_INVP,1);digitalWrite(PIN_INVN,1);}} if (dp==3){show_inv_ctrl();delay(250);level=0;dp=0;ds=0;} } } ///////////////////////////////////// /////////////////// //////////////// Ruft das dritte Untermenü auf /////////// //////////////////if(ds==1 &&dp ==3) { level=3; dp=0; while(level==3) { int temp=ds; LcdClear(); show_led_ctrl();delay(250); if (dp==0){blinker=0;if(ds!=temp) {if(y<=255){y=y+15;analogWrite(PIN_LAMP,y);}}} if (dp==1 ){blinker=0;if(ds!=temp) {if(y>=0){y=y-15;analogWrite(PIN_LAMP,y);}}} if (dp==2){if(ds! =temp) {Blinker^=1;analogWrite(PIN_LAMP,127);delay(250);analogWrite(PIN_LAMP,0);}} if (dp==3){show_led_ctrl();delay(250);level=0;dp=0;ds=0;} } } ///////////////////////////////////// /////////////////// // {show_inv_ctrl();}// {show_led_ctrl();}//}if(blinker==1){analogWrite(PIN_LAMP, 0);}Verzögerung(250);if(Blinker==1){analogWrite(PIN_LAMP,127);}}//////////////////////// /// Menütext, der auf dem Display des Nokia 5110 angezeigt werden soll ///////////////////void show_menu(void){LcdXY(0,dp);LcdString("->" );LcdXY(15,0);LcdString("Sys Info");LcdXY(15,1);LcdString("DC Load+");LcdXY(15,2);LcdString("AC Load~");LcdXY( 15,3);LcdString("LED-Lampe");}void show_info(void){ LcdXY(0,0);LcdString("Bat_I=");LcdNumtoString(BattInt_Voltage);LcdString("v");LcdXY(0 ,1);LcdString("Bat_E=");LcdNumtoString(BattExt_Voltage);LcdString("v");LcdXY(0,2);LcdString("Sol_ P=");LcdNumtoString(PV_Voltage);LcdString("v");LcdXY(0,3);if(BattExt_Voltage>8.0){LcdString("Batt Conn OK");}else{LcdString("Batt verbinden");}if (PV_Voltage> 10.5 &&cdc_level!=3 &&cdc_level!=0){LcdString("Charging:ON ");}else{LcdString("Charging:OFF");}if (TCNT1>=45535 ){LcdString ("Inverter:ON");}else{LcdString("Inverter:OFF");}}void show_load_ctrl(void){LcdXY(0,dp);LcdString("->");LcdXY(15,0); LcdString("Load Off");LcdXY(15,1);LcdString("Load On");LcdXY(15,2);LcdString("Load Auto");LcdXY(15,3);LcdString("Return" );LcdXY(0,4);LcdString("Muss Connect");LcdString("12V DC Load");}void show_inv_ctrl(void){LcdXY(0,dp);LcdString("->");LcdXY( 15,0);LcdString("AC Inv On");LcdXY(15,1);LcdString("AC Inv Off");LcdXY(15,2);LcdString("2XDC Load");LcdXY(15,3 );LcdString("Return");LcdXY(0,4);LcdString("2XDC Load,NO");LcdXY(0,5);LcdString("TRANSFORMER!");}void show_led_ctrl(void){LcdXY( 0,dp);LcdString("->");LcdXY(15,0);LcdString("LED ++");LcdXY(15,1);LcdString("LED --");LcdXY(15,2 );LcdString("LED Blk" );LcdXY(15,3);LcdString("Return");LcdXY(0,4);LcdString("LED DEAKTIVIERT");LcdXY(0,5);LcdString("When INVR On");}// //////////// Interrupt-ISRs //////////////void SW1(){dp++;if(dp>
3){dp=0;}}void SW2 (){ds^=1;} ISR (TIMER1_OVF_vect) { noInterrupts(); TCNT1 =45535; // TCNT1 =25535; Zyklus^=1; if(Zyklus==0); { digitalWrite (PIN_INVP, HOCH); VerzögerungMikrosekunden(1); // Totzone digitalWrite (PIN_INVN,LOW); VerzögerungMikrosekunden(1); aufrechtzuerhalten. Wenn (Zyklus ==1) { DigitalWrite (PIN_INVP, LOW); VerzögerungMikrosekunden(1); // Totzone digitalWrite (PIN_INVN,HIGH); VerzögerungMikrosekunden(1); } Interrupts(); }/////////////Nokia 5110 Funktionen //////////statisches konstantes Byte ASCII[][5] ={{0x00, 0x00, 0x00, 0x00, 0x00} / / 20,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 ",{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 # ,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &,{ 0x00, 0x05, 0x03, 0x00, 0x00} // 27 ',{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 ),{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6,{0x01, 0x71, 0x09, 0x05, 0x03 } // 37 7,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9,{0x00, 0x36, 0x36, 0x00, 0x00} / / 3a :,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b;,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c <,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d =,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e>,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @, {0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C,{0x7f , 0x41, 0x41, 0x22, 0x1c} // 44 D,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F,{0x3e, 0x41 , 0x49, 0x49, 0x7a} // 47 G,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I,{0x20, 0x40, 0x41 , 0x3f, 0x01} // 4a J,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L,{0x7f, 0x02, 0x0c, 0x02 , 0x7f} // 4d M,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O,{0x7f, 0x09, 0x09, 0x09, 0x06 } // 50 P, {0x3e, 0x41, 0x 51, 0x21, 0x5e} // 51 Q,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c ,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ],{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `, {0x20, 0x54, 0x54, 0x54, 0x78} // 61 a,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c,{0x38 , 0x44, 0x44, 0x48, 0x7f} // 64 d,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f,{0x0c, 0x52 , 0x52, 0x52, 0x3e} // 67 g,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i,{0x20, 0x40, 0x44 , 0x3d, 0x00} // 6a j,{0 x7f, 0x10, 0x28, 0x44, 0x00} // 6b k,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d },{0x10, 0x08, 0x08, 0x10, 0x08} // 7e ,{0x78, 0x46, 0x41, 0x46, 0x78} // 7f };void LcdCharacter(char character){ LcdWrite(LCD_D, 0x00); for (int index =0; index <5; index++) { LcdWrite(LCD_D, ASCII[character - 0x20][index]); } LcdWrite(LCD_D, 0x00);}void LcdClear(void){ for (int index =0; index  0) {digitalWrite(PIN_LOAD,HIGH);} if (Load_Auto_Enable ==1 &&PV_Voltage>10.5 || cdc_level==0) {digitalWrite(PIN_LOAD,LOW);} }void Charging_Control (void){// BattExt_Voltage Level 14.3 Laden aus, 13.5 oder niedriger Laden an, 10.8 Laden aus, 12.5 Laden an // diese nächste Bedingung verhindert die Ladeversuche während der Nacht % Nacht PV ist 0 Volt! if (PV_Voltage> 10.5 &&BattExt_Voltage>8.0) {if (BattExt_Voltage <=12.5) { analogWrite (PIN_BATTPWM,255); cdc_level =0; } if (BattExt_Voltage> 12,5 &&BattExt_Voltage <=12,9) { analogWrite (PIN_BATTPWM, 200); cdc_level =1; } if (BattExt_Voltage> 12.9 &&BattExt_Voltage <=13.3) { analogWrite (PIN_BATTPWM,160); cdc_level =1; } if (BattExt_Voltage> 13.3 &&BattExt_Voltage <=13.6) { analogWrite (PIN_BATTPWM,120); cdc_level =2; } if (BattExt_Voltage> 13,6 &&BattExt_Voltage <=13,9 &&cdc_level ==2) { analogWrite (PIN_BATTPWM,80); cdc_level =2; } if (BattExt_Voltage> 13.9 &&BattExt_Voltage <=14.3 &&cdc_level ==2) { analogWrite(PIN_BATTPWM,40); cdc_level =2; }// Over Voltage Lockout, while cdc_level is 3, NO Charging ! Charging Resumes when cdc is 2 which is below 13.5 v if (BattExt_Voltage> 14.3 ) { analogWrite(PIN_BATTPWM,0); cdc_level =3; } }else {analogWrite(PIN_BATTPWM,0);cdc_level =3;}}/// Under voltage Lockoutvoid Discharging_Control (void){if (BattExt_Voltage <=10.8) { cdc_level =0; {digitalWrite(PIN_LOAD,LOW);} Timer1_DeInit(); }}/////////////// Timer 2 Functions //////////////// This portion of the code is written in AVR stylevoid Timer1_Init(void){ noInterrupts(); // disable all interrupts pinMode(PIN_INVP,OUTPUT); pinMode(PIN_INVN,OUTPUT); TCCR1A =0; TCCR1B =0; /* ========================================50 Hz AC means 20 ms Wave which is formed by 2, 10 ms Pulses from PIN_INVP and PIN_INVN pins so both this pin should toggle at 100 Hz ! Now 100 Hz =.01 sec Arduino System Clock 16 MHz =16000000 cycle in 0,01 sec we have 160000 cycles using prescaler of 8 (CS11) makes timer count 160000/8 =20000 timer ticks Since the timer 2 is 16 bit Up Counter and it Overflows at 65635 value we need to start counting from 65535-20000 =from 45535 value upto 65535 thus TCNT1 starts at 45535 ..then tick tick tick ... 46000 .... 50000 .............. 65536 !!! Boom Timer Over Flow Interrupt and toggle the Inverter driving pins in ISR and start counting from 45535 Again !!! (This happens in the Background) ========================================*/ TCNT1 =45535; //TCNT1 =25535; TCCR1B |=(1 < 
Full CodeC/C++ 
 Code Organized &Readable
No preview (download only).
 
BootloadersC/C++ 
 
Keine Vorschau (nur Download).
 

Schaltpläne