Fabrication industrielle
Internet des objets industriel | Matériaux industriels | Entretien et réparation d'équipement | Programmation industrielle |
home  MfgRobots >> Fabrication industrielle >  >> Manufacturing Technology >> Processus de fabrication

Arduino - Chargeur solaire PV MPPT

Composants et fournitures

Arduino Nano R3
× 1
Inducteur 100 uH
les valeurs nominales actuelles doivent correspondre à la puissance requise.
× 1
Power MOSFET N-Channel
× 1
Adafruit Standard LCD - 16x2 Blanc sur Bleu
× 1

Outils et machines nécessaires

Fer à souder (générique)

Applications et services en ligne

Arduino IDE

À propos de ce projet

Il existe de nombreux contrôleurs de charge disponibles sur le marché, mais les contrôleurs de charge bon marché ordinaires ne sont pas efficaces pour une utilisation avec la puissance maximale des panneaux solaires. Et celles qui sont efficaces sont très coûteuses.

J'ai donc décidé de créer mon propre contrôleur de charge pour qu'il soit suffisamment efficace et intelligent pour comprendre les besoins de la batterie et les conditions solaires. Il prend les mesures appropriées pour tirer le maximum d'énergie disponible de l'énergie solaire et la placer très efficacement dans la batterie.

Si vous aimez mes efforts, alors s'il vous plaît votez pour ce tutoriel.

Étape 1 :Qu'est-ce que MPPT et pourquoi en avons-nous besoin ?

Nos panneaux solaires sont stupides et pas assez intelligents pour comprendre les conditions de la batterie. Supposons que nous ayons un panneau solaire de 12 V/100 watts et qu'il donnera une sortie entre 18 V et 21 V selon les fabricants, mais les batteries sont conçues pour une tension nominale de 12 V. À pleine charge, ils seront de 13,6 V et de 11,0 V à pleine décharge. Supposons maintenant que nos batteries sont en charge de 13 V, les panneaux donnent 18 V, 5,5 A à 100% d'efficacité de fonctionnement (il n'est pas possible d'avoir 100% mais supposons). Les contrôleurs ordinaires ont un régulateur de tension PWM ckt qui fait chuter la tension à 13,6 sans aucun gain de courant. Il fournit uniquement une protection contre les surcharges et les courants de fuite aux panneaux pendant la nuit.

Pour contrer ce problème, j'ai utilisé le convertisseur smps buck. Ce type de convertisseur a une efficacité supérieure à 90 %. Même 90 % sont considérés comme pauvres.

Le deuxième problème que nous avons est la sortie non linéaire des panneaux solaires. Ils doivent fonctionner à une certaine tension pour récolter le maximum de puissance disponible. Leur sortie varie au cours de la journée.

Pour résoudre ce problème, des algorithmes MPPT sont utilisés. MPPT (Maximum Power Point Tracking), comme son nom l'indique, cet algorithme suit la puissance maximale disponible des panneaux et fait varier les paramètres de sortie pour maintenir la condition.

Ainsi, en utilisant MPPT, nos panneaux généreront une puissance maximale disponible et le convertisseur buck mettra efficacement cette charge dans les batteries.

Étape 2 : Comment fonctionne MPPT ?

Je ne vais pas en discuter en détail, donc si vous voulez le comprendre, jetez un œil à ce lien - Qu'est-ce que MPPT ?

Dans ce projet, j'ai également suivi les caractéristiques d'entrée V-I et la sortie V-I. En multipliant l'entrée V-I et la sortie V-I, nous pouvons avoir la puissance en watts.

Disons que nous avons 17 V 5 A, soit 17x5 =85 watts, à tout moment de la journée. En même temps notre sortie est de 13 V 6A, soit 13x6 =78 Watt.

Maintenant, MPPT augmentera ou diminuera la tension de sortie en la comparant à la puissance d'entrée/sortie précédente.

Si la puissance d'entrée précédente était élevée et que la tension de sortie était inférieure à celle actuelle, la tension de sortie sera à nouveau abaissée pour revenir à une puissance élevée. Et si la tension de sortie était élevée, la tension actuelle sera augmentée au niveau précédent. Ainsi, il continue d'osciller autour du point de puissance maximale. Ces oscillations sont minimisées par des algorithmes MPPT efficaces.

Étape 3 :Implémentation de MPPT sur Arduino

C'est le cerveau de ce chargeur. Vous trouverez ci-dessous le code Arduino pour réguler la sortie et implémenter MPPT dans un seul bloc de code.

