BQ35100: The EOS bit dosen't change

Hey Lilian,

Please refer to this document: https://www.ti.com/lit/an/sluaal7/sluaal7.pdf

For your testing you should be gathering Scaled R and Measured Z values from the gauge. When that is gathered, you will see a resistance trend which then can be used to configure the "EOS Trend Detection % percentage" parameter that is used to trigger the EOS flag. Read section 7 to get a more depth explanation.

Regards,

Nick Richards

Hey Lilian,

You will need to gather a log file to calculate long term average and short term average because you will need the updated impedance value after each learning pulse. However, you can read those values from data memory after the learning pulse so you don't need to calculate those values. There are two values in EOSData that you need to change, that is "New Batt R Scale Delay" and "EOS Trend Detection".

Regards,

Nick Richards

Hey Lilian,

I believe the issue is how you are sending certain commands to the gauge. The gauge start and stop commands are not communicated correctly. Those commands need to be sent in little endian format as well as sending the command to the correct register. I have code written for the BQ35100 using an Arduino that I will share with you. 

/*
 * ----------------- bq35100_dataAcquisition ------------------- 
 *                  
 * This file will be used for the final data collection for the
 * smoke detectors using an arduino nano. The main program will 
 * communicate to the bq35100EVM-795 and get data like scaled 
 * resistance and measured resistance. The program will then 
 * write that data to an SD card.
 * 
 * 
 * // UPDATED to include trend data and EOS alert // 
 * 
 * PINOUT: 
 * 
 * D13 -> SCK (SD Card)
 * D12 -> MISO (SD Card)
 * D11 -> MOSI (SD Card)
 * D10 -> CS (SD Card)
 * GND -> GND (SD Card)
 * 5V -> VCC (SD Card)
 * 
 * GND -> J1_1 (bq35100EVM)
 * A5 -> J1_2 (bq35100EVM)
 * A4 -> J1_3 (bq35100EVM)
 * 
 * D5 -> J8_GE (bq35100EVM)
 * 
 * 3V3 -> REGIN (bq35100EVM)
 * 
 * Written By: Nicholas Richards
 * Last Modified: 08/5/2022
 */

#include <Wire.h> 
#include <SPI.h>
#include <SD.h>

#define bq35100_addr 0x55
#define bq35100_voltage_LSB_addr 0x08
#define bq35100_current_LSB_addr 0x0C
#define bq35100_scaledR_LSB_addr 0x16
#define bq35100_measuredZ_LSB_addr 0x22
#define bq35100_internalTemp_LSB_addr 0x28
#define bq35100_MAC_addr 0x3E
#define bq35100_longTrend_LSB_addr 0x64
#define bq35100_longTrend_MSB_addr 0x42
#define bq35100_shortTrend_LSB_addr 0x60
#define bq35100_shortTrend_MSB_addr 0x42
#define gauge_start_cmd 0x11
#define gauge_stop_cmd 0x12
#define cs_pin 10
#define GE_pin 5
#define battery_relaxation_time 14400000
#define learning_pulse_time 15000
#define one_second 1000
#define ten_milliseconds 10
#define currentLowerBound -25

File myFile;
word voltage;
word scaledR;
word internalTemp;
word measuredZ;
int current;
unsigned long shortTrend;
unsigned long longTrend;
unsigned long currentTime;
unsigned long startTime;
unsigned long lastDischarge;
bool OCV_Bad;
bool EOS_Alert;

void setup() {
  Wire.begin();
  Serial.begin(9600);
  delay(100);
  Serial.println("trend");
  if (SD.begin(cs_pin)){
    Serial.println("SD card is present & ready");
  } 
  else{
    Serial.println("SD card missing or failure...");
    while(1);  //wait here forever
  }
  SD.remove("trend.csv");
  myFile = SD.open("trend.csv", FILE_WRITE);
  myFile.println("Data Collection 1");
  myFile.println("Time(ms),Voltage(mV),ScaledR(mΩ),MeasuredZ(mΩ),Internal Temp(0.1°K),OCV_Bad,Short Trend Average, Long Trend Average, EOS Alert");
  pinMode(GE_pin,OUTPUT); // digital pin 5 is an output
  delay(ten_milliseconds);
}

void loop() { 
  delay(battery_relaxation_time); 
  wakeupGauge();
  startGauge();
  waitForLearningPulse();
  delay(learning_pulse_time); //wait for learning pulse to finish
  stopGauge();
  waitForData();
  bq35100GetData();
  SDwrite();
  sleepGauge();
}
/*
void toggle_gauge(){

  sleepGauge();
  delay(2000);
  wakeupGauge();
}*/

