Décharge à 22A :
Tout d’abord, il faut changer le fusible de la batterie, de 20A à 30A.
Pour réaliser cette simulation avec une décharge importante, on ne peut plus utiliser le composant ACS712 20A, puisque le courant utilisé est trop important par rapport au courant maximal du composant. Pour cela on va utiliser un capteur de courant manuel.
Sur le banc résistif, pour cette simulation, 12 lampes servant de résistances sont implantées sur le banc résistif.
Comme expliqué précédemment, plus le courant de décharge est important, plus la batterie se décharge vite. Mais le temps de recharge reste le même, sauf si on augmente le courant de charge.
Pour cette simulation, on va inclure en plus un capteur de température LM35 pour connaître la température de la batterie.
Résultats de simulations :
Après avoir réalisé la première simulation, on s’est rendu compte que le fusible de 30A chauffait, car dès qu’on active le banc résistif, il y a un pic de courant pouvant aller jusqu’à 35A.
Pour remédier à ce problème, on va donc remplacer par un fusible de calibre 40A.
Sur la courbe des mesures (vert) on peut remarquer l’inflexion au départ comme elle a été trouvée précédemment sur le pack de batteries Phylion. Cependant le programme a réalisé le calcul des coefficients de A3 à A0 pour une régression de degré 3. Ainsi, on peut constater que l’estimation du SOH n’est plus très précise, et que la valeur finale du SOH est légèrement élevée par rapport aux autres courbes.
Avec cette inflexion, il serait plus judicieux de refaire un test avec la même intensité, mais en réalisant le calcul de A4 à A0 pour une régression polynomiale de degré 4.
Pour certains points sur les courbes, les estimations du SOH ne sont pas très précises par rapport aux coefficients qui peuvent être imprécis également, ou mal calculés à un instant donné.
A cet instant, on peut estimer le SOH de la batterie à environ 11A.h pour une tension de seuil à 2.7V. On a un peu plus de 10A.h puisque les premiers essais ont été réalisés avec une tension seuil de 3V. On rappelle qu’il ne faut pas instaurer une tension seuil trop faible pour ne pas dégrader la batterie.
Différents essais externes ont été réalisés sur le courant déchargé par la batterie, pour vérifier les données du capteur de courant. En effet, il faut ajuster bien correctement le « zéro » du capteur pour avoir les bonnes données.
Avec des mesures de la tension de la carte Arduino, on a remarqué que la tension d’alimentation de la carte était de 4.66V et non 5V comme indiqué. Cela est dû à la tension que l’ordinateur fourni par le câble USB.
De plus, sur le banc résistif, les lampes reliées entre elles peuvent réaliser une déperdition du courant à travers les différents câbles et dominos installés.
Un problème est survenu par rapport à la mesure et l’affichage du courant du capteur. Effectivement, la tension mesurée était trop basse pour que l’on puisse avoir des valeurs précises et correctes. On ne pouvait passer par exemple que de 0.5 à 1A mesuré, sans autres valeurs entre celles-ci.
Pour remédier à ce problème, on va donc utiliser un amplificateur opérationnel avec un gain de 10. C’est-à-dire qu’à la sortie de cet AOP, qui maintenant est l’entrée analogique mesurée, on va avoir une tension 10 fois plus importante (passage de 10mV à 100mV pour 1A). Pour avoir une valeur qui se rapproche de la valeur mesurée par ampèremètre, il faut ajouter un certain coefficient.
Voici le résultat Excel pour une décharge de 20A :
On peut remarquer que les premières valeurs ne sont pas représentatives du SOH de la batterie. Vers la fin de décharge on peut estimer à peu près à 10A.h la capacité de la batterie que l’on peut utiliser avant recharge. Cependant, vers 9.5A.h, la tension est inférieure à 2.7V, tension de seuil. Cela va donc faire le calcul d’un SOH, passant ainsi de 10A.h à 9A.h à peu près. C’est un souci puisque l’on souhaite déterminer la capacité totale que l’on peut utiliser sur une batterie, et donc avoir des résultats précis.
Une autre chose que l’on a remarqué, c’est la présence d’une tension différente de 5V. Donc deux solutions sont possibles. La première est d’instaurer un coefficient (4.66/5) multiplié par le résultat pour avoir la tension avec une alimentation de 4.66V. Ce coefficient pourrait être instauré sur Excel, et les calculs pourront être réalisés automatiquement via VBA.
Une autre solution serait de directement changer la valeur de tension d’alimentation sur Arduino. Mais ça ne peut être une bonne solution puisque nous n’avons pas tous une tension d’alimentation de 4.66V (cela varie selon les ordinateurs et câbles USB).
Le prochain test qui va être réalisé sera une décharge de 20A avec une tension d’alimentation de 4.66V.
Recherche du coefficient à implanter pour avoir une bonne visualisation et un bon calcul de la capacité :
Pour permettre d’avoir la bonne valeur sur l’écran LCD et donc un bon calcul de la capacité utilisée, il faut modifier le coefficient dans le calcul du courant dans le programme Arduino.
Au départ, le coefficient implanté était une division par 1023 pour avoir le résultat de la conversion de la valeur mesurée en volts. Il va falloir donc ajouter un coefficient pour prendre en compte la présence du capteur, et l’ajuster selon le courant que l’on désire. Il faut tout d’abord multiplier par 1/10 par rapport au capteur de courant dont sa tension est multipliée par 10 par rapport au gain de l’amplificateur.
On a déjà le coefficient d’origine pour pouvoir définir un courant précis à 0A. Il va falloir par la suite également réaliser les mesures de la sortie de l’amplificateur tout d’abord pour un courant de 0 à 12A grâce à une alimentation continue. Par la formule du courant définie sur Arduino, on peut trouver le palier de mesure (résultat de « analogRead() » sur Arduino) pour chaque courant simulé.
Il ne reste plus qu’à simuler une première fois la tension de décharge de la batterie, à regarder le courant affiché sur le LCD et sur le capteur de courant à l’aide d’un voltmètre.
Il y a une différence de courant entre le courant affiché sur écran LCD et le courant mesurée par le capteur de courant.
A partir du courant trouvé sur écran LCD, on peut trouver le palier de mesure d’Arduino par tâtonnement avec une calculatrice. Une fois la valeur du palier trouvée, on peut rechercher la valeur du nouveau coefficient. Pour ma part j’ai inclus le 1023 directement dans mon calcul de coefficient, cela est plus simple. Une fois ensuite, on prend la valeur mesurée par le capteur, ce que l’on est sensé déchargé, et on recherche le nouveau coefficient.
Pour une décharge à 20.22A environ, il faut choisir un coefficient de 90/1023 (ou remplacer 1023 par 90).
Code Arduino pour une décharge à 20A :
#include <SoftwareSerial.h>
#include <TimerOne.h>
#include <LiquidCrystal.h>
#include <LiquidCrystal_I2C.h>
#include <MatrixMath.h>
#define led13 13
#define bpreset 10
#define envoi 2
#define BP 3
//#define buzz A4 //buzzer si tension en décharge inférieure à 2.7V
LiquidCrystal lcd(8,9,4,5,6,7); // (RS=8, E=9, D4=4, D5=5, D6=6, D7=7)
/******************************************************************/
float tension,tensionCapt=0; // Initialisation
float courant=0;
float sensible=0.01; // Sensibilité du capteur
//float ACSoffset=2.5; // Valeur de tension de sortie du capteur lorsque le courant=0
float capacite=0,capaciteA=0;
float ESR=0.021;
float R;
float E; // tension électrochimique
float temperature;
int heure=0,minute=0,seconde=0; // le temps
float U=5; //Tension d'alimentation de la carte (peut varier selon l'USB)
float val[8],cap[8];
int cycles=1,i=0,j=0; //nombre d'echantillons
float m,vm,reg;
float A=1.0, B=15.0;
#define N (4+1)
float SommeX[2*N],SommeXY[N];
mtx_type S[N][N];
mtx_type v[N];
mtx_type a[N];
float n=0,X=0,Y=0;
void setup() {
// put your setup code here, to run once:
Timer1.initialize(1000000); // 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
pinMode(bpreset, INPUT);
pinMode(envoi, INPUT);
pinMode(BP, INPUT);
pinMode(A0, INPUT);
pinMode(A1, INPUT);
pinMode(A2, INPUT);
//pinMode(buzz, OUTPUT);
Serial.begin(9600);
lcd.begin(20,4); //et pas lcd begin comme cetraine biblio
lcd.clear(); // Effacer le l'écran
Serial.print("Capacite;"); Serial.print("Tension;");
Serial.print("OCV;"); Serial.print("Température (%);"); Serial.println("A4;A3;A2;A1;A0;SOH;");
}
void callback()
{
seconde++;
tension=analogRead(A0); // Lecture de la valeur récupèrée de A0
tension=tension*(4.66/1023.0); // Conversion de cette valeur en une tension comprise entre 0 et 5V (Batterie)
delayMicroseconds(10);
tensionCapt=analogRead(A1); // Lecture de la valeur récupèrée de A1
//delayMicroseconds(10);
//tensionCapt=analogRead(A3);
courant=(tensionCapt*4.66)/90; // Conversion de cette valeur en une tension comprise entre 0 et 5V (Capteur ASC)
// courant=tensionCapt/sensible; // Calcul du courant
capacite=(courant/3.6)+capacite; // (I(A)*1000)/(1s/3600)+capacite
capaciteA=capacite/1000;
temperature=((analogRead(A2)*4.66)/1023.0)*(1/0.01); // la tension de sortie est de : 10mV/°C
E=tension+ESR*courant;
//R=E/courant;
//if (seconde==60) { Serial.print(temperature); Serial.println(";"); }
if(capacite>=cycles*500 and capacite<=cycles*500+30 and tension<=3.7) //si capacité est un multiple de 0.5A.h, alors lecture sur port série des mesures
//on estimera la capacité entre 500 et 505 mA.h car la mesure de la capacité n'est pas souvent pile sur 500 mA.h
{
X=capaciteA;
Y=tension;
for(i=0;i<=(N-1)*2;i++) { SommeX[i]=SommeX[i]+pow(X,i);}
for(i=0;i<(N);i++) { SommeXY[i]=SommeXY[i]+Y*pow(X,i);}
n++;
if(n<4) {
Serial.print(capaciteA); Serial.print(";"); Serial.print(tension,3); Serial.print(";");
Serial.print(E,3); Serial.print(";");Serial.print(temperature); Serial.print(";");
Serial.println(" ; ; ; ; ; ; ;"); //respectivement (a4;a3;a2;a1;a0;SOH;reg)
//A changer selon l'ordre utilisé
}
if(n>=N) {
for(i=0;i<N;i++) {
for(j=0;j<N;j++) {S[i][j]=SommeX[j+i]; }
v[i]=SommeXY[i];
}
Matrix.Invert((mtx_type*)S,N);
Matrix.Multiply((mtx_type*)S, (mtx_type*)v,N,N,1,(mtx_type*)a);
//Serial.print(capaciteA); Serial.print(";"); Serial.print(tension,3); Serial.print(";");
//Serial.print(E,3); Serial.print(";"); Serial.print(temperature); Serial.print(";");
//Serial.print(a[4],8); Serial.print(";"); Serial.print(a[3],8); Serial.print(";");
//Serial.print(a[2],8); Serial.print(";"); Serial.print(a[1],8); Serial.print(";");
//Serial.print(a[0],8); Serial.print(";");
//Serial.print(n); Serial.println(";");
//SOH avec coefficients
while ((B-A) > 0.01) {
m=(A+B)/2;
vm = a[4]*pow(m,4)+a[3]*pow(m,3)+a[2]*m*m+a[1]*m+a[0];
if(vm>2.7) { B=m; }
else { A=m;}
}
//Régression (à changer selon l'ordre utilisé)
reg=vm;
Serial.print(capaciteA); Serial.print(";"); Serial.print(tension,3); Serial.print(";");
Serial.print(E,3); Serial.print(";"); Serial.print(temperature); Serial.print(";");
Serial.print(a[4],8); Serial.print(";"); Serial.print(a[3],8); Serial.print(";");
Serial.print(a[2],8); Serial.print(";"); Serial.print(a[1],8); Serial.print(";");
Serial.print(a[0],8); Serial.print(";");
Serial.print(m); Serial.print(";"); Serial.print(reg); Serial.println(";");
}
//cap[cycles]=-capacite;
//val[cycles]=tension;
cycles++;
}
// //temperature=((analogRead(A2)*5.0)/1023.0)*(1/0.01); // la tension de sortie est de : 10mV/°C
// if(tension<=2.7) {
// tone(buzz,100,1); } //si tension de décharge trop faible => ne pas décharger entièrement
}
void temps()
{ if(seconde>=60){seconde=0;
minute++;
if(minute>=60){minute=0;
heure++;
}
if(heure>=24){heure=0;
lcd.clear();
}
}
} // fin void temps
void loop() {
// put your main code here, to run repeatedly:
if(digitalRead(bpreset)==1)
{
seconde=0; minute=0; heure=0;
cycles=0; i=0;
courant=0; capacite=0;
}
// if(digitalRead(envoi)==1)
// {
// for(j==0;j<=20;j++)
// {
// Serial.print(cap[j]); Serial.print(";");
// Serial.print(val[j]); Serial.println(";");
// }
// }
temps();
/*************Affichage sur l'écran LCD****************/
lcd.setCursor(0,0);
lcd.print(tension,3);
lcd.print("V ");
lcd.print(courant,2);
lcd.print("A ");
lcd.setCursor(0,1);
lcd.print(E,3);
lcd.print("V ");
lcd.setCursor(10,1);
lcd.print("C=");
lcd.print(capacite,0);
lcd.print("mAh ");
lcd.setCursor(0,2);
lcd.print("T=");
lcd.print(temperature);
lcd.print(" oC");
lcd.setCursor(0,3);
lcd.print(heure);
lcd.print("h ");
lcd.print(minute);
lcd.print("m ");
lcd.print(seconde);
lcd.print("s ");
lcd.setCursor(15,3);
lcd.print("N=");
lcd.print(cycles-1);
lcd.print(" ");
}
Décharge à 20A, deuxième résultat :
On peut déduire quelques points similaires à la dernière simulation. Sur le fait que la tension chute beaucoup dès la mise en marche du banc résistif. De ce fait, l’estimation du SOH est de 9A.h au lieu des 10A.h comme indiqué sur les caractéristiques de la batterie. On ne peut pas simuler une décharge plus intense car cela dépasserait la tension de seuil instaurée à 3.7V.
De ce fait, on pourrait conclure que plus le courant de décharge est important, plus la batterie se décharge vite, et plus la capacité que l’on peut utiliser est faible.
Également, la notion de précision est importante durant l’étude de l’état de santé de la batterie. C’est pour cela qu’il faut déterminer la tension offset du capteur de courant et sa pente. Il faut donc mesurer la tension en sortie du capteur de courant et la tension en sortie de l’amplificateur et les indiquer dans Excel.
Exploitation des mesures sur Excel :
Ainsi sur ce fichier Excel sont indiqués le nombre de paliers pour chaque tension mesurée (toujours par tâtonnement), le nombre d’Ampères entre chaque palier, et les résultats de tests pour la détermination de coefficient.
Entre simulations on a changé les calculs entre 5V et 4.66V. Donc pour une décharge de 8A et 14A, on a utilisé la tension de 5V, sachant que la tension de la carte était de 4.66V. Donc il serait préférable et plus judicieux de refaire ces décharges pour pouvoir mieux estimer le SOH avec cette carte.
