Coulomb Counter Breakout LTC4150

Objectifs:

Mesurer l’évolution de la charge ou décharge d’une batterie; établir la quantité d’électricité consommée par un système.

Ce dont vous aurez besoin: 

• Batterie Li-ion 
• Coulomb Counter 
• Arduino UNO
• Shield SD
• Tinkerkit Sensor Shield
• Thermistance
• Led 5mm
• fils connecteurs

Ils sont tous disponibles ici

Presentation du Coulomb Counter Breakout LTC4150:

On se sert d’une batterie pour alimenter un système. A l’instar de l’odomètre qui est un compteur kilométrique, on utilise le coulomb counter pour mesurer le flux d’électrons (quantité d’électricité) circulant de la batterie au système. Ainsi, nous pouvons suivre l’évolution de la décharge de la batterie (et de la charge si batterie rechargeable).En effet, à travers les informations obtenues, nous pouvons connaitre la valeur de la charge actuelle de même que la quantité d’électricité ayant circulé pendant un temps donné .Avec le coulomb counter on peut également savoir si la batterie est en état de charge ou de décharge.

Le Coulomb Counter Breakout LTC4150 vu de profil et de face.

Ayant comme circuit intégré le LTC4150 (voir datasheet constructeur); le coulomb counter possède une entrée (IN) dont la tension requise est comprise entre 2.7 et 8.5V; une sortie (OUT). L’intensité maximale qui doit circuler à travers le coulomb counter est de 1A. 

Celui-ci dispose également de 6 pins  pour une interface digitale.

Ces pins sont :

-VIO tension de référence égale à celle qu’utilise le système

-INT (interrupt, OUTPUT) : émet un signal en changeant d’état à chaque fois qu’une certaine quantité d’électricité traverse

-POL (polarity, OUTPUT): renseigne sur l’état de la batterie (charge ou décharge)

-CLR (clear, INPUT): utilisée en commande manuelle pour servir de reset après que l’état du INT ait changé

-SHDN (shutdown) impose au LTC4150 une consommation minimale

Pour l’entrée IN, on peut utiliser soit un connecteur JST 2mm soit les deux broches après soudure.Quant à la sortie, elle est reliée au VIN si la tension d’entrée n’est pas régulée à 5V on utilise ensuite la valeur référence 3.3V ou 5V) sinon directement sur le 5V.

On peut faire fonctionner le coulomb counter soit en mode manuel ou en mode automatique. Pour cela, il suffit d’agir sur les pins CLR et INT.

Exemple d'utilisation:

Dans l’exemple suivant, nous mesurons la température ambiante à l’aide d’un capteur Thermistance 4K7 tout en utilisant  une LED  qui reste allumée. Cette mesure s’effectue à chaque valeur de flux d’électrons passés. On enregistre ensuite les différentes données obtenues dans une carte SD. Nous utilisons également le mode automatique c’est-à-dire que le pin INT revient à son état antérieur après qu’il ait changé d’état lorsqu’une certaine quantité d’électricité ait circulé à travers le coulomb counter.

Code Arduino:

//library for SD card
#include<SD.h>
const int INT=3;
const int POL=6;
const int LedPin=9;
const int chipSelect=4;
// Change the following two lines to match your battery
// and its initial state-of-charge:
volatile double battery_mAh = 1000.0; // milliamp-hours (mAh)
volatile double battery_percent = 100.0;  // state-of-charge (percent)
// Global variables ("volatile" means the interrupt can change them behind the scenes):
volatile boolean isrflag;
volatile long int time, lasttime,time1;
volatile double mA;
double ah_quanta = 0.17067759; // mAh for each INT
double percent_quanta; // calculate below
//////////////////////////////////////////////////////////////
//////////////////SETUP//////////////////////////////////////
////////////////////////////////////////////////////////////
void setup()
{
// Set up I/O pins:
  pinMode(INT,INPUT); // Interrupt input pin 
  pinMode(POL,INPUT); // Polarity input pin  
  pinMode(LedPin,OUTPUT);
  digitalWrite(LedPin,HIGH);
  pinMode(chipSelect,OUTPUT);
// Enable serial output:
  Serial.begin(9600);
  Serial.print("Initializing SD card...");
// see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
     Serial.println("Card failed, or not present");
   return;
  }
  Serial.println("card initialized.");
  Serial.println("LTC4150 Coulomb Counter BOB interrupt's mode");
  // One INT is this many percent of battery capacity: 
  percent_quanta = 1.0/(battery_mAh/1000.0*5859.0/100.0);

