Controlador de carga solar integrado, inversor, banco de energía, lámpara
Componentes y suministros
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 4 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
 |
| × | 1 | |||
| × | 1 | ||||
 |
| × | 1 | |||
 |
| × | 1 | |||
 |
| × | 1 | |||
 |
| × | 1 | |||
 |
| × | 1 | |||
| × | 1 | ||||
 |
| × | 1 | |||
 |
| × | 1 | |||
 |
| × | 1 | |||
| × | 1 | ||||
 |
| × | 1 | |||
 |
| × | 1 |
Herramientas y máquinas necesarias
 |
| |||
| ||||
 |
|
Aplicaciones y servicios en línea
| |
| |||
|
Acerca de este proyecto
Acerca de este proyecto
Tengo algunos paneles solares, baterías de 12 voltios, transformadores y algunas cosas más tiradas por un tiempo gritando en voz alta para hacer un buen uso de ellos. De ahí el nacimiento de este dispositivo:una pequeña solución fotovoltaica completa en una sola placa. Repasemos primero cuál hace qué, ¿de acuerdo?
- Un controlador de carga es un dispositivo que regula la carga de almacenamiento / batería de CC desde un panel solar fotovoltaico y la descarga de la batería por la carga para prolongar la vida útil de la batería.
- Un inversor es un dispositivo que convierte la forma de CC de electricidad en forma de CA para operar cargas de CA.
- Power Bank proporciona un suministro de 5 V CC a través del puerto USB a dispositivos / dispositivos móviles para carga portátil o carga fuera de la red.
- La lámpara de emergencia es una fuente de luz LED súper brillante que se puede usar durante cortes de energía, campamentos y actividades al aire libre después del anochecer.
Este dispositivo que hice tiene todas estas características, las dos últimas características son compatibles de forma independiente con la batería de iones de litio incorporada. Con un panel solar (hasta 100 vatios), una batería de plomo-ácido de 12 voltios y un transformador, se pueden utilizar todas las opciones.
Versión Proto en Uno
La primera versión fue desarrollada en Uno Board con hardware mínimo y opciones mínimas. La pantalla de Nokia se montó directamente y se desarrolló un protector MOSFET para soportar la carga / descarga de la batería. ¡No hay control de menú, ni inversor, ni carga PWM y funciones geniales! Solo carga y descarga de encendido / apagado y muestra los niveles de voltaje de la batería y el panel. ¡Hace el trabajo pero no tiene encanto!
Versión completa en Protoboard
Luego desarrollé este nuevo con las siguientes características:
- Controlador de carga solar PWM de hasta 100 vatios de panel
- Mini inversor de onda cuadrada de 60 vatios
- Hasta tres controles de carga de CC de 12 voltios
- La carga de CC primaria admite funciones de encendido / apagado automático
- Un banco de energía USB independiente
- Módulo regulador Buck
- Lámpara LED de emergencia a bordo con control de brillo y parpadeo
Desplazamiento controlado por 2 botones / interruptores y menú basado en selección para el control del usuario, que muestra opciones e información de estado en la pantalla del Nokia 5110. ¡Muy genial! ¡La parte trasera está aislada con pegamento caliente para protección contra cortocircuitos contra objetos metálicos!
Hay algunas características más convenientes, como el interruptor de encendido / apagado para la luz de fondo de la pantalla, que separa el dinero para una operación independiente al apagar la batería interna.
Aquí se muestra el acceso al menú en la pantalla del Nokia 5110 con el botón de usuario:
¡Aprendamos algunas cosas técnicas!
El controlador de carga puede ser de tipo On / Off, PWM o MPPT. On / Off es la forma más simple (mi versión 1 - imagen de arriba) de controlador que no regula la corriente de carga cuando el voltaje de la batería se acerca a su voltaje de carga completo.
Mientras que PWM disminuye gradualmente la corriente de carga a medida que la batería se llena. El controlador PWM tiene los siguientes beneficios:
- Ayuda a recuperar la capacidad perdida de la batería y desulfato una batería
- Aumenta la capacidad de la batería para aceptar más carga
- Mantenga una alta capacidad promedio de la batería hasta en un 95%
- Ecualice las celdas de la batería a la deriva, de modo que las celdas internas puedan alcanzar el mismo potencial
- Reducir el calentamiento y la formación de gases de la batería evitando así la pérdida de electrolitos
- Ralentiza el envejecimiento y prolonga la vida útil del sistema
Pero PWM no puede obtener la mayor parte de la energía eléctrica de los paneles solares fotovoltaicos, porque arrastra el panel para que funcione cerca del voltaje de la batería. MPPT es la solución a este problema, que básicamente es un convertidor reductor-elevador ajustable de CC a CC, puede convertir la mayor parte de la energía solar en comparación con el controlador PWM.
Los inversores pueden ser de onda cuadrada, onda sinusoidal modificada y onda sinusoidal pura. El inversor de onda cuadrada tiene un diseño muy simple y cargas de CC suficientemente pequeñas como lámparas de CA, lámparas CFL, ventiladores de mesa, soldadores, pero no se recomienda para motores inductivos, equipos delicados / fuentes de alimentación debido a la distorsión armónica.
La onda sinusoidal modificada es una especie de onda sinusoidal retardada creada a partir de ondas cuadradas, mejor que los inversores de onda cuadrada simple. Los inversores de onda sinusoidal son los mejores para todo tipo de carga, pero son complejos en el diseño de hardware, algoritmos de software difíciles de operar y costosos de fabricar.
Un regulador reductor es un convertidor CC-CC reductor, aquí he usado un módulo reductor para cargar la batería de iones de litio de 4.2 V que alimenta el controlador (pantalla Arduino +), banco de energía USB independiente, lámpara LED incorporada.
Ahora el banco de energía USB es básicamente un impulso DC-DC que puede convertir un rango de voltajes por debajo de 5 (como un rango de 3.3 a 4.2 voltios) de una batería de iones de litio o LiPo a 5 voltios, que es el voltaje del bus USB que puede cargar dispositivos móviles. .
También tiene un convertidor de dólar para cargar esa batería. En mi proyecto, el módulo Buck toma algo de energía del panel para cargar la batería interna (a bordo).
Funcionamiento del hardware
Antes de entrar en detalles, verifique esta imagen de todo lo conectado alrededor del dispositivo:
El sistema tiene varios hardware para diferentes propósitos. Por supuesto, el cerebro es el microcontrolador AVR Atmega8A (se puede usar Atmega328P con cambios menores, que se analizan a continuación) que está programado en Arduino.
Se graba un Atmega8A nuevo con el gestor de arranque Arduino Optiboot8, puede comprar un Arduino Mini / Atmega328 cargado por arranque para evitar la molestia.
El controlador, la pantalla, la lámpara LED y el banco de energía se alimentan con una batería de iones de litio incorporada. Dos botones táctiles momentáneos son para acceder al menú en pantalla, lo que permite al usuario operar diferentes funciones del dispositivo. Los interruptores son rebotados por hardware a través de condensadores de suavizado que están conectados en paralelo.
Un interruptor deslizante permite encender / apagar el dispositivo según sea necesario.
La función de carga solar se realiza mediante un P-MOSFET impulsado por un circuito de conducción basado en transistor 2N2222 que se controla a través de PWM desde el microcontrolador. El PWM se controla en función del nivel de voltaje de la batería externa. La corriente de los paneles solares fluye a través de P-MOSFET a la batería de plomo-ácido. Cuando la batería está completamente cargada, el MOSFET se apaga desde el microcontrolador. Una vez que se apaga la carga, el voltaje de la batería comienza a caer gradualmente, cuando alcanza los 13,6 voltios, la carga se reanuda nuevamente con un ciclo de trabajo bajo para mantener la carga flotante.
La carga de 12 voltios CC se controla a través de un N-MOSFET controlando su pin de puerta desde el microcontrolador.
La LÁMPARA LED incorporada también se maneja a través de un NMOS. La puerta de este MOSFET está controlada por PWM para ajustar el brillo del LED.
El bloque inversor consta de 2 N-MOSFET que alternativamente se encienden / apagan para simular CA. Al agregar un transformador con toma de centro externo, se puede realizar un suministro de CA de onda cuadrada.
La siguiente figura explica la acción del inversor:
Al permitir que la corriente fluya a través de la toma central de la bobina de un transformador elevador en dirección opuesta, alternativamente usando MOSFET, se puede crear voltaje de CA en el secundario. Esto sucede porque cuando el MOSFET superior está encendido y el MOSFET inferior está apagado, la corriente fluye hacia arriba. Pero cuando el MOSFET superior está apagado y el MOSFET inferior está encendido, la corriente fluye hacia abajo.
Ambos MOSFET deben alternarse al doble de la frecuencia de CA. Mira la siguiente imagen para entenderla:
Para crear una CA de 50 Hz, se aplica una onda cuadrada alterna en el lado bajo del transformador con toma central de 12-0-12V / 220V. 50 Hz significa un tiempo de 20 ms para cada onda.
Es por eso que 20ms / 2 =10 ms o 100 veces Alternar las señales de puerta aplicadas a los MOSFET de conducción del transformador (MOSFET de inversor).
¡¡¡Advertencia !!! :¡El voltaje de CA es letal para los humanos, puede causar la muerte o lesiones! ¡Nunca toque el lado de AT del transformador con la mano desnuda!
Si no se utiliza la función de inversor, la opción de carga 2XDC permite utilizar dos cargas más de 12 voltios de CC en el terminal del inversor.
Magia del software
Se proporcionan dos conjuntos de código, uno es el código completo en una sola pestaña de Arduino, otro es el código con pestañas de acuerdo con funciones separadas.
He generalizado un grupo de tareas en una sola función.
Por ejemplo:
Get_ADCVal () medirá los voltajes del panel, la batería interna y la batería externa, tomará 20 muestras, promediará esos valores y actualizará la información de voltaje de retención variable.
Context_Control () realizará las actividades relacionadas con la interacción del usuario, el control de acciones y la actualización de información en la pantalla.
Charging_Control (), Discharging_Control (), Load_Control () son funciones en segundo plano que actúan como CERRAR LAZO para el sistema, monitorea el nivel de voltaje de la batería, controla la función de carga automática, control de protección de sobrecarga / descarga profunda, etc.
Las entradas del usuario se recopilan a través de interruptores de presión momentánea accionados por interrupción. Cuando se presionan estos interruptores, se ejecutan los ISR relacionados con INT0 / INT1. Dos variables volátiles dp y ds cambios. Otra tercera variable nivel junto con dp (puntero de pantalla ->) y ds (selector de contenido de pantalla) permite al usuario viajar a través del menú / submenú y realizar acciones según sea necesario.
El TImer1 de 16 bits del AVR está configurado para generar una interrupción de desbordamiento del temporizador cada 10 ms y cambia PIN_INVP y PIN_INVN cuando la función del inversor está activada.
Todas las funciones de Lcd _.... () tienen algo que ver con el control de la pantalla.
Atmega8A frente a Atmega328P (Uno)
El sistema se puede actualizar fácilmente para que funcione con Atmega328P / Uno realizando los siguientes cambios en el código. Buscar y reemplazar
TIMSK con TIMSK1 # define ADC_VREF 2.69 con #define ADC_VREF 1.11 #define ADCVDIV_R1 22 con #define ADCVDIV_R1 8.2 En la parte de hardware necesitas usar una resistencia de 8.2K en lugar de 22 K para reducir el panel, los voltajes de la batería al rango de medición de ADC.
Vídeos de acción
Por lo general, no leo solo palabras sobre algún proyecto, sino que primero busco el video. Si eres como yo, disfruta de los videos:
Alcance de la mejora
Me quedé sin Flash Space en Atmega8A. No se pudieron agregar algunas características críticas como:
- Protección contra sobrecargas / cortocircuitos controlada por software
- Algunos iconos gráficos y un logotipo
- Medición de energía y registro
- Estimación y alarma para el tiempo de respaldo
- Opción de carga para computadora portátil
- Soporte para sistema de 6 voltios
- Control de carga de Bluetooth
- Control de carga basado en temporizador
- Un reloj RTC para funciones más interesantes
- Solución conectada a IoT
Si tiene planes para hacer algo como esto, ¡no olvide agregar algunas de estas funciones!
Atmega328P (Uno) o Arduino Mega podrían ser mejores candidatos para incluir todas estas opciones.
De todos modos, funciona, estoy contento con él.
Recursos adicionales
- Descarga Arduino 1. 0. 6 con soporte para placa Atmega8
- Abra Arduino.exe, vaya a Herramientas> Tablero> Optiboot8
- Grabe el gestor de arranque con este método
- Compile y cargue el código
Código
- Código de pestaña única
- Código completo
- Cargadores de arranque
Código de pestaña ú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 // carga 12 v dc # define PIN_LAMP 10 // LUZ LED BLANCA #define PIN_BATTPWM 11 // Controla PMOS para carga externa de BAtt #define PIN_BATTint_Sense A2 # define PIN_SOLAR_Sense A0 # define PIN_BATText_Sense A3 # define ADC_VREF 2.695 // voltaje de referencia interno, alrededor de 1.11V para Arduino define ADCVDIV_R1 22 // Resistencia inferior del divisor de tensión de 22 K # define ADCVDIV_R2 175 // Resistencia superior del divisor de tensión de 175 K // const uint8_t skulljoke [] PROGMEM ={2,}; // PIN 2 &3 UTILIZADO COMO INTERRUPTOR DE INTERRUPCIÓN // PIN 0 &1 COMO PROGRAMACIÓN // PIN RESET AS # definir LCD_C LOW # definir LCD_D HIGH # definir LCD_X 84 # definir 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; volátil uint8_t =0 ds =0; volatile uint8_t ds =ciclo uint8_t cdc_level =0; // int i; void setup (void) {LcdInitialise (); LcdClear (); LcdString ("* ARDUBOY PV *"); LcdString ("CONTROLADOR"); LcdString ("INVERSOR DE CA"); LcdString ("BANCO DE ENERGÍA"); LcdString ("¡COSA LÁMPARA!"); retraso (3000); analogReference (INTERNAL); maxADC_Voltage =(ADC_VREF / ADCVDIV_R1) * (ADCVDIV_R1 + ADCVDIV_R2); pinMode (PIN_LOAD, SALIDA); digitalWrite (PIN_LOAD, BAJO); pinMode (2, INPUT_PULLUP); attachInterrupt (0, SW1, FALLING); // Interrupción para Swithc 1 pinMode (3, INPUT_PULLUP); attachInterrupt (1, SW2, FALLING); // Interrupción para Swithc 2} bucle vacío (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); } // voltaje promedio 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 * Batt_Voltage_Voltage; ////////// Visualización y control ////////////// void Context_Control (void) {if (ds ==0) {show_menu ();} if (ds ==1 &&dp ==0) {show_info (); delay (100);} // LcdClear (); Get_ADCVal ();} /////////////////////// Entra en el primer submenú ////// //////////////////////// if (ds ==1 &&dp ==1) {nivel =1; dp =0; while (nivel ==1) {int temp =ds; LcdClear (); show_load_ctrl (); retraso (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;}}} //////////////////////// Entra en el segundo submenú /////////// /////////////////// if (ds ==1 &&dp ==2) {nivel =2; dp =0; while (nivel ==2) {int temp =ds; show_inv_ctrl (); retraso (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 (); retraso (250); nivel =0; dp =0; ds =0;}}} //////////////////////////////////////// /////////////////// //////////////// Entra en el tercer submenú /////////// ////////////////// if (ds ==1 &&dp ==3) {nivel =3; dp =0; while (nivel ==3) {int temp =ds; LcdClear (); show_led_ctrl (); retraso (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);} retardo (250); if (intermitente ==1) {analogWrite (PIN_LAMP, 127);}} //////////////////////// /// Texto del menú que se mostrará en la pantalla del Nokia 5110 /////////////////// void show_menu (void) {LcdXY (0, dp); LcdString ("->" ); LcdXY (15,0); LcdString ("Información del sistema"); LcdXY (15,1); LcdString ("Carga CC +"); LcdXY (15,2); LcdString ("Carga CA ~"); LcdXY ( 15,3); LcdString ("Lámpara LED");} 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 ("Cargando:ON");} else {LcdString ("Cargando:OFF");} if (TCNT1> =45535) {LcdString ("Inversor:ON");} else {LcdString ("Inversor: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 ("Debe conectarse"); LcdString ("Carga de 12 V CC");} 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 ("Retorno"); LcdXY (0,4); LcdString ("Carga 2XDC, NO"); LcdXY (0,5); LcdString ("¡TRANSFORMADOR!");} 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 ("Retorno"); LcdXY (0,4); LcdString ("LED DESACTIVADOS"); LcdXY (0,5); LcdString ("Cuando INVR activado");} // //////////// Interrumpir ISR ////////////// anular SW1 () {dp ++; if (dp>
3) {dp =0;}} anular SW2 () {ds ^ =1;} ISR (TIMER1_OVF_vect) {noInterrupts (); TCNT1 =45535; // TCNT1 =25535; ciclo ^ =1; si (ciclo ==0); {digitalWrite (PIN_INVP, HIGH); delayMicroseconds (1); // escritura digital de banda muerta (PIN_INVN, LOW); delayMicroseconds (1); } if (ciclo ==1) {digitalWrite (PIN_INVP, LOW); delayMicroseconds (1); // banda muerta digitalWrite (PIN_INVN, HIGH); delayMicroseconds (1); } interrupciones (); } ///////////// Nokia 5110 Funciones ////////// byte constante estático 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 (carácter char) {LcdWrite (LCD_D, 0x00); para (int índice =0; índice <5; índice ++) {LcdWrite (LCD_D, ASCII [carácter - 0x20] [índice]); } LcdWrite (LCD_D, 0x00);} void LcdClear (void) {para (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 Carga apagada, 13.5 o menos Carga encendida, 10.8 Carga apagada, 12.5 Carga encendida // esta siguiente condición previene los intentos de carga durante la noche% noche PV es 0 voltios! 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; } // Bloqueo por sobrevoltaje, mientras cdc_level es 3, ¡SIN carga! La carga se reanuda cuando cdc es 2, que es inferior a 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++
Sin vista previa (solo descarga).
Esquemas
Proceso de manufactura