Mesurer la capacité d’une pile rechargeable Ni-MH – suite

Dans cette seconde partie du tutoriel, nous allons ajouter un transistor à notre circuit afin d’arrêter la décharge de la pile lorsque elle a atteint sa tension seuil de 0,8 V. Ceci afin d’éviter d’endommager la pile, car il faut éviter de décharger complètement un pile rechargeable ou une batterie.

Nous ajouterons également un petit afficheur OLED afin de visualiser facilement la capacité de la pile.

Transistor bipolaire 2N2222

Un transistor bipolaire NPN 2N2222 est utilisé dans son régime de saturation pour jouer le rôle d’un interrupteur et contrôler l’arrêt de la décharge de la pile lorsque sa tension est inférieure à 0,8 V.

Le principe d’utilisation du transistor dans son régime de saturation est rappelé dans la page sur les bases de l’électronique ici.

La base du transistor est reliée à la sortie D7 de l’Arduino au travers d’une résistance de 4,7 kΩ. Ainsi la sortie D7 de l’Arduino contrôle le courant qui circule dans la base du transistor :

  • Lorsque la sortie D7 est à HIGH (5 V), le transistor est dans son état saturé et la pile se décharge dans la résistance.
  • Lorsque la sortie D7 est LOW (0 V), le transistor est dans son état bloqué et la pile ne se décharge plus dans la résistance.

Schéma du circuit électronique

Afin de mesurer précisément l’intensité qui circule dans la résistance, nous allons mesurer la tension aux bornes de la résistance grâce à deux entrées analogiques de l’Arduino. En effet, la tension VCE entre le collecteur et l’émetteur du transistor n’est pas négligeable (de l’ordre de 0,2 V) et la mesure à une seule borne de la résistance comme dans la première partie du tutoriel n’est plus possible.

Le courant que la pile débite est :

I = (U0 – U1) / R

U0 est la tension lue sur l’entrée analogique A0
U1 est la tension lue sur l’entrée analogique A1
R = 10 Ω

Voici la simulation du circuit fait sur Falstad :

Montage pour mesurer la capacité piel NiMh

Afficheur OLED

J’ai ajouté un petit afficheur afin de visualiser facilement la mesure sans avoir besoin de laisser l’ordinateur allumé pour lire le moniteur série.

Il s’agit d’un afficheur OLED 0,96″ communiquant avec l’Arduino via un port I2C (GND, VCC, SCL, SDA).

La librairie utilisée pour cet afficheur est la librairie Adafruit SSD1306.

Photo du montage de mesure de capacité de pile NiMH

Programme de l’Arduino

// Mesure de capacité d'une pile rechargeable Ni-MH 1.2 V 
// https://tutoduino.fr/
// Copyleft 2020

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define LARGEUR_ECRAN 128 // Largeur de l'écran OLED en pixels
#define HAUTEUR_ECRAN 64  // Hauteur de l'écran OLED en pixels

// Délcaration pour l'afficheur OLED relié via I2C
#define OLED_RESET     -1 // OLED sans broche RESET
Adafruit_SSD1306 display(LARGEUR_ECRAN, HAUTEUR_ECRAN, &Wire, OLED_RESET);

// Valeur de la resistance de decharge
#define R 10.0

// Seuil bas de la tension d'une pile Ni-MH
#define SEUIL_BAS_TENSION_PILE 0.80

// Détection de seuil bas de la tension de la pile
bool seuilBasBatterieAtteint = false;

// Heure de début de la mesure
unsigned long initTime;

// Quantité d'électricité générée par la pile lors 
// de la dernière seconde
float quantiteElectricite = 0;

// Quantité d'électricité totale générée par la pile 
// depuis le lancement du programme
float quantiteElectriciteTotale = 0;