// Enable active-low interrupts on D3 (INT1) to function myISR().
  // On 328 Arduinos, you may also use D2 (INT0), change '1' to '0'. 
  isrflag = false;
  attachInterrupt(1,myISR,FALLING);
}
////////////////////////////////////////////////////////////
/////////////////LOOP//////////////////////////////////////
//////////////////////////////////////////////////////////
void loop()
{
  static int n = 0;
  // When we detect an INT signal, the myISR() function
  // will automatically run. myISR() sets isrflag to TRUE
  // so that we know that something happened.
  if (isrflag)
  {
    // Reset the flag to false so we only do this once per INT    
    isrflag = false;
    // Blink the LED
 delay(100);   
  long Resistance;
  double Temp; 
  int sensor = analogRead(A0);
  Resistance=(10230000/sensor-4700);
  Temp = log(Resistance);
  Temp = 1 / (0.001129148 + (0.000234125 * Temp) + (0.0000000876741 * Temp * Temp * Temp));
  Temp = Temp - 273.15;
    // Print out current status (variables set by myISR()) 
    Serial.print("sensor");
    Serial.print(sensor);
    Serial.print("Temp:     °C");
    Serial.print(Temp);
    Serial.print("mAh: ");
    Serial.print(battery_mAh);
    Serial.print(" soc: ");
    Serial.print(battery_percent);
    Serial.print("% time: ");
    Serial.print((time-lasttime)/1000000.0);
    Serial.print(",,");
    Serial.print(time1);
    Serial.print("s mA: ");
    Serial.println(mA);
    String sensorValue=String(sensor);
    String TempStg=String(Temp);
    String mAh=String(battery_mAh);
    String percent=String(battery_percent);
    String time2=String(time1);
    String mAStg=String(mA);
    String valueStg=sensorValue +","+ TempStg +","+ mAh +","+ percent +","+ time2 +"s"","+ mAStg;
    File datafile=SD.open("QuanBa.csv",FILE_WRITE);
      datafile.print("sensor");
      datafile.print(",");
      datafile.print("temperature");
      datafile.print(",");
      datafile.print("mAh");
      datafile.print(",");
      datafile.print("percent");
      datafile.print(",");
      datafile.print("time ");
      datafile.print(",");
      datafile.println("mA");
      datafile.println(valueStg);
      datafile.close();
  }
  // You can run your own code in the main loop()
  // myISR() will automatically update information
  // as it needs to, and set isrflag to let you know
  // that something has changed.
}
void myISR() // Run automatically for falling edge on D3 (INT1)
{
  static boolean polarity;  
  // Determine delay since last interrupt (for mA calculation)
  // Note that first interrupt will be incorrect (no previous time!)
  lasttime = time;
  time = micros();
  // Get polarity value 
  polarity = digitalRead(POL);
  if (polarity) // high = charging
  {
    battery_mAh += ah_quanta;
    battery_percent += percent_quanta;
  }
  else // low = discharging
  {
    battery_mAh -= ah_quanta;
    battery_percent -= percent_quanta;
  }
  // Calculate mA from time delay (optional)
  time1=((time-lasttime)/1000000.0);
  mA = 614.4/((time-lasttime)/1000000.0);
  // If charging, we'll set mA negative (optional) 
  if (polarity) mA = mA * -1.0;
  // Set isrflag so main loop knows an interrupt occurred  
  isrflag = true;
}

Circuit illustrant l’exemple

Si vous avez des questions n’hésitez pas à les posez en commentaires.