Controlador de carga solar integrado, inversor, PowerBank, lâmpada
Componentes e suprimentos
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 4 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
 |
| × | 1 | |||
| × | 1 | ||||
 |
| × | 1 | |||
 |
| × | 1 | |||
 |
| × | 1 | |||
 |
| × | 1 | |||
 |
| × | 1 | |||
| × | 1 | ||||
 |
| × | 1 | |||
 |
| × | 1 | |||
 |
| × | 1 | |||
| × | 1 | ||||
 |
| × | 1 | |||
 |
| × | 1 |
Ferramentas e máquinas necessárias
 |
| |||
| ||||
 |
|
Aplicativos e serviços online
| |
| |||
|
Sobre este projeto
Sobre este projeto
Eu tenho alguns painéis solares, baterias de 12 volts, transformadores e algumas outras coisas por aí por um tempo gritando em voz alta para fazer um bom uso deles. Assim, o nascimento deste dispositivo - solução fotovoltaica pequena completa em uma única placa. Vamos revisar primeiro o que faz o quê, certo?
- Um controlador de carga é um dispositivo que regula o carregamento do armazenamento / bateria DC de um painel solar fotovoltaico e o descarregamento da bateria pela carga para prolongar a vida útil da bateria.
- Um inversor é um dispositivo que converte a forma DC de eletricidade para a forma AC para operar cargas AC.
- O Power Bank fornece alimentação de 5 Vcc através da porta USB para gadgets / dispositivos móveis para carregamento portátil ou carregamento fora da rede.
- A lâmpada de emergência é uma fonte de luz LED super brilhante que pode ser usada durante quedas de energia, acampamentos, atividades ao ar livre após o anoitecer.
Este dispositivo que fiz tem todos esses recursos, os dois últimos recursos são suportados de forma independente pela bateria de íons de lítio on-board. Com um painel solar (até 100 Watt), uma bateria de chumbo-ácido de 12 volts e um transformador - todas as opções podem ser utilizadas.
Versão proto no Uno
A primeira versão foi desenvolvida em Uno Board com hardware mínimo e opções mínimas. O display da Nokia foi montado diretamente e um escudo MOSFETs foi desenvolvido para suportar o carregamento / descarregamento da bateria. Não há controle de menu, inversor, carregamento PWM e recursos interessantes! Apenas liga / desliga o carregamento e mostra os níveis de tensão da bateria e do painel. Faz o trabalho, mas não tem charme!
Versão completa em Protoboard
Então, desenvolvi este novo com os seguintes recursos:
- Controlador de carga solar PWM Painel de até 100 watts
- Mini inversor de onda quadrada de 60 watts
- Até três controles de carga de 12 Volts DC
- A carga DC primária suporta recursos de ativação / desativação automática
- Um USB Power Bank independente
- Módulo regulador Buck
- Lâmpada LED de emergência a bordo com controle de intermitência e brilho
2 botões / interruptores controlados rolar e selecionar menu baseado para controle do usuário, exibindo opções e informações de status no visor do Nokia 5110. Muito legal! O verso é isolado com cola quente para proteção contra curto-circuito contra objetos metálicos!
Existem alguns recursos mais convenientes, como botão liga / desliga para a luz de fundo da tela, separando o buck para operação independente desligando a bateria interna.
O acesso ao menu no visor do Nokia 5110 com o botão do usuário é mostrado aqui:
Vamos aprender algumas coisas técnicas!
O controlador de carga pode ser do tipo On / Off, PWM ou MPPT. Ligar / Desligar é a forma mais simples (minha versão 1 - foto acima) de controlador que não acelera a corrente de carga conforme a voltagem da bateria se aproxima da voltagem de carga total.
Onde o PWM diminui gradualmente a corrente de carga conforme a bateria fica cheia. O controlador PWM tem os seguintes benefícios:
- Ajuda a recuperar a capacidade perdida da bateria e a eliminar o sulfato de uma bateria
- Aumenta a capacidade da bateria de aceitar mais carga
- Manter uma alta capacidade média da bateria de até 95%
- Equalize o deslocamento das células da bateria, para que as células internas possam atingir o mesmo potencial
- Reduza o aquecimento e a gaseificação da bateria, evitando assim a perda de eletrólito
- Retarda o envelhecimento e prolonga a vida do sistema
Mas o PWM não consegue obter a maior parte da energia elétrica dos painéis solares fotovoltaicos, porque arrasta o painel para operar próximo à tensão da bateria. MPPT é a solução para este problema que basicamente é um conversor de buck-boost ajustável DC para DC, ele pode converter a maior parte da energia solar em comparação com o controlador PWM.
Os inversores podem ser do tipo onda quadrada, onda senoidal modificada e onda senoidal pura. O inversor de onda quadrada é muito simples em design e pequenas cargas CC boas o suficiente, como lâmpadas CA, lâmpadas CFL, ventiladores de mesa, ferros de solda, mas não é recomendado para motores indutivos, equipamentos delicados / fontes de alimentação devido à distorção harmônica.
A onda senoidal modificada é um tipo de onda senoidal retardada criada a partir de ondas quadradas, melhor do que os inversores de onda quadrada simples. Os inversores de onda senoidal são os melhores para todos os tipos de carga, mas hardware de design complexo, algoritmo de software difícil de operar e caro de fazer.
Um regulador de buck é um conversor DC-DC redutor, aqui eu usei um módulo de buck para carregar a bateria de íon de lítio de 4,2 V que alimenta o controlador (display Arduino +), banco de energia USB independente, lâmpada LED on-board.
Agora, o banco de energia USB é basicamente um reforço DC-DC que pode converter uma gama de tensões abaixo de 5 (como intervalo de 3,3 a 4,2 volts) de uma bateria de íon-lítio ou LiPo para 5 volts, que é a tensão do barramento USB que pode carregar dispositivos móveis .
Ele também tem um conversor de buck para carregar a bateria. No meu projeto, o módulo Buck pega um pouco do painel para carregar a bateria interna (a bordo).
Funcionamento do Hardware
Antes de entrar em detalhes, verifique esta imagem de tudo conectado ao redor do dispositivo:
O sistema possui vários hardwares para atender a diferentes propósitos. Claro que o cérebro é um microcontrolador AVR Atmega8A (pode ser usado Atmega328P com pequenas alterações, discutidas abaixo) que é programado em Arduino.
Um novo Atmega8A é queimado com o bootloader Arduino Optiboot8, você pode comprar um Arduino Mini / Atmega328 com boot para evitar complicações.
O controlador, a tela, a lâmpada LED e o banco de energia são alimentados por uma bateria de íons de lítio integrada. Dois botões de toque momentâneos são para acessar o menu no display, o que permite ao usuário operar diferentes funções do dispositivo. Os interruptores são de-bounce do hardware por meio de capacitores de suavização que são conectados em paralelo.
Um interruptor deslizante permite ligar / desligar o dispositivo conforme necessário.
A função de carregamento solar é realizada por um P-MOSFET acionado por um circuito de acionamento baseado em transistor 2N2222 que é controlado por meio de PWM do microcontrolador. O PWM é controlado com base no nível de tensão da bateria externa. A corrente dos painéis solares flui através do P-MOSFET para a bateria de chumbo-ácido. Quando a bateria está totalmente carregada, o MOSFET é desligado do microcontrolador. Depois que o carregamento é desligado, a tensão da bateria começa a cair gradualmente, quando atinge 13,6 volts, o carregamento é reiniciado com ciclo de trabalho baixo para manter o carregamento flutuante.
A carga de 12 volts DC é controlada por meio de um N-MOSFET controlando seu pino de porta no microcontrolador.
O LED LAMP integrado também é acionado por NMOS. O Gate deste MOSFET é controlado por PWM para ajuste de brilho do LED.
O bloco do inversor é composto por 2 N-MOSFETs que são alternadamente ligados / desligados para simular CA. Adicionando um transformador com derivação central externa, a alimentação CA de onda quadrada pode ser realizada.
A figura a seguir explica a ação do inversor:
Ao permitir que a corrente flua através da derivação central de uma bobina do transformador elevador na direção oposta, alternativamente usando MOSFETs, a tensão CA no secundário pode ser criada. Isso acontece porque quando o MOSFET superior está ativado e o MOSFET inferior desativado, a corrente flui para cima. Mas quando o MOSFET superior está desligado e o MOSFET inferior está ligado, a corrente flui para baixo.
Ambos os MOSFETs devem ser alternados com o dobro da frequência de CA. Verifique a próxima imagem para entender:
Para criar 50 Hz AC, uma onda quadrada alternada é aplicada no lado de baixo do transformador com derivação central de 12-0-12V / 220V. 50 Hz significa tempo de 20 ms para cada onda.
É por isso que 20ms / 2 =10 ms ou 100 vezes Alterna os sinais de porta aplicados aos MOSFETs de acionamento do Transformer (MOSFETs do inversor).
Aviso !!! :A tensão CA é letal para humanos, pode causar morte / ferimentos! Nunca toque no lado HV do transformador com as mãos desprotegidas! Se a função do inversor não for usada, a opção 2XDC Load permite o uso de mais duas cargas de 12 volts DC no terminal do inversor.
Magia do Software
Dois conjuntos de código são fornecidos, um é o código completo em uma única guia do Arduino, o outro é o código com guias de acordo com funções separadas.
Eu generalizei o grupo de tarefas em uma única função.
Por exemplo :
Get_ADCVal () medirá as tensões do painel, da bateria interna e da bateria externa, tomará 20 amostras, fará a média desses valores e atualizará as informações de tensão de retenção variável.
Context_Control () fará as atividades relacionadas à Interação com o usuário, Controle de ação e Atualização de informações no display.
Charging_Control (), Discharging_Control (), Load_Control () são funções em segundo plano que atuam como CLOSE LOOP para o sistema, monitora o nível de tensão da bateria, controla a função de carga automática, controle de proteção de sobrecarga / descarga profunda etc.
As entradas do usuário são coletadas por meio de interruptores de pressão momentâneos acionados por interrupção. Quando essas chaves são pressionadas, o ISR relacionado a INT0 / INT1 é executado. Duas variáveis voláteis dp e ds alterar. Outro terceiro nível de variável junto com dp (indicador de exibição ->) e ds (seletor de conteúdo de exibição) permite que o usuário navegue pelo menu / submenu e execute a ação conforme necessário.
O TImer1 de 16 bits do AVR é configurado para gerar a interrupção de estouro do temporizador a cada 10 ms e inverte PIN_INVP e PIN_INVN quando a função do inversor está ligada.
Todas as funções do Lcd _.... () têm algo a ver com o controle do display.
Atmega8A vs Atmega328P (Uno)
O sistema pode ser facilmente atualizado para funcionar com Atmega328P / Uno, fazendo as seguintes alterações no código. Encontre e substitua
TIMSK com TIMSK1 # define ADC_VREF 2.69 com #define ADC_VREF 1.11 #define ADCVDIV_R1 22 com #define ADCVDIV_R1 8.2 Na parte de hardware, você precisa usar um resistor de 8,2 K em vez de 22 K para reduzir o painel, as tensões da bateria até a faixa de medição do ADC.
Vídeos de ação
Normalmente não leio apenas palavras sobre algum projeto, em vez disso, procuro primeiro o vídeo. Se você é como eu, aproveite os vídeos:
Escopo de melhoria
Fiquei sem espaço em Flash no Atmega8A. Não foi possível adicionar alguns recursos críticos como:
- Sobrecarga controlada por software / proteção contra curto-circuito
- Alguns ícones gráficos e um logotipo
- Medição de energia e extração de madeira
- Estimativa e alarme para tempo de backup
- Opção de carregamento de laptop
- Suporte para sistema de 6 volts
- Controle de carga do Bluetooth
- Controle de carga baseado em cronômetro
- Um relógio RTC para mais recursos interessantes
- Solução conectada à IoT
Se você tem planos de fazer algo assim, não se esqueça de adicionar alguns desses recursos!
Atmega328P (Uno) ou Arduino Mega pode ser um candidato melhor para incluir todas essas opções.
De qualquer forma, faz o trabalho, estou feliz com isso.
Recursos adicionais
- Baixe o Arduino 1. 0. 6 com suporte para placa Atmega8
- Abra Arduino.exe, vá para Ferramentas> Placa> Optiboot8
- Grave o bootloader usando este método
- Compilar e fazer upload do código
Código
- Código de guia única
- Código completo
- Bootloaders
Código de guia única 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 // LUZ DO LED BRANCO #define PIN_BATTPWM 11 // Direciona PMOS para Carregamento Ext BAtt #define PIN_BATTint_Sense A2 # define PIN_SOLAR_Sense A0 # define PIN_BATText_Sense A3 # define ADC_VREF 2.695 // tensão ref interna, em torno de 1.11 V para Arduino Uno # Atmega328P, aqui meu Atmega8A dá isso! define ADCVDIV_R1 22 // Resistor inferior do divisor de tensão 22 K # define ADCVDIV_R2 175 // Resistor superior do divisor de tensão 175 K // const uint8_t skulljoke [] PROGMEM ={2,}; // PINO 2 e 3 USADO COMO INTERRUPT SWITCH // PIN 0 &1 AS PROGRAMMING // 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; volátil int y =0; volátil uint8_t dp ciclo =0; volátil uint8_t ds =0; volátil uint8_t cdc_level =0; // int i; configuração de void (void) {LcdInitialise (); LcdClear (); LcdString ("* ARDUBOY PV *"); LcdString ("CONTROLADOR"); LcdString ("AC INVERTER,"); LcdString ("POWER BANK,"); LcdString ("COISA DA LÂMPADA !!"); atraso (3000); analogReference (INTERNAL); maxADC_Voltage =(ADC_VREF / ADCVDIV_R1) * (ADCVDIV_R1 + ADCVDIV_R2); pinMode (PIN_LOAD, OUTPUT); digitalWrite (PIN_LOAD, LOW); pinMode (2, INPUT_PULLUP); attachInterrupt (0, SW1, FALLING); // Interromper para Swithc 1 pinMode (3, INPUT_PULLUP); attachInterrupt (1, SW2, FALLING); // Interromper para 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); } // tensão média 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 =PV.023 / Voltage_Voltage * PV.023Voltagem_Voltagem * 1023.0} maxADC_Voltage * PV.023 / 1023.0} BattExt_Voltage =PVADC_Voltage_Voltage 1023.0} =maxADC_Voltage * 1023.0Volt_Voltagem =PVADC_Voltage * 1023.0} PVADC_Voltage =1023.0 / maxADC_Voltage_Voltage_Voltage / 1023.0; ////////// Display and Control ////////////// void Context_Control (void) {if (ds ==0) {show_menu ();} if (ds ==1 &&dp ==0) {show_info (); delay (100);} // LcdClear (); Get_ADCVal ();} ///////////////////////// Entra no primeiro submenu ////// //////////////////////// if (ds ==1 &&dp ==1) {nível =1; dp =0; enquanto (nível ==1) {int temp =ds; LcdClear (); show_load_ctrl (); atraso (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 (); atraso (250); nível =0; dp =0; ds =0;}}} ////////////////////// Entra no segundo submenu ///////////// ///////////////////// if (ds ==1 &&dp ==2) {level =2; dp =0; enquanto (nível ==2) {int temp =ds; show_inv_ctrl (); atraso (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 (); atraso (250); nível =0; dp =0; ds =0;}}} //////////////////////////////////////// /////////////////////// //////////////// Entra no 3º submenu ///////////// ////////////////// if (ds ==1 &&dp ==3) {level =3; dp =0; enquanto (nível ==3) {int temp =ds; LcdClear (); show_led_ctrl (); atraso (250); if (dp ==0) {pisca-pisca =0; if (ds! =temp) {if (y <=255) {y =y + 15; analogWrite (PIN_LAMP, y);}}} if (dp ==1 ) {pisca-pisca =0; if (ds! =temp) {if (y> =0) {y =y-15; analogWrite (PIN_LAMP, y);}}} if (dp ==2) {if (ds! =temp) {pisca-pisca ^ =1; analogWrite (PIN_LAMP, 127); atraso (250); analogWrite (PIN_LAMP, 0);}} if (dp ==3) {show_led_ctrl (); atraso (250); nível =0; dp =0; ds =0;}}} //////////////////////////////////////// ///////////////////// // {show_inv_ctrl ();} // {show_led_ctrl ();} //} if (blinker ==1) {analogWrite (PIN_LAMP, 0);} atraso (250); if (pisca-pisca ==1) {analogWrite (PIN_LAMP, 127);}} ////////////////////////// /// Menu Texto a ser mostrado no visor do 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 ("Lâmpada LED");} void show_info (vazio) {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 (" Conectar Batt ");}if (PV_Voltage> 10.5 &&cdc_level!=3 &&cdc_level!=0){LcdString("Charging:ON ");}else{LcdString("Charging:OFF");}if (TCNT1>=45535 ){LcdString ("Inverter:ON");}else{LcdString("Inverter:OFF");}}void show_load_ctrl(void){LcdXY(0,dp);LcdString("->");LcdXY(15,0); LcdString("Load Off");LcdXY(15,1);LcdString("Load On");LcdXY(15,2);LcdString("Load Auto");LcdXY(15,3);LcdString("Return" );LcdXY(0,4);LcdString("Must Connect");LcdString("12V DC Load");}void show_inv_ctrl(void){LcdXY(0,dp);LcdString("->");LcdXY( 15,0);LcdString("AC Inv On");LcdXY(15,1);LcdString("AC Inv Off");LcdXY(15,2);LcdString("2XDC Load");LcdXY(15,3 );LcdString("Return");LcdXY(0,4);LcdString("2XDC Load,NO");LcdXY(0,5);LcdString("TRANSFORMER!");}void show_led_ctrl(void){LcdXY( 0,dp);LcdString("->");LcdXY(15,0);LcdString("LED ++");LcdXY(15,1);LcdString("LED --");LcdXY(15,2 );LcdString("LED Blk" );LcdXY(15,3);LcdString("Return");LcdXY(0,4);LcdString("LED DISABLEs");LcdXY(0,5);LcdString("When INVR On");}////////////// Interrupt ISRs //////////////void SW1(){dp++;if(dp>
3){dp=0;} }void SW2(){ds^=1;} ISR(TIMER1_OVF_vect) { noInterrupts(); TCNT1 =45535; // TCNT1 =25535; cycle^=1; if(cycle==0); { digitalWrite(PIN_INVP,HIGH); delayMicroseconds(1); // dead band digitalWrite(PIN_INVN,LOW); delayMicroseconds(1); } if(cycle==1) { digitalWrite(PIN_INVP,LOW); delayMicroseconds(1); // dead band digitalWrite(PIN_INVN,HIGH); delayMicroseconds(1); } interrupts(); }/////////////Nokia 5110 Functions //////////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 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 Charging off, 13.5 or below Charging on, 10.8 Load off, 12.5 Load on // this next condition prevenst the attemps of charging during night % night PV is 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 &ReadableNo preview (download only).
BootloadersC/C++
Sem visualização (somente download).
Esquemas
Processo de manufatura