Contrôleur de charge solaire intégré, onduleur, PowerBank, lampe

Outils et machines nécessaires

	Fer à souder (générique)
	Moteur de forage
	Pistolet à colle chaude (générique)

Applications et services en ligne

	Arduino IDE
	AutoDesk 123D

À propos de ce projet

À propos de ce projet

J'ai quelques panneaux solaires, des batteries de 12 volts, des transformateurs et quelques autres trucs qui traînent pendant un moment à crier à haute voix pour en faire bon usage. D'où la naissance de cet appareil - petite solution PV complète sur une seule carte. Voyons d'abord qui fait quoi, voulez-vous ?

• Un contrôleur de charge est un appareil qui régule la charge du stockage/batterie CC à partir d'un panneau solaire photovoltaïque et la décharge de la batterie par la charge pour prolonger la durée de vie de la batterie.
• Un onduleur est un appareil qui convertit l'électricité sous forme CC en forme CA pour faire fonctionner les charges CA.
• La banque d'alimentation fournit une alimentation 5 V cc via un port USB aux gadgets/appareils mobiles pour une charge portable ou une charge hors réseau.
• La lampe de secours est une source de lumière LED super brillante qui peut être utilisée pendant les pannes de courant, le camping, les activités de plein air après le crépuscule.

Cet appareil que j'ai fabriqué possède toutes ces fonctionnalités, les deux dernières fonctionnalités sont prises en charge indépendamment par la batterie Li-ion embarquée. Avec un panneau solaire (jusqu'à 100 watts), une batterie au plomb de 12 volts et un transformateur, toutes les options peuvent être utilisées.

Version proto sur Uno

La première version a été développée sur Uno Board avec un minimum de matériel et un minimum d'options. L'écran Nokia a été directement monté et un blindage MOSFET a été développé pour prendre en charge la charge/décharge de la batterie. Il n'y a pas de contrôle de menu, pas d'onduleur, pas de charge PWM et des fonctionnalités intéressantes ! Il suffit d'activer/de désactiver la charge et d'afficher les niveaux de tension de la batterie et du panneau. Fait le job mais n'a pas de charme !

Version complète sur Protoboard

Ensuite, j'ai développé ce nouveau avec les fonctionnalités suivantes :

• Contrôleur de charge solaire PWM jusqu'à panneau de 100 watts
• Onduleur mini 60 watts à onde carrée
• Jusqu'à trois commandes de charge 12 volts CC
• La charge CC principale prend en charge les fonctions d'activation/désactivation automatique
• Une banque d'alimentation USB indépendante
• Module régulateur Buck
• Lampe LED d'urgence à bord avec contrôle du clignotement et de la luminosité

Menu de défilement et de sélection contrôlé par 2 boutons/interrupteurs pour le contrôle de l'utilisateur, affichant les options et les informations d'état sur l'écran du Nokia 5110. Très cool! La face arrière est isolée par colle chaude pour une protection contre les courts-circuits contre les objets métalliques !

Il existe quelques fonctionnalités plus pratiques telles que l'interrupteur marche/arrêt pour le rétroéclairage de l'écran, séparant le mâle pour un fonctionnement indépendant en éteignant la batterie interne.

L'accès au menu sur l'écran du Nokia 5110 avec le bouton utilisateur est illustré ici :

Apprenons quelques trucs techniques!

Le contrôleur de charge peut être de type On/Off, PWM ou MPPT. On/Off est la forme la plus simple (ma version 1 - image ci-dessus) de contrôleur qui ne limite pas le courant de charge lorsque la tension de la batterie s'approche de sa pleine tension de charge.

Alors que PWM diminue progressivement le courant de charge à mesure que la batterie se remplit. Le contrôleur PWM présente les avantages suivants :

