Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

Arduino - Carregador solar PV MPPT

Componentes e suprimentos

Arduino Nano R3
× 1
Indutor 100 uH
as classificações atuais devem corresponder à potência necessária.
× 1
Power MOSFET N-Channel
× 1
Adafruit LCD padrão - 16x2 branco em azul
× 1

Ferramentas e máquinas necessárias

Ferro de soldar (genérico)

Aplicativos e serviços online

Arduino IDE

Sobre este projeto




Existem muitos controladores de carga disponíveis no mercado, mas controladores de carga baratos comuns não são eficientes para uso com potência máxima de painéis solares. E os que são eficientes custam muito caro.

Portanto, decidi fazer meu próprio controlador de carga para ser eficiente e inteligente o suficiente para entender as necessidades da bateria e as condições solares. Ele executa as ações apropriadas para extrair o máximo de energia disponível da energia solar e colocá-la dentro da bateria de maneira muito eficiente.

Se você gosta de meus esforços, por favor, vote neste tutorial.





Etapa 1:O que é MPPT e por que precisamos dele?


Nossos painéis solares são burros e não são inteligentes o suficiente para entender as condições da bateria. Suponha que temos um painel solar de 12v / 100 watts e ele dará uma saída entre 18V-21V dependendo do fabricante, mas as baterias são classificadas para tensão nominal de 12v. Em condições de carga total, eles serão 13,6 V e 11,0 V na descarga total. Agora vamos assumir que nossas baterias estão carregando 13 V, os painéis estão dando 18 V, 5,5 A com 100% de eficiência de trabalho (não é possível ter 100%, mas vamos supor). Os controladores comuns têm um regulador de tensão PWM ckt que diminui a tensão para 13,6 sem qualquer ganho de corrente. Ele apenas fornece proteção contra sobrecarga e fuga de corrente para os painéis durante a noite.

Para evitar esse problema, usei o conversor smps buck. Este tipo de conversor tem eficiência acima de 90%. Até 90% são considerados pobres.

O segundo problema que temos é a produção não linear de painéis solares. Eles precisam ser operados em uma determinada tensão para colher a potência máxima disponível. Sua produção varia ao longo do dia.

Para resolver este problema, algoritmos MPPT são usados. MPPT (Maximum Power Point Tracking) como o nome sugere, este algoritmo rastreia a potência máxima disponível dos painéis e varia os parâmetros de saída para sustentar a condição.

Portanto, ao usar o MPPT nossos painéis estarão gerando a potência máxima disponível e o conversor de buck estará colocando essa carga de forma eficiente nas baterias.





Etapa 2:Como funciona o MPPT?


Não vou discutir isso em detalhes, então se você quiser entender, dê uma olhada neste link - O que é MPPT?

Neste projeto eu rastreei as características de entrada V-I e saída V-I, também. Multiplicando a entrada V-I e a saída V-I podemos obter a potência em watts.

Digamos que temos 17 V 5 A, ou seja, 17x5 =85 watts, a qualquer hora do dia. Ao mesmo tempo, nossa saída é de 13 V 6A, ou seja, 13x6 =78 Watt.

Agora o MPPT aumentará ou diminuirá a tensão de saída comparando com a alimentação de entrada / saída anterior.

Se a potência de entrada anterior era alta e a tensão de saída era menor do que a atual, a tensão de saída será reduzida novamente para voltar à potência alta. E se a tensão de saída for alta, a tensão atual será aumentada para o nível anterior. Assim, ele continua oscilando em torno do ponto de potência máxima. Essas oscilações são minimizadas por algoritmos MPPT eficientes.





Etapa 3:Implementando MPPT no Arduino


Este é o cérebro deste carregador. Abaixo está o código do Arduino para regular a saída e implementação do MPPT em um único bloco de código.
  // Iout =corrente de saída // Vout =tensão de saída // Vin =tensão de entrada // Pin =potência de entrada, Pin_previous =última potência de entrada // Vout_last =última tensão de saída, Vout_sense =voltagem de saída atual regulada (flutuar Iout, flutuar Vin, flutuar Vout) {
if ((Vout> Vout_max) || (Iout> Iout_max) || ((Pin> Pin_previous &&Vout_sense Vout_last ))) {if (duty_cycle> 0) {duty_cycle - =1; } analogWrite (buck_pin, duty_cycle); } else if ((Vout Pin_previous &&Vout_sense> Vout_last) || (Pin dever_ciclo + =1; } analogWrite (buck_pin, duty_cycle); } Pin_previous =Pin; Vin_last =Vin; Vout_last =Vout;}





Etapa 4:Conversor Buck


Usei o mosfet do canal N para fazer o conversor de buck. Normalmente as pessoas escolhem o mosfet do canal P para a comutação do lado alto e, se escolherem o mosfet do canal N para o mesmo propósito, será necessário um IC de driver ou ckt de inicialização.

