Industriële fabricage
Industrieel internet der dingen | Industriële materialen | Onderhoud en reparatie van apparatuur | Industriële programmering |
home  MfgRobots >> Industriële fabricage >  >> Manufacturing Technology >> Productieproces

Geïntegreerde Solar ChargeController, Inverter, PowerBank, Lamp

Componenten en benodigdheden

Microchip-technologie Atmega8
× 1
Buck-converter
× 1
SparkFun LED - 3W aluminium print (5 stuks, warm wit /td>
× 1
Nokia 5110-scherm
× 1
SparkFun koellichaam
× 1
SparkFun N-Channel MOSFET
× 4
SparkFun P-kanaal Mosfet
× 1
Zonnepaneel 40 watt of minder voor 12 V-systeem
× 1
SparkFun lithium-ionbatterij - 18650 cel
× 1
DC-DC 0,9 ​​V-5 V naar USB-module 5 V DC Boost Step-up voeding
× 1
Transistor-NPN voor algemeen gebruik
× 1
12-0-12/220 Midden getapte transformator
× 1
1N4007 – Diode voor hoge spanning, hoge stroomsterkte
× 1
Mannelijke kop 36 Positie 1 rij - lang (0,1")
× 1
Schuifschakelaar
× 1
SparkFun Drukknopschakelaar 12 mm
× 1
Arduino Proto Shield
× 1
Strip/Vero/Proto Board 8x11 cm
× 1
Arduino UNO
× 1
Arduino Nano R3
× 1
Arduino Mega 2560
× 1
Lage FW-spanning Schottky-diode 5822
× 1
Condensator 10 µF
× 1
Condensator 100 nF
× 1

Benodigde gereedschappen en machines

Soldeerbout (algemeen)
Boormotor
Hot lijmpistool (algemeen)

Apps en online services

Arduino IDE
AutoDesk 123D

Over dit project

Over dit project

Ik heb een paar zonnepanelen, 12 Volt accu's, transformatoren en nog een paar dingen die nog een tijdje liggen te smeken om er goed gebruik van te maken. Dus de geboorte van dit apparaat - complete kleine PV-oplossing op een enkel bord. Laten we eerst bekijken wat wat doet, zullen we?

  • Een laadregelaar is een apparaat dat het opladen van DC-opslag/accu van een fotovoltaïsch zonnepaneel en het ontladen van de accu door de belasting regelt om de levensduur van de accu te verlengen.
  • Een omvormer is een apparaat dat DC-vorm van elektriciteit omzet in AC-vorm om AC-belastingen te laten werken.
  • Power Bank levert 5V DC-voeding via de USB-poort aan gadgets/mobiele apparaten voor draagbaar opladen of off-grid opladen.
  • Noodlamp is een superheldere LED-lichtbron die kan worden gebruikt tijdens stroomuitval, kamperen, buitenactiviteiten na zonsondergang.

Dit apparaat dat ik heb gemaakt heeft al deze functies, de laatste twee functies worden onafhankelijk ondersteund door de ingebouwde Li-ion batterij. Met een zonnepaneel (tot 100 Watt), een 12 Volt loodaccu en een transformator kunnen alle mogelijkheden worden benut.

Proto-versie op Uno

De eerste versie is ontwikkeld op Uno Board met minimale hardware en minimale opties. Het Nokia-display werd direct gemonteerd en er werd een MOSFET-schild ontwikkeld om het opladen/ontladen van de batterij te ondersteunen. Er is geen menubediening, geen omvormer, geen PWM-oplading en coole functies! Gewoon aan / uit opladen en batterij- en paneelspanningsniveaus weergeven. Doet het werk maar kreeg geen charme!

Volledige versie op Protoboard

Toen ontwikkelde ik deze nieuwe met de volgende functies:

  • PWM Solar Laadregelaar tot 100 Watt Paneel
  • Square wave mini 60 Watt omvormer
  • Tot drie 12 volt DC-belastingsregelingen
  • Primaire DC-belasting ondersteunt automatische aan/uit-functies
  • Een onafhankelijke USB-powerbank
  • Buck-regelaarmodule
  • Nood-LED-lamp aan boord met knipper- en helderheidsregeling

2-knop/schakelaar gestuurd scroll- en selectiemenu voor gebruikersbediening, weergave van opties en statusinformatie op het Nokia 5110-display. Heel cool! Achterkant is Hot-Glue Insulated voor bescherming tegen kortsluiting tegen metalen voorwerpen!

Er zijn nog een paar handige functies, zoals een aan/uit-schakelaar voor de achtergrondverlichting van het scherm, waardoor de kosten worden gescheiden voor onafhankelijke bediening door de interne batterij uit te schakelen.

Toegang tot het menu op het Nokia 5110-scherm met gebruikersknop wordt hier weergegeven:

Laten we wat technische dingen leren!

Laadregelaar kan van het type Aan/Uit, PWM of MPPT zijn. Aan/Uit is de eenvoudigste vorm (mijn versie 1 - afbeelding hierboven) van een controller die de laadstroom niet verlaagt als de accuspanning de volledige laadspanning nadert.

Terwijl PWM de laadstroom geleidelijk verlaagt naarmate de batterij vol raakt. PWM-controller heeft de volgende voordelen:

  • Helpt bij het herstellen van verloren batterijcapaciteit en het desulfateren van een batterij
  • Vergroot het vermogen van de batterij om meer lading te accepteren
  • Houd een hoge gemiddelde batterijcapaciteit tot 95%
  • Egaliseer drijvende batterijcellen, zodat interne cellen hetzelfde potentieel kunnen bereiken
  • Verminder de opwarming van de batterij en vergassing om zo elektrolytverlies te voorkomen
  • Vertraagt ​​veroudering en verlengt de levensduur van het systeem

Maar PWM kan het grootste deel van het elektrische vermogen niet uit PV-zonnepanelen halen, omdat het het paneel sleept om in de buurt van batterijspanning te werken. MPPT is de oplossing voor dit probleem, dat in feite een DC naar DC instelbare buck-boost-converter is, die het grootste deel van de zonne-energie kan omzetten in vergelijking met een PWM-controller.

Omvormers kunnen blokgolf, gemodificeerde sinusgolf en zuivere sinusgolf zijn. De vierkante golfomvormer heeft een heel eenvoudig ontwerp en is goed genoeg voor kleine DC-belastingen zoals AC-lampen, CFL-lampen, tafelventilatoren, soldeerbouten, maar wordt niet aanbevolen voor inductieve motoren, delicate apparatuur/voedingen vanwege harmonische vervorming.

Gemodificeerde sinusgolf is een soort vertraagde sinusgolf die is gemaakt van vierkante golven, beter dan gewone vierkante golfomvormers. Sinusomvormers zijn het beste voor alle soorten belasting, maar complex om hardware te ontwerpen, moeilijk software-algoritme om te bedienen en duur om te maken.

Een buck-regelaar is een step-down DC-DC-converter, hier heb ik een buck-module gebruikt om de 4,2 V Li-ion-batterij op te laden die de controller van stroom voorziet (Arduino + display), onafhankelijke USB-powerbank, ingebouwde LED-lamp.

Nu is USB-powerbank in feite een DC-DC-boost die een reeks spanningen van minder dan 5 (zoals 3,3 tot 4,2 volt) kan omzetten van een Li-ion- of LiPo-batterij naar 5 volt, de USB-busspanning die mobiele apparaten kan opladen .

Het heeft ook een buck-converter om die batterij op te laden. In mijn project neemt de buck-module wat sap van het paneel om de interne (aan boord) batterij op te laden.

Werking van de hardware

Voordat we ingaan op details, bekijk deze afbeelding van alles wat rond het apparaat is aangesloten:

Het systeem heeft verschillende hardware voor verschillende doeleinden. Het brein is natuurlijk de AVR Atmega8A-microcontroller (kan worden gebruikt Atmega328P met kleine wijzigingen, hieronder besproken) die is geprogrammeerd in Arduino.

Een nieuwe Atmega8A wordt gebrand met Arduino Optiboot8 bootloader, je kunt een Bootloaded Arduino Mini/Atmega328 kopen om het gedoe te vermijden.

De controller, het display, de LED-lamp en de powerbank worden gevoed door een ingebouwde Li-ion-batterij. Twee kortstondige aanraakknoppen zijn voor toegang tot het menu op het display, waarmee de gebruiker verschillende functies van het apparaat kan bedienen. De schakelaars zijn hardwarematig gedebounced door middel van afvlakcondensatoren die parallel zijn geschakeld.

Met een schuifschakelaar kunt u het apparaat naar behoefte in-/uitschakelen.

De zonne-oplaadfunctie wordt uitgevoerd door een P-MOSFET aangedreven door een 2N2222-transistor-gebaseerd stuurcircuit dat wordt bestuurd via PWM van een microcontroller. De PWM wordt geregeld op basis van het externe batterijspanningsniveau. Stroom van zonnepanelen vloeit via P-MOSFET naar de loodzuuraccu. Wanneer de batterij volledig is opgeladen, wordt de MOSFET uitgeschakeld vanaf de microcontroller. Nadat het opladen is uitgeschakeld, begint de accuspanning geleidelijk te dalen, wanneer deze 13,6 volt bereikt, wordt het opladen weer hervat met een lage inschakelduur om het float-laden te behouden.

De 12 Volt DC-belasting wordt geregeld via een N-MOSFET door de Gate-pin vanaf de Microcontroller te bedienen.

De on-board LED LAMP wordt ook aangedreven door een NMOS. De Gate van deze MOSFET is PWM-gestuurd voor het aanpassen van de helderheid van de LED.

Het inverterblok bestaat uit 2 N-MOSFET's die afwisselend aan/uit worden geschakeld om AC te simuleren. Door een externe centraal getapte transformator toe te voegen, kan een blokgolf AC-voeding worden gerealiseerd.

De volgende afbeelding legt de actie van de omvormer uit:

Door stroom door de middenaftakking van de spoel van een step-up transformator in tegengestelde richting te laten stromen, of door MOSFET's te gebruiken, kan een secundaire wisselspanning worden gecreëerd. Dit gebeurt omdat wanneer de bovenste MOSFET is ingeschakeld en de onderste MOSFET is uitgeschakeld, de stroom naar boven vloeit. Maar wanneer de bovenste MOSFET is uitgeschakeld en de onderste MOSFET is ingeschakeld, stroomt de stroom naar beneden.

Beide MOSFET's moeten worden geschakeld met tweemaal de frequentie van AC. Controleer de volgende afbeelding om het te begrijpen:

Om 50 Hz AC te creëren, wordt een alternerende Square Wave toegepast op de lage kant van de 12-0-12V/220V centraal getapte transformator. 50 Hz betekent 20 ms tijd voor elke golf.

Dat is de reden waarom 20 ms/2 =10 ms of 100 keer de poortsignalen omschakelen die worden toegepast op de MOSFET's die de transformator aansturen (inverter-MOSFET's).

Waarschuwing!!! :AC-spanning is dodelijk voor de mens, kan de dood/verwonding veroorzaken! Raak de HV-zijde van de transformator nooit met blote hand aan!

Als de inverterfunctie niet wordt gebruikt, maakt de 2XDC Load-optie het mogelijk om nog twee 12 volt DC-belastingen op de inverterterminal te gebruiken.

Magie van de software

Er worden twee sets code geleverd, één is volledige code in een enkele Arduino-tab, een andere is code met tabbladen volgens afzonderlijke functies.

Ik heb een groep taken gegeneraliseerd in een enkele functie.

Bijvoorbeeld:

Get_ADCVal() meet de spanning van het paneel, de interne batterij en de externe batterij, neemt 20 monsters, neemt het gemiddelde van die waarden en werkt de informatie over de variabele houdspanning bij.

Context_Control() zal de gebruikersinteractie, actiecontrole, info-update op weergavegerelateerde activiteiten uitvoeren.

Charging_Control() , Discharge_Control(), Load_Control() zijn achtergrondfuncties die fungeren als CLOSE LOOP voor het systeem, het batterijspanningsniveau bewaken, de Auto Load-functie regelen, de overlading/diepe ontladingsbeveiliging regelen, enz.

Gebruikersinvoer wordt verzameld via door onderbrekingen aangedreven kortstondige drukschakelaars. Wanneer deze schakelaars worden ingedrukt, worden INT0/INT1 gerelateerde ISR uitgevoerd. Twee vluchtige variabele dp en ds veranderingen. Nog een derde variabele niveau samen met dp (display pointer ->) en ds (display content selector) kan de gebruiker door menu/submenu gaan en indien nodig actie ondernemen.

16 bit TImer1 van AVR is geconfigureerd om Timer Overflow Interrupt om de 10 ms te genereren en schakelt PIN_INVP en PIN_INVN om wanneer de inverterfunctie is ingeschakeld.

Alle Lcd_....() functies hebben iets te maken met display control .

Atmega8A vs Atmega328P (Uno)

Het systeem kan eenvoudig worden geüpgraded om te werken met Atmega328P/Uno door de volgende wijzigingen in de code aan te brengen. Zoek en vervang

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

In het hardwaregedeelte moet je een weerstand van 8,2K gebruiken in plaats van 22 K om het paneel te verkleinen, batterijspanningen tot ADC-meetbereik.

Actievideo's

Ik lees meestal niet alleen woorden over een project, in plaats daarvan ga ik eerst voor de video. Als je op mij lijkt, geniet dan van de video's:

Bereik van verbetering

Ik had geen Flash Space meer in Atmega8A. Kan enkele kritieke functies niet toevoegen, zoals:

  • Softwaregestuurde beveiliging tegen overbelasting/kortsluiting
  • Enkele grafische pictogrammen en een logo
  • Meting van energie en loggen
  • Inschatting en alarm voor back-uptijd
  • Oplaadoptie voor laptop
  • Ondersteuning voor 6 Volt-systeem
  • Bluetooth-laadregeling
  • Op timer gebaseerde belastingsregeling
  • Een RTC-klok voor meer coole functies
  • IoT-verbonden oplossing

Als je plannen hebt om zoiets te maken, vergeet dan niet om enkele van deze functies toe te voegen!

Atmega328P(Uno) of Arduino Mega is misschien een betere kandidaat om al deze opties op te nemen.

Hoe dan ook, het doet zijn werk, ik ben er blij mee.

Aanvullende bronnen

  • Download Arduino 1. 0. 6 met ondersteuning voor Atmega8-kaarten
  • Open Arduino.exe , ga naar Extra> Bord> Optiboot8
  • Brand bootloader met deze methode
  • Code compileren en uploaden

Code

  • Enkelvoudige Tab-code
  • Volledige code
  • Bootloaders
Enkele tabcode 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 load#define PIN_LAMP 10 // WIT LED LICHT #define PIN_BATTPWM 11 // Stuurt PMOS aan voor Ext BAtt-oplading #define PIN_BATTint_Sense A2#define PIN_SOLAR_Sense A0#define PIN_BATText_Sense A3#define ADC_VREF 2.695 // interne ref-spanning, ongeveer 1.11V voor Arduino Uno aka Atmega328P, geeft mya Atmega328P! definieer ADCVDIV_R1 22 // 22 K spanningsdeler onderste weerstand #define ADCVDIV_R2 175 // 175 K spanningsdeler bovenste weerstand//const uint8_t skulljoke[] PROGMEM ={2,};// PIN 2 &3 GEBRUIKT ALS INTERRUPT SWITCH// PIN 0 &1 ALS PROGRAMMERING// 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;vluchtig int y=0;vluchtig uint8_t dp =0;vluchtig uint8_t ds =0; uint8_t cdc_level =0;//int i;void setup(void){ LcdInitialise(); LcdClear(); LcdString("*ARDUBOY PV*"); LcdString(" CONTROLLER,"); LcdString("AC-INVERTER,"); LcdString("POWER BANK,"); LcdString("LAMP DING!!"); vertraging (3000); analogeReferentie (INTERN); maxADC_Voltage=(ADC_VREF/ADCVDIV_R1)*(ADCVDIV_R1+ADCVDIV_R2); pinMode (PIN_LOAD, UITGANG); digitalWrite (PIN_LOAD, LAAG); pinMode (2, INPUT_PULLUP); attachInterrupt (0, SW1, FALLING);// Interrupt voor Swithc 1 pinMode (3, INPUT_PULLUP); attachInterrupt(1, SW2, FALLING);// Interrupt voor 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); }// gemiddelde spanning 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; ////////// Weergave en bediening //////////////void Context_Control(void){ if(ds==0) ​​{show_menu();} if(ds==1 &&dp ==0) {show_info(); delay(100);} //LcdClear();Get_ADCVal();}/////////////////////// Gaat naar 1e submenu////// ////////////////////// if(ds==1 &&dp ==1) { level=1; dp=0; while(niveau==1) { int temp=ds; LcdClear(); show_load_ctrl();vertraging(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;} } }//////////////////////Ga naar 2e submenu/////////// ///////////////////if(ds==1 &&dp ==2) { level=2; dp=0; while(niveau==2) { int temp=ds; show_inv_ctrl();vertraging(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;} } } ////////////////////////////////////// /////////////////// ////////////////Ga naar 3e submenu/////////// //////////////////if(ds==1 &&dp ==3) { level=3; dp=0; while(niveau==3) {int temp=ds; LcdClear(); show_led_ctrl();vertraging(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);}delay(250);if(blinker==1){analogWrite(PIN_LAMP,127);}}//////////////////////// /// Menutekst die wordt weergegeven op het scherm van de Nokia 5110 ///////////////////void show_menu(void){LcdXY(0,dp);LcdString("->" );LcdXY(15,0);LcdString("Sys Info");LcdXY(15,1);LcdString("DC Load+");LcdXY(15,2);LcdString("AC Load~");LcdXY( 15,3);LcdString("LED-lamp");}void show_info(void){ LcdXY(0,0);LcdString("Bat_I=");LcdNumtoString(BattInt_Voltage);LcdString("v");LcdXY(0 ,1);LcdString("Bat_E=");LcdNumtoString(BattExt_Voltage);LcdString("v");LcdXY(0,2);LcdString("Sol_ P=");LcdNumtoString(PV_Voltage);LcdString("v");LcdXY(0,3);if(BattExt_Voltage>8.0){LcdString("Batt Conn OK");}else{LcdString("Connect Batt");}if (PV_Voltage> 10.5 &&cdc_level!=3 &&cdc_level!=0){LcdString("Charging:ON ");}else{LcdString("Charging:OFF");}if (TCNT1>=45535){LcdString ("Omvormer:AAN");}else{LcdString("Omvormer:UIT");}}void show_load_ctrl(void){LcdXY(0,dp);LcdString("->");LcdXY(15,0); LcdString("Laden uit");LcdXY(15,1);LcdString("Laden aan");LcdXY(15,2);LcdString("Automatisch laden");LcdXY(15,3);LcdString("Return" );LcdXY(0,4);LcdString("Moet verbinden");LcdString("12V DC Load");}void show_inv_ctrl(void){LcdXY(0,dp);LcdString("->");LcdXY( 15,0);LcdString("AC Inv Aan");LcdXY(15,1);LcdString("AC Inv Uit");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 Zwart" );LcdXY(15,3);LcdString("Return");LcdXY(0,4);LcdString("LED UIT");LcdXY(0,5);LcdString("Als INVR aan");}// //////////// ISR's onderbreken //////////////void SW1(){dp++;if(dp>
3){dp=0;} }void SW2 (){ds^=1;} ISR(TIMER1_OVF_vect) { noInterrupts(); TCNT1 =45535; // TCNT1 =25535; cyclus^=1; if(cyclus==0); { digitalWrite (PIN_INVP, HOOG); vertragingMicroseconden(1); // dode band digitalWrite (PIN_INVN, LOW); vertragingMicroseconden(1); } if(cycle==1) {digitalWrite(PIN_INVP,LOW); vertragingMicroseconden(1); // dode band digitalWrite (PIN_INVN, HOOG); vertragingMicroseconden(1); } onderbreekt(); }/////////////Nokia 5110 Functies //////////static const 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 j,{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-teken){ LcdWrite(LCD_D, 0x00); for (int index =0; index <5; index++) { LcdWrite(LCD_D, ASCII[karakter - 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 Opladen uit, 13.5 of lager Opladen aan, 10.8 Load uit, 12.5 Load aan // deze volgende toestand voorkomt de pogingen om 's nachts op te laden % nacht PV is 0 volt !if (PV_Voltage> 10,5 &&BattExt_Voltage>8,0){if (BattExt_Voltage <=12,5) { analogWrite(PIN_BATTPWM,255); cdc_niveau =0; } if (BattExt_Voltage> 12.5 &&BattExt_Voltage <=12.9) { analogWrite(PIN_BATTPWM,200); cdc_niveau =1; } if (BattExt_Voltage> 12.9 &&BattExt_Voltage <=13.3) { analogWrite (PIN_BATTPWM,160); cdc_niveau =1; } if (BattExt_Voltage> 13.3 &&BattExt_Voltage <=13.6) { analogWrite(PIN_BATTPWM,120); cdc_niveau =2; } if (BattExt_Voltage> 13.6 &&BattExt_Voltage <=13.9 &&cdc_level ==2) { analogWrite(PIN_BATTPWM,80); cdc_niveau =2; } if (BattExt_Voltage> 13,9 &&BattExt_Voltage <=14.3 &&cdc_level ==2) { analogWrite(PIN_BATTPWM,40); cdc_niveau =2; }// Overspanningsvergrendeling, terwijl cdc_level 3 is, GEEN opladen! Opladen wordt hervat wanneer cdc 2 is, wat lager is dan 13,5 v als (BattExt_Voltage> 14,3) {analogeWrite(PIN_BATTPWM,0); cdc_niveau =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++
Geen voorbeeld (alleen downloaden).

Schema's


Productieproces

  1. Wat is een zonne-omvormer en hoe werkt het?
  2. Halogeenlamp
  3. Lavalamp
  4. Zonne-verwarmingssysteem
  5. Geïntegreerd circuit
  6. Zonnecel
  7. Slim verkeerslicht
  8. Arduino-gamecontroller
  9. Cloud-kostuum
  10. Solar Tracker V2.0
  11. Zonne-energie begrijpen