• Aide à récupérer la capacité perdue de la batterie et à désulfater une batterie
• Augmente la capacité de la batterie à accepter plus de charge
• Maintenir des capacités de batterie moyennes élevées jusqu'à 95 %
• Égalisez les cellules de batterie à la dérive, afin que les cellules internes puissent atteindre le même potentiel
• Réduire l'échauffement et le dégagement de gaz de la batterie, empêchant ainsi la perte d'électrolyte
• Ralentit le vieillissement et prolonge la durée de vie du système

Mais PWM ne peut pas tirer la majeure partie de l'énergie électrique des panneaux solaires photovoltaïques, car il entraîne le panneau à fonctionner près de la tension de la batterie. MPPT est la solution à ce problème qui est essentiellement un convertisseur buck-boost réglable CC à CC, il peut convertir la majeure partie de l'énergie solaire par rapport au contrôleur PWM.

Les onduleurs peuvent être des types à onde carrée, à onde sinusoïdale modifiée et à onde sinusoïdale pure. L'onduleur à onde carrée est de conception très simple et de petites charges CC suffisantes comme les lampes CA, les lampes CFL, les ventilateurs de table, les fers à souder, mais il n'est pas recommandé pour les moteurs inductifs, les équipements/alimentations délicats en raison de la distorsion harmonique.

L'onde sinusoïdale modifiée est une sorte d'onde sinusoïdale retardée créée à partir d'ondes carrées, mieux que les onduleurs à onde carrée. Les onduleurs à onde sinusoïdale sont les meilleurs pour tous les types de charge, mais le matériel est complexe à concevoir, l'algorithme logiciel difficile à utiliser et coûteux à fabriquer.

Un régulateur buck est un convertisseur DC-DC abaisseur, ici j'ai utilisé un module buck pour charger la batterie Li-ion de 4,2 V qui alimente le contrôleur (Arduino + écran), la banque d'alimentation USB indépendante, la lampe LED intégrée.

Maintenant, la banque d'alimentation USB est essentiellement un boost DC-DC qui peut convertir une plage de tensions inférieure à 5 (comme une plage de 3,3 à 4,2 volts) d'une batterie Li-ion ou LiPo à 5 volts qui est la tension du bus USB qui peut charger les appareils mobiles .

Il dispose également d'un convertisseur buck pour charger cette batterie. Dans mon projet, le module buck prend du jus du panneau pour charger la batterie interne (à bord).

Fonctionnement du matériel

Avant d'entrer dans les détails, vérifiez cette image de tout ce qui est connecté autour de l'appareil :

Le système dispose de divers matériels pour servir à des fins différentes. Bien sûr, le cerveau est un microcontrôleur AVR Atmega8A (peut être utilisé Atmega328P avec des modifications mineures, discutées ci-dessous) qui est programmé dans Arduino.

Un Atmega8A frais est gravé avec le chargeur de démarrage Arduino Optiboot8, vous pouvez acheter un Arduino Mini/Atmega328 bootloadé pour éviter les tracas.

Le contrôleur, l'écran, la lampe LED et la banque d'alimentation sont alimentés par une batterie Li-ion embarquée. Deux boutons tactiles momentanés permettent d'accéder au menu affiché, ce qui permet à l'utilisateur d'utiliser différentes fonctions de l'appareil. Les commutateurs sont anti-rebonds matériels via des condensateurs de lissage qui sont connectés en parallèle.

Un interrupteur à glissière permet d'allumer/éteindre l'appareil selon les besoins.

La fonction de charge solaire est réalisée par un P-MOSFET piloté par un circuit de pilotage basé sur un transistor 2N2222 qui est contrôlé via PWM à partir d'un microcontrôleur. Le PWM est contrôlé en fonction du niveau de tension de la batterie externe. Le courant des panneaux solaires traverse le P-MOSFET jusqu'à la batterie au plomb. Lorsque la batterie est complètement chargée, le MOSFET est désactivé à partir du microcontrôleur. Une fois la charge désactivée, la tension de la batterie commence à baisser progressivement, lorsqu'elle atteint 13,6 volts, la charge reprend avec un faible cycle de service pour maintenir la charge d'entretien.

