Arduino - Cargador solar PV MPPT

Acerca de este proyecto

Hay muchos controladores de carga disponibles en el mercado, pero los controladores de carga baratos ordinarios no son eficientes para su uso con la máxima potencia de los paneles solares. Y los que son eficientes son muy costosos.

Así que decidí hacer mi propio controlador de carga para que sea lo suficientemente eficiente e inteligente como para comprender las necesidades de la batería y las condiciones solares. Toma las medidas adecuadas para extraer la máxima energía disponible de la energía solar y ponerla dentro de la batería de manera muy eficiente.

Si te gustan mis esfuerzos, vota por este tutorial.

Paso 1:¿Qué es MPPT y por qué lo necesitamos?

Nuestros paneles solares son tontos y no lo suficientemente inteligentes como para comprender las condiciones de la batería. Supongamos que tenemos un panel solar de 12v / 100 vatios y dará una salida entre 18V-21V dependiendo de los fabricantes, pero las baterías están clasificadas para voltaje nominal de 12v. En condiciones de carga completa, serán de 13,6 voltios y de 11,0 voltios con descarga completa. Ahora supongamos que nuestras baterías se están cargando a 13v, los paneles dan 18v, 5.5A con una eficiencia de trabajo del 100% (no es posible tener el 100%, pero supongamos). Los controladores ordinarios tienen un regulador de voltaje PWM ckt que baja el voltaje a 13.6 sin ninguna ganancia de corriente. Solo brinda protección contra la sobrecarga y la fuga de corriente a los paneles durante la noche.

Para contrarrestar este problema, he utilizado el convertidor smps buck. Este tipo de convertidor tiene una eficiencia superior al 90%. Incluso el 90% se considera pobre.

El segundo problema que tenemos es la salida no lineal de los paneles solares. Deben funcionar a un cierto voltaje para recolectar la máxima potencia disponible. Su producción varía a lo largo del día.

Para solucionar este problema se utilizan algoritmos MPPT. MPPT (Seguimiento del punto de máxima potencia) como sugiere el nombre, este algoritmo rastrea la potencia máxima disponible de los paneles y varía los parámetros de salida para mantener la condición.

Entonces, al usar MPPT, nuestros paneles generarán la máxima potencia disponible y el convertidor reductor colocará esta carga de manera eficiente en las baterías.

Paso 2:¿Cómo funciona MPPT?

No voy a discutir esto en detalle, así que si quiere entenderlo, eche un vistazo a este enlace:¿Qué es MPPT?

En este proyecto, he realizado un seguimiento de las características de entrada V-I y también de la salida V-I. Multiplicando la entrada V-I y la salida V-I podemos tener la potencia en vatios.

Digamos que tenemos 17 V 5 A, es decir, 17x5 =85 vatios, en cualquier momento del día. Al mismo tiempo, nuestra salida es 13 V 6A, es decir, 13x6 =78 Watt.

Ahora MPPT aumentará o disminuirá el voltaje de salida comparándolo con la potencia de entrada / salida anterior.

Si la potencia de entrada anterior era alta y el voltaje de salida era más bajo que el actual, entonces el voltaje de salida se reducirá nuevamente para volver a la potencia alta. Y si el voltaje de salida era alto, entonces el voltaje actual aumentará al nivel anterior. Por lo tanto, sigue oscilando alrededor del punto de máxima potencia. Estas oscilaciones se minimizan mediante algoritmos MPPT eficientes.

Paso 3:implementación de MPPT en Arduino

Este es el cerebro de este cargador. A continuación se muestra el código Arduino para regular la salida y la implementación de MPPT en un solo bloque de código.

  // Iout =corriente de salida // Vout =voltaje de salida // Vin =voltaje de entrada // Pin =potencia de entrada, Pin_previous =última potencia de entrada // Vout_last =último voltaje de salida, Vout_sense =voltaje de salida actualvoid regular (flotar Iout, flotar Vin, flotar 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  ciclo_de_uso + =1; } analogWrite (buck_pin, duty_cycle); } Pin_previous =Pin; Vin_last =Vin; Vout_last =Vout;}  