Mas eu modifiquei o conversor buck ckt para ter uma troca de lado baixo usando o mosfet do canal N. Estou usando o canal N porque são de baixo custo, altas classificações de potência e menor dissipação de potência. Este projeto usa mosfet de nível lógico IRFz44n, para que possa ser acionado diretamente por um pino PWM do Arduino.

Para corrente de carga mais alta, deve-se usar um transistor para aplicar 10 V na porta para deixar o mosfet em saturação completamente e minimizar a dissipação de energia. Eu fiz o mesmo.

Como você pode ver no ckt acima, coloquei o mosfet na tensão -ve, usando + 12v do painel como aterramento. Esta configuração me permite usar um mosfet de canal N para conversor de buck com componentes mínimos.

Mas também tem algumas desvantagens. Como você tem ambos os lados - tensão separada, você não tem mais um aterramento de referência comum. Portanto, medir tensões é muito complicado.

Eu conectei o Arduino nos terminais de entrada solar, usando sua linha -Ve como aterramento para o Arduino. Podemos facilmente medir a tensão de entrada neste ponto usando um divisor de tensão ckt de acordo com nossa exigência. Mas não podemos medir a tensão de saída tão facilmente, pois não temos um aterramento comum.

Agora, para fazer isso, existe um truque. Em vez de medir a tensão no capacitor de saída, medi a tensão entre duas linhas -Ve. Usando solar -Ve como aterramento para o Arduino e saída -Ve como o sinal / tensão a ser medido. O valor que você obteve com esta medição deve ser subtraído da tensão de entrada medida e você obterá a tensão de saída real através do capacitor de saída.
  Vout_sense_temp =Vout_sense_temp * 0,92 + float (raw_vout) * volt_factor * 0,08; // mede a volatilidade em gnd de entrada e gnd de saída. 
Vout_sense =Vin_sense-Vout_sense_temp-diode_volt; // altera a diferença de tensão entre dois aterramentos para a tensão de saída.

Para medições de corrente, usei módulos de detecção de corrente ACS-712. Eles foram alimentados por Arduino e conectados à entrada GND.

Os temporizadores internos são modificados para ganhar 62,5 Khz PWM no pino D6, que é usado para conduzir o MOSFET. Um diodo de bloqueio de saída será necessário para fornecer vazamento reverso e proteção de polaridade reversa, use o diodo Schottky da classificação de corrente desejada para este propósito. O valor do indutor depende dos requisitos de frequência e corrente de saída. Você pode usar calculadoras conversoras de buck disponíveis online ou usar carga de 100uH 5A-10A. Nunca exceda a corrente de saída máxima do indutor em 80% -90%.





Etapa 5:retoque final


Você também pode adicionar recursos adicionais ao seu carregador. O meu tem LCD para exibir os parâmetros e 2 interruptores para receber a entrada do usuário.

Vou atualizar o código final e completar o diagrama ckt muito em breve.





Etapa 6:Diagrama de circuito real, BOM e código


ATUALIZAR:

Eu carreguei o código, bom e circuito. É um pouco diferente do meu, porque é mais fácil de fazer este.
Solar_charger_tutorial_code.ino

Código

  • Solar_charger_tutorial_code.ino