/* -------------- bq35100GetData -----------------
 * 
 * This function communicates to the bq35100EVM-795
 * and request data and then writes that data to 
 * global variables. 
 * 
 * Inputs: None 
 * Outputs: None
 */
void bq35100GetData(){
  currentTime = millis() - startTime;
  scaledR = dataFromAddress(bq35100_scaledR_LSB_addr);
  measuredZ = dataFromAddress(bq35100_measuredZ_LSB_addr);
  voltage = dataFromAddress(bq35100_voltage_LSB_addr);
  internalTemp = dataFromAddress(bq35100_internalTemp_LSB_addr);
  OCV_Bad = checkOCV_bad();
  shortTrend = fromDataFlash(bq35100_shortTrend_MSB_addr,bq35100_shortTrend_LSB_addr);
  longTrend = fromDataFlash(bq35100_longTrend_MSB_addr,bq35100_longTrend_LSB_addr);
  EOS_Alert = checkEOS();
}

/* ----------------- SDwrite ----------------
 *  
 *  This function takes the values from the  
 *  global variables and writes that data to 
 *  the SD card. 
 *  
 *  Inputs: None
 *  Outputs: None
 */
void SDwrite(){
  if(myFile){
    myFile.println(String(currentTime)+","+String(voltage)+","+String(scaledR)+","+String(measuredZ)+","+String(internalTemp)+","+String(OCV_Bad)+ "," + String(shortTrend) + "," + String(longTrend)+ "," + String(EOS_Alert));
    myFile.flush();
  }
}

/* --------------- byteCombiner ------------------
 *  
 *  This function combines two bytes into a word
 *  
 *  Inputs: MSB and LSB 
 *  Output: Word 
 */
word byteCombiner(word MSB, word LSB){
  word temp = 0;
  temp |= LSB;
  MSB = MSB << 8;
  temp |= MSB;
  return temp;
}

/* --------------- startGauge ----------------
 *  
 *  This function sends a command to the gauge 
 *  telling it to enter ACTIVE mode
 *  
 *  Input: None 
 *  Output: None
 */
void startGauge(){
  Wire.beginTransmission(bq35100_addr);
  Wire.write(bq35100_MAC_addr);
  Wire.write(gauge_start_cmd);
  Wire.write(0x00);
  Wire.endTransmission();
  delay(ten_milliseconds);
}

/* ------------ stopGauge ----------------
 * 
 * This function sends a command to the gauge 
 * telling it to exit ACTIVE mode and complete
 * all task
 * 
 * Input: None 
 * Output: None
 */
void stopGauge(){
  Wire.beginTransmission(bq35100_addr);
  Wire.write(bq35100_MAC_addr);
  Wire.write(gauge_stop_cmd);
  Wire.write(0x00);
  Wire.endTransmission();
  delay(ten_milliseconds);
}

/* ------------ wakeupGauge ----------------
 *  
 *  This function sends a digital high to the  
 *  GE pin to wake up the gauge.
 *  
 *  Input: None 
 *  Output: None
 */
void wakeupGauge(){
  digitalWrite(GE_pin,HIGH);
  delay(one_second); 
}
// this is important, have to wait long enough so you can send commands to the gauge
/* --------------- sleepGauge --------------
 *  
 * This function sends a digital low to the 
 * GE pin to put the gauge to sleep/low power
 * mode
 * 
 * Input: None
 * Output: None
 */
void sleepGauge(){
  digitalWrite(GE_pin,LOW);
}


bool checkOCV_bad(){
    byte bit1 = 0;
    byte bit2 = 0;
    Wire.beginTransmission(bq35100_addr);
    Wire.write(0x00);
    Wire.write(0x00);
    Wire.write(0x00);
    Wire.endTransmission();
    delay(ten_milliseconds); // also important, cant send two commands back to back too quick 
    Wire.beginTransmission(bq35100_addr);
    Wire.write(0x00);
    Wire.endTransmission();
    Wire.requestFrom(bq35100_addr,2);
    if(Wire.available() <= 2){
      bit1 = Wire.read();
      bit2 = Wire.read();
    }
   return bitRead(bit1,3);  
}

/* ------------------ waitForData --------------
 *  
 *  This function waits for the data to process 
 *  from the gauge using a busy-wait synchronization
 *  by polling the G_DONE bit in the CONTROL_STATUS
 *  address
 *  
 *  Input: None 
 *  Output: None
 */
void waitForData(){
  bool finish = false;
  byte bit1 = 0;
  byte bit2 = 0;
  while(!finish){
    Wire.beginTransmission(bq35100_addr);
    Wire.write(0x00);
    Wire.write(0x00);
    Wire.write(0x00);
    Wire.endTransmission();
    delay(ten_milliseconds); 
    Wire.beginTransmission(bq35100_addr);
    Wire.write(0x00);
    Wire.endTransmission();
    Wire.requestFrom(bq35100_addr,2);
    if(Wire.available() <= 2){
      bit1 = Wire.read();
      bit2 = Wire.read();
    }
   finish = bitRead(bit1,6); 
  }
}