// Iout =courant de sortie// Vout =tension de sortie// Vin =tension d'entrée// Pin =puissance d'entrée, Pin_previous =dernière puissance d'entrée// Vout_last =dernière tension de sortie, Vout_sense =tension de sortie actuellevoid réguler (float Iout, float Vin, float Vout) {
if((Vout>Vout_max) || (Iout>Iout_max) || ((Pin>Pin_previous &&Vout_senseVout_last) || (PinVout_last ))) { if(duty_cycle>0) { duty_cycle -=1 ; } analogWrite(buck_pin, duty_cycle); } else if ((VoutPin_previous &&Vout_sense>Vout_last) || (Pin cycle_service+=1 ; } analogWrite(buck_pin, duty_cycle); } Pin_previous =Pin; Vin_last =Vin;Vout_last =Vout;}

Étape 4 :Convertisseur Buck

J'ai utilisé un mosfet à canal N pour faire le convertisseur buck. Habituellement, les gens choisissent le mosfet du canal P pour la commutation côté haut et s'ils choisissent le mosfet du canal N dans le même but qu'un circuit intégré de pilote sera nécessaire ou le démarrage du cerclage ckt.

Mais j'ai modifié le convertisseur buck ckt pour avoir une commutation côté bas utilisant un mosfet à canal N. J'utilise le canal N car il s'agit d'un faible coût, d'une puissance nominale élevée et d'une dissipation de puissance inférieure. Ce projet utilise un mosfet de niveau logique IRFz44n, il peut donc être directement piloté par une broche Arduino PWM.

Pour un courant de charge plus élevé, il faut utiliser un transistor pour appliquer 10 V à la grille pour amener le mosfet à saturation complètement et minimiser la dissipation de puissance. J'ai fait de même.

Comme vous pouvez le voir dans ckt ci-dessus, j'ai placé le mosfet sur la tension -ve, utilisant ainsi +12v du panneau comme masse. Cette configuration me permet d'utiliser un mosfet à canal N pour un convertisseur buck avec un minimum de composants.

Mais il a aussi quelques inconvénients. Comme vous avez séparé la tension -Ve des deux côtés, vous n'avez plus de masse de référence commune. La mesure des tensions est donc très délicate.

J'ai connecté l'Arduino aux bornes d'entrée solaire, en utilisant sa ligne -Ve comme masse pour Arduino. Nous pouvons facilement mesurer la tension d'entrée à ce stade en utilisant un diviseur de tension ckt selon nos besoins. Mais nous ne pouvons pas mesurer la tension de sortie aussi facilement car nous n'avons pas de masse commune.

Maintenant, pour ce faire, il existe une astuce. Au lieu de mesurer la tension aux bornes du condensateur de sortie, j'ai mesuré la tension entre deux lignes -Ve. Utilisation de -Ve solaire comme masse pour l'Arduino et sortie -Ve comme signal/tension à mesurer. La valeur que vous avez obtenue avec cette mesure doit être soustraite de la tension d'entrée mesurée et vous obtiendrez la tension de sortie réelle aux bornes du condensateur de sortie.

Vout_sense_temp=Vout_sense_temp*0.92+float(raw_vout)*volt_factor*0.08 ; //mesure la tension entre la masse d'entrée et la masse de sortie.
Vout_sense=Vin_sense-Vout_sense_temp-diode_volt ; //changer la différence de tension entre deux masses en tension de sortie ..

Pour les mesures de courant, j'ai utilisé des modules de détection de courant ACS-712. Ils ont été alimentés par Arduino et connectés à l'entrée GND.

Les temporisateurs internes sont modifiés pour gagner 62,5 kHz PWM à la broche D6, qui est utilisée pour piloter le MOSFET. Une diode de blocage de sortie sera nécessaire pour fournir une protection contre les fuites inverses et l'inversion de polarité, utilisez une diode Schottky du courant nominal souhaité à cette fin. La valeur de l'inductance dépend de la fréquence et des exigences de courant de sortie. Vous pouvez utiliser les calculatrices de convertisseur buck disponibles en ligne ou utiliser une charge 100uH 5A-10A. Ne dépassez jamais le courant de sortie maximal de l'inducteur de 80 % à 90 %.

Étape 5 : dernière retouche

Vous pouvez également ajouter des fonctionnalités supplémentaires à votre chargeur. Les miens ont un écran LCD pour afficher les paramètres et 2 commutateurs pour prendre les entrées de l'utilisateur.

Je mettrai à jour le code final et terminerai le diagramme ckt très bientôt.

Étape 6 : Schéma de circuit réel, nomenclature et code

MISE À JOUR :

J'ai téléchargé le code, la nomenclature et le circuit. C'est légèrement différent du mien, car c'est plus facile à faire celui-ci.