// Fonction qui doit être appellée toutes les secondes
// La fonction mesure la tension aux bornes de la résistance
// et en déduit le courant qui y circule. 
// Elle mesure la capacité de la pile en additionnant
// le courant de décharges toutes les secondes jusqu'à ce
// que la pile soit totalement déchargée
void mesureQuantiteElectricite() {
  float U0,U1;
  float tensionResistance;
  float courant;

  // Lit la tension aux bornes de la pile et aux bornes 
  // de la résistance
  U0 = analogRead(A0)*5.0/1024.0;
  U1 = analogRead(A1)*5.0/1024.0;
  tensionResistance = U0-U1;
    
  // Verifie que la tension de la pile n'est
  // pas inferieure à son seuil bas afin de ne pas 
  // l'endommager
  if (U0 < SEUIL_BAS_TENSION_PILE) {
    seuilBasBatterieAtteint = true;
  }

  // Calcul du courant qui circule dans la résistance
  courant = (U0-U1)/R;

  // La quantité d'électricité est la quantité de charges électriques
  // déplacées par les électrons. Elle est égale à l'intensité
  // multipliée par le temps (1 seconde ici).
  // Afin d'avoir la quantité d'électricité en mAh, il faut
  // utiliser le facteur 1000/3600
  quantiteElectricite = courant/3.6;

  // On additionne cette quantité d'électricité aux précédentes
  // afin de connaître la quantité totale d'électricité
  // à la fin de la mesure
  quantiteElectriciteTotale = quantiteElectriciteTotale+quantiteElectricite;

  // Affichage sur l'afficheur OLED de la tension de la pile, 
  // du courant débité ainsi que de la quantité d'électricité débitée 
  // par la pile depuis le lancement du programme
  display.clearDisplay();
  display.setTextSize(2);
  display.setTextColor(WHITE);  
  display.setCursor(0, 0);
  display.println("Tutoduino");

  display.setTextSize(1);
  display.setCursor(0, 20);
  display.print("U=");
  display.print(U0);
  display.println(" V");
  
  display.setCursor(0,30);
  display.print("I=");
  display.print(courant);
  display.println(" A");

  display.setCursor(0,40);
  display.print("Q=");  
  display.print(quantiteElectriciteTotale);
  display.println(" mAh");
  display.display(); 
}

void setup() {

  Serial.begin(9600);

  // Initialisation de l'écran OLED
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("Echec initialisation afficheur"));
    for(;;); // Don't proceed, loop forever
  }
  
  // Positionne la référence de tension par défaut
  // la tension de référence sera donc la tension 
  // d'alimentation du micro-contrôleur
  analogReference(DEFAULT);

  // Heure de début de la mesure 
  initTime = millis();

  // La sortie D7 sera utilisé pour contrôler 
  // l'état du transistor
  pinMode(7, OUTPUT);
  delay(100);

  Serial.println("Décharge de la pile terminée");

  // Passe le transistor dans son état saturé
  // afin de démarrer la décharge de la pile
  digitalWrite(7, HIGH);


}

void loop() {
  // Mesure de la quantité d'électricité débitée toutes les 
  // secondes jusqu'à ce que la tension de la pile soit inférieure
  // à son seuil bas afin de ne pas l'endommager.
  if (seuilBasBatterieAtteint == false) {
    mesureQuantiteElectricite();
    delay(1000);
  } else {
    // Une fois que le seule bas de la pile est atteint, 
    // on positionne le transistor en mode bloqué afin
    // d'arrêter la décharge de la pile
    digitalWrite(7, LOW);
    Serial.println("Décharge de la pile terminée");
    Serial.print("Capacité de la pile = ");
    Serial.print(quantiteElectriciteTotale);
    Serial.println(" mAh");
    display.setCursor(0,50);
    display.print("Mesure terminee !");  
    display.display();     
    delay(1000);
  }
}
github

Téléchargez le croquis depuis GitHub

Une fois que la tension de seuil (0,8 V) de la pile est atteinte, la mesure est terminée et la capacité de la pile est affichée.

Ci-dessous une pile Ni-MH a une capacité mesurée de 1366 mAh, alors que sa capacité théorique est de 2500 mAh. La pile est ancienne et a perdu la moitié de sa capacité.

Afficheur alors que la mesure est terminée

Un cycle de charge/décharge permet de redonner un peu de vigueur à une pile rechargeable qui n’a pas été utilisée pendant relativement longtemps.

Après 1 cycle de charge/décharge, la pile a déjà gagné 140 mAh de capacité. Il est recommandé d’effectuer 5 cycles de charge/décharge afin de redonner une bonne capacité à une pile stockée longtemps sans avoir été utilisée.

Ce tutoriel peut bien entendu être utilisé pour mesurer la capacité la batterie externe USB que vous utilisez pour recharger votre smartphone.

Ce type de batterie est généralement de type Li-Ion et de tension de sortie d’environ 5 V. Il faudra absolument utiliser une résistance de puissance de 20 Ω 10 W. Une résistance de puissance est nécessaire car le courant débité sera de l’ordre de 200 mA et donc la puissance à dissiper sera P = U x I = U x U / R = 25 / 20 = 1,25 W. On résistance ordinaire (1/4 W) ne conviendrait donc pas pour ce type de mesure car elle sera endommagée ou chaufferait beaucoup trop.

batterie externe usb

Il faudra penser à modifier le programme de l’Arduino avec la nouvelle valeur de la résistance.

#define R 20.0

Voilà c’est la fin de ce tutoriel, si vous l’avez apprécié ou si vous avez des questions, n’hésitez pas à utiliser le formulaire de commentaires ci-dessous.