Paso 4:convertidor Buck

He usado mosfet de canal N para hacer el convertidor buck. Por lo general, las personas eligen mosfet de canal P para conmutación de lado alto y si eligen mosfet de canal N para el mismo propósito, se requerirá un controlador IC o un ckt de correas de arranque.

Pero modifiqué el convertidor buck ckt para tener un cambio de lado bajo usando mosfet de canal N. Estoy usando el canal N porque son de bajo costo, clasificaciones de alta potencia y menor disipación de energía. Este proyecto utiliza un mosfet de nivel lógico IRFz44n, por lo que puede ser impulsado directamente por un pin Arduino PWM.

Para una corriente de carga más alta, se debe usar un transistor para aplicar 10 V en la puerta para que el mosfet se sature completamente y minimizar la disipación de energía. Yo he hecho lo mismo.

Como puede ver en el ckt anterior, coloqué el mosfet en voltaje -ve, por lo que usé + 12v del panel como tierra. Esta configuración me permite usar un mosfet de canal N para convertidor reductor con componentes mínimos.

Pero también tiene algunos inconvenientes. Como tiene ambos lados -Ve voltaje separados, ya no tiene una tierra de referencia común. Por lo tanto, medir los voltajes es muy complicado.

He conectado el Arduino en los terminales de entrada solar, usando su línea -Ve como tierra para Arduino. Podemos medir fácilmente el voltaje de entrada en este punto utilizando un divisor de voltaje ckt según nuestro requisito. Pero no podemos medir el voltaje de salida tan fácilmente porque no tenemos un terreno común.

Ahora bien, para hacer esto hay un truco. En lugar de medir el voltaje a través del capacitor de salida, he medido el voltaje entre dos líneas -Ve. Usando solar -Ve como tierra para el Arduino y salida -Ve como la señal / voltaje a medir. El valor que obtuvo con esta medida debe restarse del voltaje de entrada medido y obtendrá el voltaje de salida real a través del capacitor de salida.

  Vout_sense_temp =Vout_sense_temp * 0.92 + float (raw_vout) * volt_factor * 0.08; // medir la volatilidad en la tierra de entrada y salida. 
 Vout_sense =Vin_sense-Vout_sense_temp-diode_volt; // cambia la diferencia de voltaje entre dos tierras a voltaje de salida ..  

Para las mediciones de corriente he utilizado módulos de detección de corriente ACS-712. Han sido alimentados por Arduino y conectados a la entrada GND.

Los temporizadores internos se modifican para ganar 62,5 Khz PWM en el pin D6, que se utiliza para controlar el MOSFET. Se requerirá un diodo de bloqueo de salida para proporcionar protección contra fugas inversas y polaridad inversa. Utilice un diodo Schottky de la corriente nominal deseada para este propósito. El valor del inductor depende de los requisitos de frecuencia y corriente de salida. Puede usar las calculadoras de conversión de dólar disponibles en línea o usar una carga de 100uH 5A-10A. Nunca exceda la corriente de salida máxima del inductor en un 80% -90%.

Paso 5:Retoque final

También puede agregar funciones adicionales a su cargador. Los míos tienen LCD para mostrar los parámetros y 2 interruptores para recibir información del usuario.

Actualizaré el código final y completaré el diagrama de ckt muy pronto.

Paso 6:diagrama de circuito real, lista de materiales y código

ACTUALIZAR:

He subido el código, el bom y el circuito. Es un poco diferente al mío, porque es más fácil hacer este.

Código

• Solar_charger_tutorial_code.ino