La charge de 12 volts CC est contrôlée via un N-MOSFET en contrôlant sa broche Gate à partir du microcontrôleur.

La LAMPE LED embarquée est également pilotée par un NMOS. La porte de ce MOSFET est contrôlée par PWM pour le réglage de la luminosité de la LED.

Le bloc onduleur est composé de 2 N-MOSFET qui sont alternativement activés/désactivés pour simuler le courant alternatif. En ajoutant un transformateur à prise centrale externe, une alimentation CA à onde carrée peut être réalisée.

La figure suivante explique l'action de l'onduleur :

En permettant au courant de traverser la prise centrale de la bobine d'un transformateur élévateur dans le sens opposé en utilisant alternativement des MOSFET, une tension alternative au secondaire peut être créée. Cela se produit parce que lorsque le MOSFET supérieur est allumé et que le MOSFET inférieur est éteint, le courant circule vers le haut. Mais lorsque le MOSFET supérieur est éteint et que le MOSFET inférieur est allumé, le courant circule vers le bas.

Les deux MOSFET doivent être basculés à deux fois la fréquence du courant alternatif. Vérifiez l'image suivante pour la comprendre :

Pour créer du courant alternatif à 50 Hz, une onde carrée alternative est appliquée sur le côté bas du transformateur à prise centrale 12-0-12V/220V. 50 Hz signifie 20 ms de temps pour chaque onde.

C'est pourquoi 20 ms/2 =10 ms ou 100 fois Basculez les signaux de porte appliqués au transformateur pilotant les MOSFET (MOSFET à onduleur).

Attention !!! :La tension alternative est mortelle pour l'homme, peut causer la mort/des blessures ! Ne touchez jamais le côté HT du transformateur à main nue !

Si la fonction onduleur n'est pas utilisée, l'option de charge 2XDC permet d'utiliser deux autres charges 12 volts CC à la borne de l'onduleur.

Magie du logiciel

Deux jeux de code sont fournis, l'un est le code complet dans un seul onglet Arduino, l'autre est le code à onglets selon des fonctions distinctes.

J'ai généralisé un groupe de tâches en une seule fonction.

Par exemple :

Get_ADCVal() mesurera les tensions du panneau, de la batterie interne et de la batterie externe, prendra 20 échantillons, fera la moyenne de ces valeurs et mettra à jour les informations de tension de maintien variable.

Context_Control() effectuera l'interaction utilisateur, le contrôle d'action, la mise à jour des informations sur les activités liées à l'affichage.

Charging_Control () , Discharge_Control (), Load_Control () sont des fonctions d'arrière-plan qui agissent comme BOUCLE DE FERMETURE pour le système, surveille le niveau de tension de la batterie, contrôle la fonction de charge automatique, le contrôle de protection contre les surcharges/décharges profondes, etc.

