Testeur et chargeur d`accumulateur

Testeur et chargeur d'accumulateur PYR, version 2013/10/15 - 1 -
Testeur et chargeur d'accumulateur
Les microcontrôleur permettent souvent de réaliser très rapidement des applications
simples, sans devoir ajouter beaucoup de composants.
A titre d'exemple, nous allons réaliser un dispositif capable de mesurer la tension d'un
accumulateur NiMH (tension nominale de 1.2 V), de le charger et de le décharger en
mesurant sa capacité (en mAh)
Le figure ci-dessous montre comment faire la mesure, la charge et la décharge de
l'accumulateur, puis propose un schéma capable de réaliser ces trois fonctions.
La patte PinCharge va successivement être laissée en l'air (comme une entrée) pour
effectuer la mesure, être mise à « 1 » pour charger l'accumulateur, puis être mise à « 0 »
pour le décharger.
Le choix de la résistance doit être tel que le courant maximum dans la patte du
microcontrôleur ne soit pas dépassé (20 à 30 mA). Ce serait même prudent de ne pas trop
s'en approcher, pour que la chute de tension dans la résistance interne des transistors de
sortie reste négligeable. Avec 100 Ohm et une tension d'alimentation de 3.5 V, le courant
sera de 25mA au début de la charge, lorsque la tension au bornes de l'accumulateur sera
d'environ 1 V : I = U/R = (3.5V -1V) / 100 Ohm = 25 mA.
Mesure de la tension de l'accumulateur
La mesure de la tension au borne de l'accumulateur est simple : il suffit d'utiliser une
entrée analogique du microcontrôleur.
Pour visualiser les valeurs, la ligne série est très pratique.
Voici les instructions correspondantes en C/Arduino (testé avec Energia sur un LaunchPad
MSP430g) :
#define AccuIn A5 // patte de lecture de la tension
void setup() {
Serial.begin(9600); // initialisation de la ligne série
}
void loop() {
Serial.printLn(analogRead(AccuIn)); // lecture-affichage
delay (1000);
}
Ce programme permet juste de tester la lecture de la valeur analogique. Voici comment le
modifier pour gérer et afficher les valeurs en Volt, en utilisant la fonction Arduino de
R
R
Accu
Mesure Charge Décharge
V
R
PinCharge
AccuIn
Microcontrôleur

Testeur et chargeur d'accumulateur PYR, version 2013/10/15 - 2 -
changement d'échelle :
#define MaxConv 1023 // valeur maximale lue
#define MaxVolt 2500 // tension correspondant à la valeur maximale
tension =map (analogRead(PinAccuIn), 0, MaxConv, 0, MaxVolt);
Mise en charge et en décharge
Le programme suivant ajoute la charge et la décharge de l'accumulateur :
...
#define Alimentation 3500 // tension d'alimentation en mV (3.5 V)
#define Resistance 100 // résistance de charge et décharge, en ohm
enum {Mesure, Recharge, Decharge};
#define ModeMesure {pinMode(PinCharge, INPUT);}
#define ModeRecharge {pinMode(PinCharge, OUTPUT); digitalWrite(PinCharge, HIGH);}
#define ModeDecharge {pinMode(PinCharge, OUTPUT); digitalWrite(PinCharge, LOW);}
void setup (){ // initialisations
analogReference(INTERNAL2V5);
Serial.begin(9600);
ModeMesure;
}
void AfficheTension (int valeur) { // affichage d'une tension (en Volt)
Serial.print (valeur/1000); Serial.print (".");
Serial.print ((valeur/100)%10); Serial.print ((valeur/10)%10);
Serial.print (" Volt");
}
void AfficheCourant (long valeur) { // affichage d'un courant (en mA)
Serial.print (valeur); Serial.print (" mA");
}
void AfficheCharge (long valeur) { // affichage d'une charge (en mAh)
Serial.print (valeur/3600); // passe de mAs en mAh
Serial.print (" mAh");
}
int tension; long courantCharge; long charge = 0;
char car; byte mode=Mesure;
void loop (){ // boucle principale
tension =map (analogRead(PinAccuIn), 0, MaxConv, 0, MaxVolt);
Serial.print ("Tension: "); AfficheTension(tension);
if (mode == Recharge) { // en recharge, la résistance est au +
courantCharge = (Alimentation-tension) / Resistance;
Serial.print (", courant de charge: ");
}
if (mode == Decharge) { // en décharge, la résistance est à la masse
courantCharge = tension / Resistance;
Serial.print (", courant de decharge: ");
}
AfficheCourant(courantCharge);
Serial.print (", charge: "); AfficheCharge(charge);
charge += courantCharge; // intègre la recharge, en mAs(!)
Serial.println();
delay(1000); // attente d'une seconde (pour la mesure de la charge)
if (Serial.available() > 0) { // lecture des caractères éventuels

Testeur et chargeur d'accumulateur PYR, version 2013/10/15 - 3 -
car = Serial.read();
switch (car) { // décodage des commandes
case 'c' : mode=Recharge;charge=0; ModeRecharge; break;
case 'd' : mode=Decharge;charge=0; ModeDecharge; break;
default : mode=Mesure; ModeMesure;
}
}
}
Quelques commentaires :
- Remarquez l'utilisation d'une référence de tension interne au microcontrôleur, par la
commande analogReference(INTERNAL2V5); La lecture de la tension est alors
rendu insensible à la valeur exacte de la tension l'alimentation (mais pas encore celle du
courant).
- La tension a été exprimée en mV. Un nombre de 16 bits (int) est suffisant. Par contre,
la charge a nécessité une variable de 32 bits (long), vu qu'elle est exprimée en mAs. C'est
seulement à l'affichage que cette valeur est convertie dans l'unité habituelle de la charge,
le mAh.
- L'utilisation de la division entière (/) et du modulo (%) a permis d'afficher la tension en
Volt, avec deux chiffres après le point décimal, à partir d'une valeur exprimée en mV.
Notez la double ligne pour afficher les dixièmes et les centièmes. Une ligne unique :
Serial.print ((valeur/10)%100);
produirait des erreurs, à cause de la suppression du zéro non-significatif (1.03 V serait
affiché 1.3 V).
- Avez-vous remarqué une erreur dans la gestion du temps ? La boucle principale loop
est censée d'exécuter une fois par seconde, vu qu'elle fait l'intégration le courant pour
calculer la charge. En mettant un délai de 1'000 ms, on sous-entend que toutes les autres
instructions de la boucle principale durent un temps négligeable vis-à-vis d'une seconde.
Ce n'est pas le cas ici : l'envoi d'une ligne de caractères à 9'600 bits par seconde prend du
temps ! Si elle a une longueur de 60 caractères, on aura un temps d'envoi d'environ 60
ms. En effet, un caractère correspond à 10 bit, soit environ 1 ms à 9600 baud. On pourra
corriger cette erreur en lisant le temps du système avec la procédure millis().
Charge et décharge plus rapides
Pour pouvoir charger et décharger plus rapidement
l'accumulateur, il serait possible de mettre un transistor.
Plus simplement, on pourrait utiliser plusieurs pattes,
comme sur le schéma ci-contre.
Avec des résistances de 100 Ohm, il ne faudrait toutefois
pas dépasser l'usage de 4 sorties. En effet, le
microcontrôleur n'a pas seulement un courant maximum
par patte, il a aussi un courant maximum total, qui est en
général de l'ordre de 100mA s'il y a une seule patte pour
chaque alimentation.
PinCharge
AccuIn
Microcontrôleur

Testeur et chargeur d'accumulateur PYR, version 2013/10/15 - 4 -
Mesure de la tension d'alimentation
La tension d'alimentation est définie comme une constante (3500mV) dans le programme.
Or ce n'est pas forcément le cas dans la pratique ! Tout au moins faudrait-il ajuster la
constante dans le programme en fonction de l'alimentation utilisée. Le montage et le
programme pourrait être complété pour mesurer la tension d'alimentation, sur une
seconde entrée analogique.
Pour pouvoir utiliser le mode de conversion basé sur
une référence interne (par exemple 2.5 V), il faut diviser
la tension d'alimentation, pour ne pas dépasser la
tension de référence. En utilisant deux résistance
identique R1 = R2, on divise la tension par deux.
La précision des résistances courantes n'est pas très
bonne (par exemple 5%). Mais il est facile de bien
choisir les résistances, en essayant d'en trouver deux
qui ont une valeur très proche. Un multimètre courant,
même s'il n'est lui-même pas très précis, a une
résolution suffisante pour faire ce choix !
Mesure de la résistance interne de l'accumulateur ?
Il semble possible avec ce montage de mesurer la résistance interne de l'accumulateur,
qui est une valeur intéressante. Une première mesure de la tension doit être faite à vide,
puis une seconde mesure en décharge. La différence entre ces deux mesures permet de
calculer la résistance interne de l'accumulateur.
Dans la pratique, la résistance interne d'un accumulateur en bon état est difficile à
mesurer par ce moyen : la différence de tension serait trop faible.
Une technique pourrait être utilisée pour obtenir des mesures plus précise que la précision
du convertisseur : le sur-échantillonnage, qui consiste à faire la somme de nombreuses
mesures. Dans ce cas, on pourrait répéter mille fois les mesures successives à vide et
avec la charge. La différence entre la somme serait probablement significative.
Améliorations possibles
Une détection de fin de charge (à environ 1.6 Volt) et de fin de décharge (vers 0.9 V) serait
souhaitable.
Pour un maintien de la charge dans l'accumulateur après l'avoir chargé, il serait possible
d'utiliser la technique connue sous le nom de Trickle charging, qui consiste à continuer de
charger en PWM un accumulateur, en réglant la valeur du courant moyen à la
compensation de sa décharge naturelle.
Le montage et le programme pourraient être modifiés pour gérer plusieurs accumulateurs.
Il serait aussi possible de rendre l'appareil autonome en ajoutant un afficheur (LED 4 fois 7
segments, ou afficheur LCD) et quelques boutons (mode charge, décharge, affichage de
la charge ou de la tension, etc).
La possibilité de charger des accumulateurs avec des tensions plus élevées (LiPo 3.7v)
nécessiterait une alimentation plus élevée, sans oublier la régulation pour le processeur
(environ 3.5 V pour un MSP430). Dans ce cas, des transistors seraient nécessaire pour la
PinCharge
AccuIn
Microcontrôleur
MesureAlim
Vcc
R1
R2

Testeur et chargeur d'accumulateur PYR, version 2013/10/15 - 5 -
charge et la décharge.