Solar_charger_tutorial_code.ino Arduino

 ///////////////////////////////////////////////// //////////////////////////////////////////Términos de Uso///// //////////////////////////////////////////////////// //////////////////////////////////// EL SOFTWARE SE PROPORCIONA "TAL CUAL", SIN GARANTÍA DE NINGÚN TIPO, EXPRESA O // IMPLÍCITA, INCLUYENDO PERO NO LIMITADO A LAS GARANTÍAS DE COMERCIABILIDAD, // APTITUD PARA UN PROPÓSITO PARTICULAR Y NO INFRACCIÓN. EN NINGÚN CASO LOS // AUTORES O TITULARES DE LOS DERECHOS DE AUTOR SERÁN RESPONSABLES DE CUALQUIER RECLAMO, DAÑOS U OTRAS // RESPONSABILIDAD, YA SEA EN UNA ACCIÓN DE CONTRATO, AGRAVIO O DE OTRO MODO, QUE SURJA DE, // FUERA DE O EN RELACIÓN CON EL SOFTWARE O EL USO U OTROS NEGOCIOS EN // EL 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 menú 3 # definir botón 2 # definir led 13 # definir charge_led A5 # definir luz 4uint8_t auto_mode =1; float Pin =0, Pout =0, Pin_previous =0; float eficiencia =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 Voutink_sense, heat_sust,; float Vin_sense; uint8_t duty_cycle =0; float volt_factor =0.05376; // cambia este valor para calibrar las lecturas de voltaje ... 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 (datos de cadena, int columna, int fila); void UI (); void set_limits (int cmd, int temp); void mem_read (); void mem_write (); void mppt (); configuración vacía () {wdt_disable (); watchdogSetup (); // ponga su código de configuración aquí, para que se ejecute una vez:Serial.begin (115200); mem_read (); pinMode (light, OUTPUT); pinMode (charge_led, OUTPUT); digitalWrite (charge_led, LOW); digitalWrite (light, HIGH); pinMode (led, SALIDA); pinMode (ventilador, SALIDA); pinMode (menú, ENTRADA); pinMode (botón, ENTRADA); digitalWrite (menú, HIGH); digitalWrite (botón, HIGH); TCCR0B =TCCR0B &0b11111000 | 0x01; / establecer pwm en Max ... 62.5 KhzanalogWrite (buck_pin, 0); lcd.begin (16,2); lcd_show ("Cargador solar", 0,0); delay (64000); wdt_reset (); delay (64000); wdt_reset (); lcd_show ("Vi Vb Ib", 0,0); ////////////////// para (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); retardo (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 =flotar (raw_iin) * 5/1023 / 0.066; Vout_sense_temp =float (raw_vout) * volt_factor; Vin_sense =flotar (raw_vin) * volt_factor; // heat_sink_temp =raw_lm35 * 0.48; // 0.0049 * 1000/10 // temperatura_disipador_calentamiento =temperatura_disipador_calentamiento-273.15; // descomentar si se usa LM235} ////////// void watchdogSetup (void) {cli (); // deshabilita todas las interrupcioneswdt_reset (); // reinicia el temporizador WDT // Ingresa al modo de configuración de 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) {ciclo_de_uso =0; analogWrite (buck_pin, duty_cycle); Serial.println ("Apagado por sobrecalentamiento"); lcd_show ("Fallo por sobrecalentamiento", 0,1); wdt_reset (); para (int i =0; i <10; i ++) {digitalWrite (led, HIGH); digitalWrite (charge_led, LOW); retraso (4000); digitalWrite (charge_led, HIGH); digitalWrite (led, BAJO); retraso (4000); } wdt_reset (); } más {cargo =verdadero; digitalWrite (charge_led, HIGH); regular (Iout_sense, Vin_sense, Vout_sense); digitalWrite (led, BAJO); }} 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 ("Duty cycle ="); Serial.println (duty_cycle); Serial .print ("MODO Cargador:"); Serial.println (modo); Serial.println ("Arranque suave activado"); retraso (32000); } inicio =falso; mppt_init =false;} void lcd_show (datos de cadena, columna int, fila int) {lcd.setCursor (columna, fila); if (data.length ()> 0) {for (int i =0; i 
 45.0) {digitalWrite (fan, HIGH);} else if (heat_sink_temp <37.0) {digitalWrite (fan, LOW);} count ++;} 

Esquemas

Ventilador pulmonar COVID-19 de código abierto Coche con control remoto por infrarrojos