Les entrées de l'utilisateur sont collectées via des interrupteurs à pression momentanés commandés par interruption. Lorsque ces commutateurs sont enfoncés, les ISR liés à INT0/INT1 sont exécutés. Deux variables volatiles dp et ds changements. Une autre troisième variable niveau avec dp (pointeur d'affichage ->) et ds (sélecteur de contenu d'affichage) permet à l'utilisateur de parcourir le menu/sous-menu et d'effectuer l'action requise.

Le TImer1 16 bits de l'AVR est configuré pour générer une interruption de débordement du temporisateur toutes les 10 ms et bascule PIN_INVP et PIN_INVN lorsque la fonction de l'onduleur est activée.

Toutes les fonctions Lcd_....() ont quelque chose à voir avec le contrôle d'affichage .

Atmega8A contre Atmega328P (Uno)

Le système peut être facilement mis à niveau pour fonctionner avec Atmega328P/Uno en apportant les modifications suivantes au code. Rechercher et remplacer

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

Dans la partie hardware vous devez utiliser une résistance de 8.2K au lieu de 22K pour réduire le panneau, les tensions de la batterie à la plage de mesure ADC.

Vidéos d'action

En général, je ne lis pas que des mots sur un projet, je commence plutôt par lire la vidéo. Si vous êtes comme moi, profitez des vidéos :

Portée de l'amélioration

J'ai manqué d'espace Flash dans Atmega8A. Impossible d'ajouter certaines fonctionnalités critiques telles que :

• Protection contre les surcharges/courts-circuits contrôlée par logiciel
• Quelques icônes graphiques et un logo
• Mesure de l'énergie et exploitation forestière
• Estimation et alarme pour le temps de sauvegarde
• Option de recharge pour ordinateur portable
• Prise en charge du système 6 volts
• Contrôle de la charge Bluetooth
• Contrôle de charge basé sur une minuterie
• Une horloge RTC pour des fonctionnalités plus intéressantes
• Solution connectée IoT

Si vous avez l'intention de faire quelque chose comme ça, n'oubliez pas d'ajouter certaines de ces fonctionnalités !

Atmega328P(Uno) ou Arduino Mega pourraient être un meilleur candidat pour inclure toutes ces options.

En tout cas, ça fait le job, j'en suis content.

Ressources supplémentaires

• Téléchargez Arduino 1. 0. 6 avec prise en charge de la carte Atmega8
• Ouvrez Arduino.exe, allez dans Outils> Carte> Optiboot8
• Graver le bootloader en utilisant cette méthode
• Compiler et télécharger le code

Code

• Code à onglet unique
• Code complet
• Chargeurs de démarrage

Code à onglet unique 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 // Charge 12 v cc#define PIN_LAMP 10 // LUMIÈRE LED BLANC #define PIN_BATTPWM 11 // Drives PMOS pour Ext BAtt Charging #define PIN_BATTint_Sense A2#define PIN_SOLAR_Sense A0#define PIN_BATText_Sense A3#define ADC_VREF 2.695 // tension de référence interne, environ 1.11V pour Arduino Uno aka Atmega328P, voici mon Atme328P, ici mon Atme328P define ADCVDIV_R1 22 // 22 K diviseur de tension résistance inférieure#define ADCVDIV_R2 175 // 175 K diviseur de tension résistance supérieure//const uint8_t skulljoke[] PROGMEM ={2,};// PIN 2 &3 UTILISÉS COMME INTERRUPTEUR D'INTERRUPTION// 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;volatile int y=0;volatile uint8_t dp =0;volatile uint8_t ds =0;volatile0 cycle=volatile uint8_t cdc_level =0;//int i;void setup(void){ LcdInitialise(); LcdClear(); LcdString("*ARDUBOY PV*"); LcdString(" CONTRLEUR,"); LcdString("ONDULEUR CA,"); LcdString("POWER BANK, "); LcdString("LAMPE CHOSE !!!"); retard (3000); analogReference(INTERNE); 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); // Interruption pour Swithc 1 pinMode (3, INPUT_PULLUP); attachInterrupt(1, SW2, FALLING);// Interruption pour Swithc 2 }void loop(void){ Get_ADCVal();Context_Control();Charging_Control();Discharge_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); }// tension moyenne 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_PV_Voltage/1023.0;AD_Voltage/1023.0;AD_Voltage=1023.0; ////////// Affichage et contrôle //////////////void Context_Control(void){ if(ds==0) ​​{show_menu();} if(ds==1 &&dp ==0) {show_info(); delay(100);} //LcdClear();Get_ADCVal();}//////////////////////Entre le 1er sous-menu ////// ///////////////////// if(ds==1 &&dp ==1) { level=1; dp=0 ; while(level==1) { int temp=ds; LcdClear(); show_load_ctrl();delay(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;} } }/////////////////////Entre dans le 2e sous-menu /////////// ///////////////////if(ds==1 &&dp ==2) { level=2; dp=0 ; while(niveau==2) { int temp=ds; show_inv_ctrl();delay(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;} } } ///////////////////////////////////// ////////////////// /////////////// Entre dans le 3e sous-menu /////////// //////////////////if(ds==1 &&dp ==3) { level=3; dp=0 ; while(niveau==3) { int temp=ds; LcdClear(); show_led_ctrl();delay(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) {clignotant^=1;analogWrite(PIN_LAMP,127);delay(250);analogWrite(PIN_LAMP,0);}} si (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);}}/////////////////////// /// Menu Texte à afficher sur l'écran Nokia 5110 ///////////////////void show_menu(void){LcdXY(0,dp);LcdString("->" );LcdXY(15,0);LcdString("Infos système");LcdXY(15,1);LcdString("Charge CC+");LcdXY(15,2);LcdString("Charge CA~");LcdXY( 15,3) ;LcdString("Lampe 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("Charging:ON ");}else{LcdString("Charging:OFF");}if (TCNT1>=45535){LcdString ("Onduleur:ON");}else{LcdString("Onduleur:OFF");}}void show_load_ctrl(void){LcdXY(0,dp);LcdString("->");LcdXY(15,0); LcdString("Charger désactivé");LcdXY(15,1);LcdString("Charger activé");LcdXY(15,2);LcdString("Charger auto");LcdXY(15,3);LcdString("Retour" );LcdXY(0,4);LcdString("Doit se connecter");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 DÉSACTIVE");LcdXY(0,5);LcdString("Lorsque INVR activé");}// //////////// Interruption des ISR //////////////void SW1(){dp++;if(dp>
3){dp=0;} }void SW2 (){ds^=1;} ISR(TIMER1_OVF_vect) { noInterrupts(); TCNT1 =45535 ; // TCNT1 =25535; cycle^=1 ; si(cycle==0) ; { digitalWrite(PIN_INVP,HIGH); délaiMicrosecondes(1) ; // bande morte digitalWrite(PIN_INVN,LOW); délaiMicrosecondes(1) ; } if(cycle==1) { digitalWrite(PIN_INVP,LOW); délaiMicrosecondes(1) ; // bande morte digitalWrite(PIN_INVN,HIGH); délaiMicrosecondes(1) ; } interruption(); }/////////////Fonctions Nokia 5110 //////////octet de const statique 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 } // 50P,{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 j,{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 ans,{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(character){ LcdWrite(LCD_D, 0x00); for (int index =0; index <5; index++) { LcdWrite(LCD_D, ASCII[caractère - 0x20][index]); } LcdWrite(LCD_D, 0x00);}void LcdClear(void){ pour (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 Charge désactivée, 13,5 ou moins Charge activée, 10,8 Charge désactivée, 12,5 Charge activée // cette prochaine condition empêche les tentatives de charge pendant la nuit % PV nocturne est de 0 volt !if (PV_Voltage> 10,5 &&BattExt_Voltage> 8,0){if (BattExt_Voltage <=12,5) { analogWrite(PIN_BATTPWM,255); niveau_cdc =0 ; } if (BattExt_Voltage> 12,5 &&BattExt_Voltage <=12,9) { analogWrite(PIN_BATTPWM,200); niveau_cdc =1 ; } if (BattExt_Voltage> 12,9 &&BattExt_Voltage <=13,3) { analogWrite(PIN_BATTPWM,160); niveau_cdc =1 ; } if (BattExt_Voltage> 13,3 &&BattExt_Voltage <=13,6) { analogWrite(PIN_BATTPWM,120); niveau_cdc =2 ; } if (BattExt_Voltage> 13,6 &&BattExt_Voltage <=13,9 &&cdc_level ==2) { analogWrite(PIN_BATTPWM,80); niveau_cdc =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 &Readable
No preview (download only).
 
BootloadersC/C++ 
 
Aucun aperçu (téléchargement uniquement).
 

Schémas