Solar_charger_tutorial_code.ino

Code

  • Solar_charger_tutorial_code.ino
Solar_charger_tutorial_code.inoArduino
//////////////////////////////////////////// //////////////////////////////////////////Conditions d'utilisation///// ////////////////////////////////////////////////////////////// ////////////////////////////////LE LOGICIEL EST FOURNI "EN L'ETAT", SANS GARANTIE D'AUCUNE SORTE, EXPRESSE OU//IMPLICITE, Y COMPRIS MAIS NON LIMITÉ AUX GARANTIES DE QUALITÉ MARCHANDE,//ADAPTATION À UN USAGE PARTICULIER ET D'ABSENCE DE CONTREFAÇON. EN AUCUN CAS LES//AUTEURS OU TITULAIRES DE DROITS D'AUTEUR NE POURRONT ÊTRE TENUS RESPONSABLES DE TOUTE RÉCLAMATION, DOMMAGES OU AUTRE//RESPONSABILITÉ, QUE CE SOIT DANS UNE ACTION CONTRACTUELLE, DÉLICTUELLE OU AUTRE, DÉCOULANT DE,//DE OU EN RELATION AVEC LE LOGICIEL OU LA UTILISATION OU AUTRES OPÉRATIONS DANS//LE LOGICIEL.////////////////////////////////////// /////////////////////////////////////////////#include #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#define button 2#define led 13#define charge_led A5#define light 4uint8_t auto_mode=1;float Pin=0,Pout=0,Pin_previous=0;float efficacite=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_sense,Vin_therm;;float Vin_sense;uint8_t duty_cycle =0;float volt_factor =0,05376; //modifier cette valeur pour calibrer les lectures de tension...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(String data,int column, int row);void UI();void set_limits(int cmd,int temp);void mem_read();void mem_write();void mppt(); void setup() { wdt_disable(); watchdogSetup(); // mettez votre code de configuration ici, à exécuter une fois : Serial.begin(115200);mem_read();pinMode(light,OUTPUT);pinMode(charge_led,OUTPUT);digitalWrite(charge_led,LOW);digitalWrite(light,HIGH);pinMode(led,OUTPUT);pinMode(fan,OUTPUT);pinMode(menu,INPUT);pinMode(bouton,INPUT);digitalWrite(menu,HIGH);digitalWrite(bouton,HIGH);TCCR0B =TCCR0B &0b11111000 | 0x01 ; / set pwm à Max... 62.5 KhzanalogWrite(buck_pin,0);lcd.begin(16,2);lcd_show("Solar Charger",0,0);delay(64000);wdt_reset();delay(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);delay(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; //décommentez si vous utilisez LM235}//////////void watchdogSetup(void){cli(); // désactive toutes les interruptionswdt_reset(); // réinitialiser le minuteur WDT// Entrer en mode de configuration du chien de garde :WDTCSR |=(1<Vout_max) || (Iout>Iout_max) || ((Pin>Pin_previous &&Vin_senseVin_last))) { if(duty_cycle>0) { duty_cycle-=1; } analogWrite(buck_pin, duty_cycle); } else if((VoutPin_previous &&Vin_sense>Vin_last) || (PinIout_min+1){ charge =true; } ///////////// if((Vout>Vout_max) &&(Iout 80.0){ duty_cycle=0; analogWrite(buck_pin, duty_cycle); Serial.println("Over Heat Shutdown"); lcd_show("Échec de surchauffe ",0,1) ; wdt_reset(); for(int i=0;i<10;i++){ digitalWrite(led,HIGH); digitalWrite(charge_led,LOW); retard (4000); digitalWrite(charge_led,HIGH); digitalWrite(led,LOW); retard (4000); } wdt_reset(); } else { charge =vrai; digitalWrite(charge_led,HIGH); réguler (Iout_sense, Vin_sense, Vout_sense); digitalWrite(led,LOW); }}void soft_start() { for(int i=0;i<20;i++) { réguler(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);Série .print("MODE Chargeur :");Serial.println(mode);Serial.println("Démarrage progressif activé"); retard (32000); } démarrage=faux ; mppt_init =false;}void lcd_show(String data,int column, int row) { lcd.setCursor(column,row); 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++;}

Schémas


Processus de fabrication

  1. Bulldozer
  2. Cellule solaire
  3. Acquisition de données en temps réel d'un panneau solaire à l'aide d'Arduino
  4. Arduino Spybot
  5. FlickMote
  6. Téléviseur maison B-Gone
  7. horloge maîtresse
  8. Solar Tracker V2.0
  9. Énergie éolienne