/* ------------- waitForLearningPulse ------------------
 *  
 *  This function waits for the next learning pulse by 
 *  waiting a set amount of time determined by the user
 *  
 *  Inputs: None
 *  Outputs: None
 */
void waitForLearningPulse(){
  int this_current = 0;
  while(this_current > -5){
   delay(one_second);
   this_current = getCurrent();
  }
  stopGauge();
  sleepGauge();
  delay(110000);
  wakeupGauge();
  startGauge();
}

/* -------------- waitForFirstDischarge -----------------
 * 
 *  This function waits for the first discharge that 
 *  happens by polling the gauge for the current. When the 
 *  current goes below a certain threshold then it keeps
 *  track of the start time and the time the discharge 
 *  finishes
 *  
 *  Inputs: None
 *  Outputs: None 
 */
 /*
void waitForFirstDischarge(){
  int this_current = 0;
  while(this_current > currentLowerBound){
    delay(1000);
    this_current = getCurrent();
  }
  startTime = millis();
  delay(dischargeTime);
  lastDischarge = millis();
}
*/
/* ---------------- dataFromAddress -----------------
 * 
 * This function uses the address passed to then
 * request 2 bytes of data from the gauge. The 2 bytes 
 * return is in a little endian format. The data is 
 * transformed into a word and returned.
 * 
 * Input: Address
 * Output: Word
 * 
 */
word dataFromAddress(byte addr){
  word LSB = 0;
  word MSB = 0;
  word combined = 0;
  Wire.beginTransmission(bq35100_addr);
  Wire.write(addr);
  Wire.endTransmission();
  Wire.requestFrom(bq35100_addr,2);

  if(Wire.available()<= 2){
    LSB = Wire.read();
    MSB = Wire.read();
  }
  
  combined = byteCombiner(MSB,LSB);
  return combined;
}

/* -------------- getCurrent ----------------
 *  
 *  This function gets the current reading 
 *  from the gauge
 *  
 *  Note: This function is seperate to 
 *  dataFromAddress becuase current is a 
 *  signed integer
 *  
 *  Inputs: None
 *  Output: Signed Int
 */
int getCurrent(){
   word LSB = 0;
   word MSB = 0;
   int combined = 0;
   Wire.beginTransmission(bq35100_addr);
   Wire.write(bq35100_current_LSB_addr);
   Wire.endTransmission();
   Wire.requestFrom(bq35100_addr,2);

   if(Wire.available() <= 2){
     LSB = Wire.read();
     MSB = Wire.read();
   }
   combined |= LSB;
   MSB = MSB << 8;
   combined |= MSB;
   return combined;
}

/* --------------------- fromDataFlash -----------------------------
 *  
 *  This function returns data from the specified Data Flash memory
 *  address
 * 
 *  Inputs: MSB of address, LSB of address
 *  Output: unsigned long 
 */
unsigned long fromDataFlash(byte addrMSB, byte addrLSB){
  Wire.beginTransmission(bq35100_addr);
  Wire.write(bq35100_MAC_addr);
  Wire.write(addrLSB);
  Wire.write(addrMSB);
  Wire.endTransmission();
  delay(10);
  Wire.beginTransmission(bq35100_addr);
  Wire.write(0x40);
  Wire.endTransmission();
  Wire.requestFrom(bq35100_addr,4);

  unsigned long firstByte = 0x00000000;
  unsigned long secondByte = 0x00000000;
  unsigned long thirdByte = 0x00000000;
  unsigned long fourthByte = 0x00000000;
 
  if(Wire.available() <= 4){
    firstByte = Wire.read();
    secondByte = Wire.read();
    thirdByte = Wire.read();
    fourthByte = Wire.read();
   }
  unsigned long combined = 0x00000000;
  firstByte = firstByte << 24;
  combined |= firstByte;
  secondByte = secondByte << 16;
  combined |= secondByte;
  thirdByte = thirdByte << 8;
  combined |= thirdByte;
  combined |= fourthByte;
  return combined;
}

bool checkEOS(){
  byte first = 0x00;
  Wire.beginTransmission(bq35100_addr);
  Wire.write(0x0B);
  Wire.endTransmission();
  Wire.requestFrom(bq35100_addr,1);
  if(Wire.available()<= 1){
    first = Wire.read();
  }
  return bitRead(first,3);
}

I hope this helps!

Regards,

Nick Richards