Chargeur solaire MPPT Arduino pour une récolte optimale de l'énergie photovoltaïque

Composants et fournitures

Composant	Quantité	Notes
Arduino Nano R3	1
Inductance 100 µH	1	Le courant nominal doit correspondre à votre puissance requise.
MOSFET de puissance canal N	1
Écran LCD standard Adafruit 16x2 (blanc sur bleu)	1

Outils nécessaires

• Fer à souder (générique)

Applications et services en ligne

• Arduino IDE

À propos du projet

Il existe de nombreux contrôleurs de charge sur le marché, mais les contrôleurs bon marché ne sont pas efficaces pour exploiter la puissance maximale des panneaux solaires. Ceux qui sont efficaces sont très coûteux. J'ai donc décidé de créer mon propre contrôleur de charge, à la fois efficace et assez intelligent pour comprendre les besoins de la batterie et les conditions solaires. Il prend les mesures appropriées pour tirer la puissance maximale disponible du panneau solaire et la stocker dans la batterie de manière très efficace.

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

Nos panneaux solaires ne sont pas assez intelligents pour comprendre l'état de la batterie. Imaginons un panneau 12V/100W qui délivre 18-21V selon les fabricants, tandis que les batteries sont en 12V nominal. À charge complète, elles sont à 13,6V et à décharge complète à 11,0V. Supposons une batterie à 13V en charge, le panneau donne 18V, 5,5A à 100% d'efficacité (théorique). Les contrôleurs ordinaires ont un régulateur de tension PWM qui abaisse la tension à 13,6V sans gain de courant. Ils ne font que protéger contre la surcharge et les courants de fuite nocturnes.

Pour contrer cela, j'ai utilisé un convertisseur abaisseur (buck) SMPS. Ce type de convertisseur a un rendement supérieur à 90%. Même 90% est considéré comme médiocre.

Le second problème est la sortie non-linéaire des panneaux solaires. Ils doivent fonctionner à une tension précise pour récolter la puissance maximale. Leur sortie varie au cours de la journée. Pour résoudre ce problème, on utilise des algorithmes MPPT (Maximum Power Point Tracking). Comme leur nom l'indique, cet algorithme suit la puissance maximale disponible des panneaux et varie les paramètres de sortie pour maintenir cette condition.

Ainsi, avec le MPPT, nos panneaux génèrent la puissance maximale disponible et le convertisseur abaisseur injecte cette charge efficacement dans les batteries.

Étape 2 : Comment fonctionne le MPPT ?

Je ne vais pas entrer dans les détails, mais vous pouvez consulter ce lien pour comprendre : Qu'est-ce que le MPPT ?

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

Exemple : 17V 5A = 85W à un instant donné. En même temps, la sortie est 13V 6A = 78W. Le MPPT augmentera ou diminuera la tension de sortie en comparant avec la puissance d'entrée/sortie précédente. Si la puissance d'entrée précédente était plus élevée et la tension de sortie plus basse qu'actuellement, la tension de sortie sera à nouveau abaissée pour revenir à la haute puissance. Et si la tension de sortie était plus haute, la tension actuelle sera augmentée au niveau précédent. Ainsi, il oscille autour du point de puissance maximale. Ces oscillations sont minimisées par des algorithmes MPPT efficaces.

Étape 3 : Implémentation du MPPT sur Arduino

C'est le cerveau de ce chargeur. Voici le code Arduino pour réguler la sortie et implémenter le MPPT en un seul bloc.

// 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 actuelle

void regulate(float Iout, float Vin, float Vout) {
  if ((Vout > Vout_max) || (Iout > Iout_max) || ((Pin > Pin_previous && Vout_sense < Vout_last) || (Pin < Pin_previous && Vout_sense > Vout_last))) {
    if (duty_cycle > 0) duty_cycle -= 1;
    analogWrite(buck_pin, duty_cycle);
  } else if ((Vout < Vout_max) && (Iout < Iout_max) && ((Pin > Pin_previous && Vout_sense > Vout_last) || (Pin < Pin_previous && Vout_sense < Vout_last))) {
    if (duty_cycle < 240) duty_cycle += 1;
    analogWrite(buck_pin, duty_cycle);
  }
  Pin_previous = Pin;
  Vin_last = Vin;
  Vout_last = Vout;
}

Étape 4 : Convertisseur abaisseur (Buck Converter)

J'ai utilisé un MOSFET canal N pour réaliser le convertisseur abaisseur. Habituellement, on choisit un MOSFET canal P pour la commutation côté haut, et si on utilise un canal N pour le même usage, un circuit de driver IC ou de bootstrap est nécessaire. Mais j'ai modifié le circuit pour avoir une commutation côté bas avec un MOSFET canal N. J'utilise le canal N car ils sont peu coûteux, ont de hautes puissances nominales et une dissipation de puissance plus faible. Ce projet utilise un MOSFET IRFZ44N à niveau logique, pilotable directement par une broche PWM Arduino.

Pour des courants de charge plus élevés, il faut utiliser un transistor pour appliquer 10V à la grille afin de saturer complètement le MOSFET et minimiser la dissipation. C'est ce que j'ai fait.

Comme on le voit sur le schéma, j'ai placé le MOSFET sur la tension -V, utilisant ainsi le +12V du panneau comme masse. Cette configuration permet d'utiliser un MOSFET canal N pour le convertisseur abaisseur avec un minimum de composants. Mais cela a des inconvénients : les deux côtés -V sont séparés, il n'y a plus de masse de référence commune. La mesure des tensions devient donc délicate.