Solar_charger_tutorial_code.ino Arduino
 /////////////////////////////////////////////////// //////////////////////////////////////////Termos de uso///// //////////////////////////////////////////////////////// //////////////////////////////////////// O SOFTWARE É FORNECIDO "COMO ESTÁ", SEM QUALQUER TIPO DE GARANTIA, EXPRESSA OU // IMPLÍCITA, INCLUINDO, MAS NÃO SE LIMITANDO ÀS GARANTIAS DE COMERCIALIZAÇÃO, // ADEQUAÇÃO A UM DETERMINADO FIM E NÃO VIOLAÇÃO. EM NENHUMA HIPÓTESE // OS AUTORES OU TITULARES DOS DIREITOS AUTORAIS SERÃO RESPONSÁVEIS POR QUALQUER RECLAMAÇÃO, DANOS OU OUTRAS // RESPONSABILIDADE, SEJA EM AÇÃO DE CONTRATO, DELITO OU DE OUTRA FORMA, DECORRENTE DE, // FORA DE OU EM CONEXÃO COM O SOFTWARE OU USE OU OUTROS NEGÓCIOS NO // SOFTWARE.//////////////////////////////////////////// /////////////////////////////////////////////////// # incluir  #include  #include  #define vin_pin A1 # define vout_pin A0 # define iout_pin A2 # define iin_pin A3 # define lm35 A4 # define fan 5 # define buck_pin 6 # define menu 3 # definir botão 2 # definir led 13 # definir charge_led A5 # definir luz 4uint8_t auto_mode =1; float Pin =0, Pout =0, Pin_previous =0; eficiência de flutuação =0,0; int raw_vin =0, raw_vout =0, raw_iout =0, raw_iin =0, raw_lm35 =0; float Vout_boost =14,5, Vout_max =15,0, Iout_max =5,0, Vout_float =13,5, Iout_min =0,00, Vin_thresold =10,0; float Iout_sense, Iin_sense, Iin; float Vout_sensep, Vin_last;; float Vin_sense; uint8_t duty_ciclo =0; float volt_factor =0,05376; // altere este valor para calibrar as leituras de tensão ... String mode =""; bool startup =true, lcd_stat =true, charge =true, mppt_init =true; unsigned int count =0; LiquidCrystal lcd (7, 8, 9, 10, 11, 12); void lcd_show (dados de string, coluna int, linha interna); void UI (); void set_limits (int cmd, int temp); void mem_read (); void mem_write (); void mppt (); void setup () {wdt_disable (); watchdogSetup (); // coloque seu código de configuração aqui, para ser executado uma vez:Serial.begin (115200); mem_read (); pinMode (light, OUTPUT); pinMode (charge_led, OUTPUT); digitalWrite (charge_led, LOW); digitalWrite (light, HIGH); pinMode (led, OUTPUT); pinMode (ventilador, OUTPUT); pinMode (menu, INPUT); pinMode (botão, INPUT); digitalWrite (menu, HIGH); digitalWrite (botão, HIGH); TCCR0B =TCCR0B &0b11111000 | 0x01; / definir pwm em Max ... 62,5 KhzanalogWrite (buck_pin, 0); lcd.begin (16,2); lcd_show ("Carregador solar", 0,0); atraso (64000); wdt_reset (); atraso (64000); wdt_reset (); lcd_show ("Vi Vb Ib", 0,0); ////////////////// for (int i =0; i <10; i ++) { raw_iout + =analogRead (iout_pin) -513; raw_iin + =analogRead (iin_pin) -513; raw_vin + =analogRead (vin_pin); raw_vout + =analogRead (vout_pin); raw_lm35 + =analogRead (lm35); atraso (2); } raw_iout =raw_iout / 10; raw_iin =raw_iin / 10; raw_vout =raw_vout / 10; raw_vin =raw_vin / 10; Iout_sense =float (raw_iout) * 5/1023 / 0,066; Iin_sense =float (raw_iin) * 5/1023 / 0,066; Vout_sense_temp =float (raw_vout) * volt_factor; Vin_sense =float (raw_vin) * volt_factor; // heat_sink_temp =raw_lm35 * 0,48; // 0,0049 * 1000/10 // heat_sink_temp =heat_sink_temp-273.15; // descomente se estiver usando LM235} ////////// void watchdogSetup (void) {cli (); // desativa todas as interrupçõeswdt_reset (); // zera o temporizador WDT // Entre no modo de configuração do Watchdog:WDTCSR | =(1 < Vout_max) || (Iout> Iout_max) || ((Pin> Pin_previous &&Vin_sense  Vin_last))) {if (duty_cycle> 0) {duty_cycle- =1; } analogWrite (buck_pin, duty_cycle); } else if ((Vout  Pin_previous &&Vin_sense> Vin_last) || (Pin  Iout_min + 1) {charge =true; } ///////////// if ((Vout> Vout_max) &&(Iout 
 80.0) {duty_cycle =0; analogWrite (buck_pin, duty_cycle); Serial.println ("Desligamento por superaquecimento"); lcd_show ("Falha de superaquecimento", 0,1); wdt_reset (); para (int i =0; i <10; i ++) {digitalWrite (led, HIGH); digitalWrite (charge_led, LOW); atraso (4000); digitalWrite (charge_led, HIGH); digitalWrite (led, BAIXO); atraso (4000); } wdt_reset (); } mais {carga =verdadeiro; digitalWrite (charge_led, HIGH); regular (Iout_sense, Vin_sense, Vout_sense); digitalWrite (led, BAIXO); }} void soft_start () {for (int i =0; i <20; i ++) {regular (Iout_sense, Vin_sense, Vout_sense); Serial.print ("Vin ="); Serial.println (Vin_sense); Serial.print ("Vout ="); Serial.println (Vout_sense); Serial.print ("Iout ="); Serial.println (Iout_sense); Serial.print ("Ciclo de trabalho ="); Serial.println (duty_cycle); Serial .print ("MODO Carregador:"); Serial.println (modo); Serial.println ("Inicialização suave ativada"); atraso (32000); } inicialização =falso; mppt_init =false;} void lcd_show (dados da string, coluna interna, linha interna) {lcd.setCursor (coluna, linha); if (data.length ()> 0) {for (int i =0; i 
 45.0) {digitalWrite (fan, HIGH);} else if (heat_sink_temp <37.0) {digitalWrite (fan, LOW);} contar ++;} 

Esquemas


Processo de manufatura

  1. Bulldozer
  2. Célula solar
  3. Aquisição de dados em tempo real do painel solar usando Arduino
  4. Arduino Spybot
  5. FlickMote
  6. TV B-Gone caseiro
  7. Relógio mestre
  8. Encontre-me
  9. Solar Tracker V2.0
  10. Força do vento