Réalisation d'un MPPT : Charge et décharge sous isis proteus

Je me tourne vers vous aujourd'hui après longue reflexion sur mon sujet qui date déjà.

En effet je dois réaliser un MPPT. Pour cela j'ai choisi les outils suivant :

Un panneau solaire
Une carte arduino méga 2560
Un hacheur abaisseur
Une batterie
Je suis présentement dans la phase simulation et je rencontre plusieurs problème donc j'aimerais résoudre l'un après l'autre.

Le premier qui me bloque vraiment est que je n'arrive pas simuler la charge et la décharge de ma batterie. Pour cela implore votre aide afin de résoudre ce problème.

NB : Pour ma simulation j'ai essayé de mettre la batterie en série avec une résistance mais je n'observe rien, j'ai même essayé de me un générateur de tension en série avec une résistance mais toujours rien.

Je vous remercie d'avance et je me tiens disponible pour toute incomprehension.




Voici le code utilisé avec arduino méga 2560


#include <LiquidCrystal.h>
#include "TimerOne.h" // using Timer1 library from https://playground.arduino.cc/Code/Timer1/


#include <LiquidCrystal.h>
#include "TimerOne.h" // using Timer1 library from https://playground.arduino.cc/Code/Timer1/



// Definition de l'utilité des broches
#define PWM10 10 // 10 Timer 2
#define Led13 13 // 13 pour la led jaune sur la carte
#define BP1 30 // 30 BP1
#define BP2 31 // 31 BP2
#define PWM_MAX 100 // the value for pwm duty cyle 0-100%
#define PWM_MIN 60 // the value for pwm duty cyle 0-100%
#define PWM_START 90 // the value for pwm duty cyle 0-100%


LiquidCrystal monEcran(27,28,25,24,23,22); // on crée l'objet écran


/* Code d'exemple pour la fonction analogRead().

• /

float Vn ; // Pn_1 Represente Pn qui est la valeur de la tension du panneau
float Vb ; // Pn Represente Pn qui est la valeur de la tension du batterie
float In; // C'est le courant du panneau
float Pn ; //puissance panneau
float Pn_1 = 0; // Pn_1 Represente Pn-1 qui est la valeur précedente de Pn
float Vn_1 = 0; // Pn_1 Represente Pn-1 qui est la valeur précedente de Pn
byte K=1;
byte pwm ; //pwm duty cycle 0-100%
//int consigne = 8;




// Fonction setup(), appelée au démarrage de la carte Arduino
void setup()
{

monEcran.begin(20,4); //on initialise la communication avec 20 colonnes et quatre lignes

TCCR2B = TCCR2B & 0b11111000 | 0x01; //Division de fréquence par 1 //fréquence : 32500Hz, 7692Hz,

pinMode(PWM10, OUTPUT );
pinMode(Led13, OUTPUT); //led carte arduino
Timer1.initialize(300000); // initialize timer1, and set a 0,1 second period => 100 000 pour 0.01s 10 000
Timer1.attachInterrupt(callback); // attaches callback() as a timer overflow interrupt

// analogWrite(PWM10, 128);
//qui est à la nouvelle fréquence choisit


}


//Fonction de réglage de la pwm

//void Rapport_cyclic_pwm(void)
//{
// if (pwm > PWM_MAX) // check limits of PWM duty cyle and set to PWM_MAX
// {
// pwm = PWM_MAX;
// }
// else if (pwm < PWM_MIN) // if pwm is less than PWM_MIN then set it to PWM_MIN
// {
// pwm = PWM_MIN;
// }
//
// if (pwm < PWM_MAX)
// {
// Timer1.pwm(PWM10,(PWM_FULL * (long)pwm / 100), 20); // use Timer1 routine to set pwm duty cycle at 20uS period
// //FlexiTimer2.pwm(PWM_PIN,(PWM_FULL * (long)pwm / 100));
// }
// else if (pwm == PWM_MAX) // if pwm set to 100% it will be on full but we have
// {
// Timer1.pwm(PWM10,(PWM_FULL - 1), 1000); // keep switching so set duty cycle at 99.9% and slow down to 1000uS period
// //FlexiTimer2.pwm(PWM_PIN,(PWM_FULL - 1));
// }
//} // Fin de la fonction de réglage de la pwm

// Fonction loop(), appelée continuellement en boucle tant que la carte Arduino est alimentée
/* Fonction de la lecture des données*/
void callback() {
digitalWrite(Led13,HIGH); //mesure du temps de la routine
// Mesure la tension sur la broche A0
Vn = analogRead(A0);

// Mesure du courant sur la broche A1
In = analogRead(A1);

// Transforme la mesure (nombre entier) en tension du panneau Voltaïque via un produit en croix
Vn = Vn*25;
Vn = Vn/1023;

// Transforme la mesure (nombre entier) en courant du paneau
In = In*5;
In = In/1023;


// Mesure la tension sur la broche A0
Vb = analogRead(A2);

// Transforme la mesure (nombre entier) en tension du panneau Voltaïque via un produit en croix
Vb = Vb*25;
Vb = Vb/1023;

//on écrit simplement la valeur de 0 à 255 du rapport cyclique du signal

if(Pn>Pn_1)
{
if(Vn>Vn_1)
{
pwm = pwm-1;
//Rapport_cyclic_pwm();
}
else
{
pwm = pwm + 1;
//Rapport_cyclic_pwm();
}
}
else
{
if(Vn>Vn_1)
{
pwm = pwm+1;
// Rapport_cyclic_pwm();
}
else
{
pwm = pwm-1;
//Rapport_cyclic_pwm();
}
}


// delay(30); //utilisation timer0
Pn_1 = Pn;
Vn_1 = Vn;

digitalWrite(Led13,LOW); //mesure du temps de la routine
} //fin routine

/* Fonction qui permet d'afficher les données*/

void Affich_data(void)
{
monEcran.setCursor(0,0);
monEcran.print("Up");
monEcran.setCursor(5,0);
monEcran.print("Ip");

monEcran.setCursor(10,0);
monEcran.print("P");

monEcran.setCursor(15,0);
monEcran.print("pwm"); //Affiche le rapport cyclique

monEcran.setCursor(0,2);
monEcran.print("Vb");

// Envoi la mesure au (Vn,1);
// LCD pour affichage

monEcran.setCursor(0,1); //efface 1 ligne
monEcran.print(" ");
monEcran.setCursor(0,1);
monEcran.print(Vn,1);
// Envoi la mesure au LCD pour affichage
monEcran.setCursor(5,1);
monEcran.print(In, 1);

//Calcul de la puissance nominale
Pn= Vn*In;
monEcran.setCursor(10,1);
monEcran.print(Pn, 1); // Affichage au décimal près

monEcran.setCursor(15,1);
monEcran.print(pwm); // Affichage au décimal près

monEcran.setCursor(0,3);
monEcran.print( Vb, 1); // Affichage au décimal près
monEcran.setCursor(15,2); //colonne, ligne
monEcran.print("BP1"); //affichage BP1
}


void loop()
{

Affich_data();


} //fin loop