J'ai connecté l'Arduino aux bornes d'entrée du panneau, utilisant sa ligne -V comme masse pour l'Arduino. On peut facilement mesurer la tension d'entrée avec un diviseur de tension. Mais on ne peut pas mesurer la tension de sortie aussi facilement car il n'y a pas de masse commune. L'astuce consiste à mesurer la tension entre les deux lignes -V. En utilisant le -V du panneau comme masse pour l'Arduino et le -V de sortie comme signal à mesurer. La valeur obtenue doit être soustraite de la tension d'entrée mesurée pour obtenir la vraie tension de sortie aux bornes du condensateur de sortie.

Vout_sense_temp = Vout_sense_temp * 0.92 + float(raw_vout) * volt_factor * 0.08; // mesure tension entre masse entrée et masse sortie
Vout_sense = Vin_sense - Vout_sense_temp - diode_volt; // conversion en tension de sortie réelle

Pour les mesures de courant, j'ai utilisé des modules ACS-712 alimentés par l'Arduino et connectés à la masse d'entrée. Les timers internes sont modifiés pour obtenir un PWM de 62,5 kHz sur la broche D6, qui pilote le MOSFET. Une diode de blocage en sortie est nécessaire pour la protection contre les fuites inverses et l'inversion de polarité ; utilisez une diode Schottky du courant nominal souhaité. La valeur de l'inductance dépend de la fréquence et des besoins en courant de sortie. Vous pouvez utiliser des calculateurs de convertisseur buck en ligne ou une inductance 100µH 5A-10A. Ne dépassez jamais 80-90% du courant maximal de l'inductance.

Étape 5 : Finitions

Vous pouvez ajouter des fonctionnalités supplémentaires à votre chargeur. Le mien possède un LCD pour afficher les paramètres et 2 interrupteurs pour la saisie utilisateur. Je mettrai à jour le code final et le schéma complet très bientôt.

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

MISE À JOUR : J'ai mis en ligne le code, la nomenclature et le schéma. C'est légèrement différent du mien car c'est plus facile à réaliser.

Solar_charger_tutorial_code.ino

Code complet

Solar_charger_tutorial_code.ino (Arduino)

///////////////////////////////////////////////////////////////////////////////////////
// Terms of use
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND...
///////////////////////////////////////////////////////////////////////////////////////
#include <LiquidCrystal.h>
#include <avr/wdt.h>
#include <EEPROM.h>

#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 4

uint8_t auto_mode = 1;
float Pin=0, Pout=0, Pin_previous=0;
float efficiency=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_last;
float heat_sink_temp;
float Vin_sense;
uint8_t duty_cycle = 0;
float volt_factor = 0.05376; // à calibrer pour 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 watchdogSetup(void);

void setup() {
  wdt_disable();
  watchdogSetup();
  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(button, INPUT);
  digitalWrite(menu, HIGH);
  digitalWrite(button, HIGH);
  TCCR0B = TCCR0B & 0b11111000 | 0x01; // PWM 62.5 kHz
  analogWrite(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);
  // ... initialisation capteurs (moyenne sur 10 lectures)
}

void watchdogSetup(void) {
  cli();
  wdt_reset();
  WDTCSR |= (1< Vout_max) || (Iout > Iout_max) || ((Pin > Pin_previous && Vin_sense < Vin_last) || (Pin < Pin_previous && Vin_sense > Vin_last))) {
    if (duty_cycle > 0) duty_cycle -= 1;
    analogWrite(buck_pin, duty_cycle);
  } else if ((Vout < Vout_max) && (Iout < Iout_max) && ((Pin > Pin_previous && Vin_sense > Vin_last) || (Pin < Pin_previous && Vin_sense < Vin_last))) {
    if (duty_cycle < 250) duty_cycle += 1;
    analogWrite(buck_pin, duty_cycle);
  }
  Pin_previous = Pin;
  Vin_last = Vin;
}

void auto_cutoff(float Iout, float Vin, float Vout) {
  if (Vout <= Vout_float && Iout > Iout_min + 1) charge = true;
  if ((Vout > Vout_max) && (Iout < Iout_min) && (charge == true)) {
    charge = false;
    Serial.println("Charging Completed.");
    digitalWrite(led, HIGH);
    digitalWrite(charge_led, LOW);
  } else if (Vin < Vin_thresold) {
    duty_cycle = 0; analogWrite(buck_pin, duty_cycle);
    Serial.println("LOW Input Voltage.");
    lcd_show("Input Volt. Low ", 0, 1);
    wdt_reset();
    for (int i=0; i<10; i++) {
      digitalWrite(led, HIGH); digitalWrite(charge_led, LOW); delay(6000);
      digitalWrite(charge_led, HIGH); digitalWrite(led, LOW); delay(6000);
    }
    wdt_reset();
  } else if (heat_sink_temp > 80.0) {
    duty_cycle = 0; analogWrite(buck_pin, duty_cycle);
    Serial.println("Over Heat Shutdown");
    lcd_show("Over Heat Fail ", 0, 1);
    wdt_reset();
    for (int i=0; i<10; i++) {
      digitalWrite(led, HIGH); digitalWrite(charge_led, LOW); delay(4000);
      digitalWrite(charge_led, HIGH); digitalWrite(led, LOW); delay(4000);
    }
    wdt_reset();
  } else {
    charge = true; digitalWrite(charge_led, HIGH);
    regulate(Iout_sense, Vin_sense, Vout_sense);
    digitalWrite(led, LOW);
  }
}

void soft_start() {
  for (int i=0; i<20; i++) {
    regulate(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("Charger MODE : "); Serial.println(mode);
    Serial.println("Soft Start Activated");
    delay(32000);
  }
  startup = false; 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

Schémas

Ventilateur pulmonaire open-source COVID-19 : système de soutien respiratoire DIY basé sur Arduino Construire un robot voiture 4WD à télécommande IR avec Arduino