Arduino LTC6804 BMS - Part 1: Main Board

Part 2 is here

Part 3 is here

NOTE:

You can purchase blank PCBs for this project on my Tindie store here:

https://www.tindie.com/products/dcaditz/arduino-lt...

Overview

The LTC6804-2 is a battery monitor IC which can monitor up to 12 series connected batteries. It has five general purpose IO pins which can be used to measure sensor values ( e.g., battery temperatures) or control external relays. It also has 12 balancing control outputs for passive battery pack balancing. The LTC6804-2 can be controlled, and data registers can be read, through an 4-wire SPI interface.

The LTC6804-2 can fairly easily interface with an Adruino microcontroller board such as an Arduino Uno. I chose a stacked system with the LTC6804 PCB deisgned as an Arduino shield. The complete system comprises an Arduino Uno, a custom designed LTC6804 BMS board, a balance board and optionally an Xbee wireless mesh network shield to communicate with a monitoring station. The balance board and Xbee system will be explained in a separate Instructable.

Supplies

You can order the BMS PCBs here:

https://www.tindie.com/products/dcaditz/arduino-ltc6804-battery-management-system-pcb/

Step 1: Theory of Operation

The BMS is configured for a battery pack are composed of A123 LiFePO4 cylindrical batteries in 12S8P configuration. The A123 cells have the following characteristics:

Nominal capacity 2.3Ah Min discharge voltage: 2.0 V Max charge voltage: 3.8V Max continuous charge current: 10A Max continuous discharge current: 60A Max recommended temperature 70C The function of the BMS is to maintain the pack within the above specifications. When one or more of the 8P sections of the battery pack are found to be out of range, the BMS deactivates the appropriate relay to isolate the pack. The charge relay disconnects the pack from the charger when an over-voltage or over-current state is detected. The discharge relay disconnects the pack from the load when an under-charge state or load over-current is detected. In addition, both relays are deactivated when an over-temperature state is detected. Care should be taken when a relay is deactivated since the BMS may reactivate the relay when the fault state is eliminated, supplying power to the load. Always assume the battery pack is live and disconnect manually before performing work on the electrical system.

Step 2: BMS Circuit

The BMS circuitboard was designed using Eagle CAD. The PCB is designed
to plug in to an Arduino Uno, which is programmed to control the LTC6804 through the 4-wire SPI interface at pins 41-44. The arduino reads the data collected by the LTC6804 such as cell voltages, current and cell temperatures and also controls peripheral circuitry such as relays. The schematic is provided in Figure 1. R-C filters are provided for each cell monitoring input. Analog inputs A2 - A5 are connected to the corresponding Arduino analog input pins, with +5 and ground also routed to each connector. A0 connects to a LEM hall effect sensor which outputs approximately Vin/2 at zero current where Vin is nominally 12 volts. A separate voltage divider connects to A1 which monitors the true Vin, which may vary with the state of charge of the external 12V supply. The relay drivers are controlled by the Arduino's digital pins 8 and 9. You can view the schematic in higher resolution here: http://caditz.us/images/electronics/BMS/BMS8d.png or you can download and extract the zip file, which contains a higher resolution schematic and a parts list (BOM).

Step 3: PCB Layout and Routing

The PCB is a 2-layer design using surface mount components. Most discreet components use 0805 packages since smaller packages are difficult to solder by hand. The LTC6804 itself is provided as a 48 pin SSOP with 0.5mm lead spacing which can be challenging to solder. The bottom layer is specified as a ground plane to minimize noise. Eagle CAD did a fairly good job of trace routing after the components were placed in reasonable locations with enough space between. You may contact me to obtain a PCB (I may do another PCB run if enough people are interested.) Also, Gerber files are provided here if you want to make your own PCBs. There are many free and paid tools to view the Gerber files. I use the free version of ViewMate by Pentalogix (https://www.pentalogix.com/t/software-products/viewmate). These Gerber files can be sent to a PCB manufacturer.

Step 4: PCB Assembly

Prototype BMS PCBs were soldered by hand using a Weller WESD51 temperature controlled soldering station with an ETB ET series 0.093 "screwdriver" tip. Although smaller tips may seem better for intricate work, they do not retain heat and make the job more difficult. Use a flux pen to clean the PCB pads before soldering. 0.3 mm solder works well for hand soldering SMD parts. It works well to place a bit of solder on one pad, place the device and tack down that pad. The remaining pads can then be soldered without the part moving. A different technique is needed for the LTC6804 SSOP package which has quite narrow pin spacing. One method uses large amount of solder which is allowed to bridge the pins. The excess is then removed with high quality solder wick. For the second method, pre-apply a small amount of solder on each pad. The IC is then placed and tacked down pin by pin. It is good practice to place the most difficult component first so that if it fails, the remaining components are not wasted. Work can be done under a magnifying glass. Taking a photo with your phone and zooming in is a good way to inspect for cold joints or bridging. A hot air rework station is also useful to remove surface mount components when all else fails.

Step 5: Connections

The BMS board is designed to be connected to an Arduino UNO as a standard shield. It draws power directly from the Arduino, which should be plugged in to a 12V supply. The BMS board has input connectors for two temperature sensors and a LEM Hall effect current sensor. The board uses TE/APM 5-103634-2 three position right angle header connectors for these sensor inputs. The sensor cables should mate to these headers with the pin definitions (gnd, +5v and signal) indicated on the circuitboard. There are optional slots on the circuitboard for two additional temperature sensor inputs and two general purpose input/outputs (GPIO). Temperature sensors are MPC9700 3-pin Thermistor ICs or similar: Datasheet. The arduino code is calibrated for a 50 amp LEM HTB 50-P/SP5 current sensor. Other current sensors can be used, but the code may need modification if the sensor has a different nominal current rating. There are two relay control outputs which use TE/APM 103635-1 two position headers. One relay header is for the charge relay and the other is for the discharge relay. These can be repurposed for other uses in the arduino code. The board supplies power to the relay coils with a maximum rated current of 9 amps, but this may be limited by your arduino power supply. Note: powering the Arduino from USB cable will probably not provide enough current to keep the relay coils energized. Battery sense wires plug into the top row of the 13 pin, 0.1 pin spacing header. Respect the indicated polarity when connecting the battery sense wires. Reversing the polarity may cause permanent damage to the BMS board. Gerber files are provided below if you want to make your own PCBs.

Step 6: Arduino Code

The Arduino firmware for the BMS is on Github https://github.com/dcaditz/BMS_V4 and also provided inline below. You may have to tweak it a bit to deal with updates to external libraries since this project was published. There are also several optional features such as code for cell balancing or XBee communications that you may want to comment or uncomment based on your implementation.

The libraries for interacting with the LTC6804 are specified in the header. These can be found on the Linear Technology website:

https://www.analog.com/en/search.html?q=LTSketchbo...

Download and extract LTSketchbook.zip to find the listed libraries.

The code poles the LTC6804 every 5 seconds and reads the battery cell voltages, pack temperature sensors and total current. If any values are out of the pre-defined safe range, the arduino opens a relay to disconnect the battery pack. The code also writes cell voltages, module temperatures, current and relay states to both to the Serial monitor and to an XBee wireless mesh network (Discussed in a separate Instructable).

#include 
#include 
#include 
//#include 
#include "Linduino.h"
#include "LT_SPI.h"
#include "UserInterface.h"
#include "LTC68042.h"
#include "Average.h"


#define TOTAL_IC  1            // Number of ICs in the isoSPI network LTC6804-2 ICs must be addressed in ascending order starting at 0.

/***** Pack and sensor characteristics *****/
const float MAX_CURRENT = 5000000000.;          // Maximum battery current(amps) before relay opens
const float MAX_TEMP  = 50. ;                   // Maximum pack temperature (deg C) before relay opens
const float LEM_RANGE =  50.;                   // Rated range of LEM hall sensor.
const float MIN_CELL_V = 2.20;                  // Minimum allowable cell voltage. Depends on battery chemistry.
const float MAX_CELL_V = 3.60;                  // Maximum allowable cell voltage. Depends on battery chemistry.
const float CELL_BALANCE_THRESHOLD_V = 3.3;     // Cell balancing occurrs when voltage is above this value

/***** Xbee serial *****/
#define xbRxD 4
#define xbTxD 5
SoftwareSerial XbeeSerial(xbRxD, xbTxD);

/******** Arduino pin definitions ********/
int chargeRelayPin = 8;               // Relay output for overcharge conditions
int dischargeRelayPin = 9;            // Relay output for undercharge conditions
int currentPin = A0;                  // LEM Input should be Vcc/2 + I * 1.667 / LEM_RANGE
int currentBiasPin = A1;              // For comparing with LEM output (currentPin) since Vcc/2 may change as aux battery discharges.
int tempPins[] = {A2};                // Array of arduino pins used for temperature sensor inpout


/********  Variables for tracking cell voltages and states ***************/
int overCharge_state = LOW;           // Over charge state. HIGH = relay on, LOW = relay off
int underCharge_state = LOW;          // Under charge state. HIGH = relay on, LOW = relay off
int overTemp_state = LOW;             // Over temperature state. HIGH = relay on, LOW = relay off
int overCurrent_state = LOW;          // Over current state. HIGH = relay on, LOW = relay off
int chargeRelay_state;
int dischargeRelay_state;
int cellMax_i;                        // Temporary variable for holding index of cell with max voltage
int cellMin_i;                        // Temporary variable for holding index of cell with min voltage
float  cellMin_V;                     // Temporary variable for holding  min measured cell voltage
float  cellMax_V;                     // Temporary variable for holding  max measured cell voltage
float minV1 ;
float maxV1 ;


/********   Current and temperature variables ***********************/
const uint16_t imax = 100;                 // Size of arrays for averaging read measurements
Average lemHistory(imax);
Average lemBiasHistory(imax);
float lem = 0;
float lemBias = 0;
float lemZeroCal = 0;
float current = 0;
float temp[sizeof(tempPins)];

int error = 0;
unsigned long  tstart;


/******************************************************
  Global Battery Variables received from 6804 commands
  These variables store the results from the LTC6804
  register reads and the array lengths must be based
  on the number of ICs on the stack
 ******************************************************/


uint16_t cell_codes[TOTAL_IC][12];
/*!<
  The cell codes will be stored in the cell_codes[][12] array in the following format:

  |  cell_codes[0][0]| cell_codes[0][1] |  cell_codes[0][2]|    .....     |  cell_codes[0][11]|  cell_codes[1][0] | cell_codes[1][1]|  .....   |
  |------------------|------------------|------------------|--------------|-------------------|-------------------|-----------------|----------|
  |IC1 Cell 1        |IC1 Cell 2        |IC1 Cell 3        |    .....     |  IC1 Cell 12      |IC2 Cell 1         |IC2 Cell 2       | .....    |
****/

uint16_t aux_codes[TOTAL_IC][6];
/*!<
  The GPIO codes will be stored in the aux_codes[][6] array in the following format:

  |  aux_codes[0][0]| aux_codes[0][1] |  aux_codes[0][2]|  aux_codes[0][3]|  aux_codes[0][4]|  aux_codes[0][5]| aux_codes[1][0] |aux_codes[1][1]|  .....    |
  |-----------------|-----------------|-----------------|-----------------|-----------------|-----------------|-----------------|---------------|-----------|
  |IC1 GPIO1        |IC1 GPIO2        |IC1 GPIO3        |IC1 GPIO4        |IC1 GPIO5        |IC1 Vref2        |IC2 GPIO1        |IC2 GPIO2      |  .....    |
*/

uint8_t tx_cfg[TOTAL_IC][6];
/*!<
  The tx_cfg[][6] stores the LTC6804 configuration data that is going to be written
  to the LTC6804 ICs on the daisy chain. The LTC6804 configuration data that will be
  written should be stored in blocks of 6 bytes. The array should have the following format:

  |  tx_cfg[0][0]| tx_cfg[0][1] |  tx_cfg[0][2]|  tx_cfg[0][3]|  tx_cfg[0][4]|  tx_cfg[0][5]| tx_cfg[1][0] |  tx_cfg[1][1]|  tx_cfg[1][2]|  .....    |
  |--------------|--------------|--------------|--------------|--------------|--------------|--------------|--------------|--------------|-----------|
  |IC1 CFGR0     |IC1 CFGR1     |IC1 CFGR2     |IC1 CFGR3     |IC1 CFGR4     |IC1 CFGR5     |IC2 CFGR0     |IC2 CFGR1     | IC2 CFGR2    |  .....    |

*/

uint8_t rx_cfg[TOTAL_IC][8];
/*!<
  the rx_cfg[][8] array stores the data that is read back from a LTC6804-1 daisy chain.
  The configuration data for each IC  is stored in blocks of 8 bytes. Below is an table illustrating the array organization:

  |rx_config[0][0]|rx_config[0][1]|rx_config[0][2]|rx_config[0][3]|rx_config[0][4]|rx_config[0][5]|rx_config[0][6]  |rx_config[0][7] |rx_config[1][0]|rx_config[1][1]|  .....    |
  |---------------|---------------|---------------|---------------|---------------|---------------|-----------------|----------------|---------------|---------------|-----------|
  |IC1 CFGR0      |IC1 CFGR1      |IC1 CFGR2      |IC1 CFGR3      |IC1 CFGR4      |IC1 CFGR5      |IC1 PEC High     |IC1 PEC Low     |IC2 CFGR0      |IC2 CFGR1      |  .....    |
*/



/*!**********************************************************************
  \brief  Inititializes hardware and variables
 ***********************************************************************/
void setup()
{
  pinMode(chargeRelayPin, OUTPUT);
  pinMode(dischargeRelayPin, OUTPUT);
  pinMode(currentPin, INPUT);
  pinMode(currentBiasPin, INPUT);
  for (int i = 0; i < sizeof(tempPins) / sizeof(int); i++)
  {
    pinMode(tempPins[i], INPUT);
  }
  digitalWrite(dischargeRelayPin, LOW); // turn off relays during setup
  digitalWrite(chargeRelayPin, LOW);    // turn off relays during setup

  overCharge_state = HIGH;
  underCharge_state = HIGH;

  Serial.begin(9600);
  XbeeSerial.begin(9600);

  LTC6804_initialize();  //Initialize LTC6804 hardware
  init_cfg();            //initialize the 6804 configuration array to be written
  delay(1000);
  lemZeroCal = zeroCurrentCalibrate();   // Calibrates LEM sensor at zero current
  overCurrent_state = HIGH;
  tstart = millis();
}

/*!*********************************************************************
  \brief main loop
***********************************************************************/
void loop()
{


  //  while (overCurrent_state == LOW) {
  //    Serial.println("RESET TO CONTINUE");
  //    delay(10000);
  //  }

  // read current:
  //overCurrent_state = HIGH;
  current = readCurrent();


  // read temperatures:
  overTemp_state = HIGH;
  for (int i = 0; i < sizeof(tempPins) / sizeof(int); i++)
  {
    temp[i] = (analogRead(tempPins[i]) * 5. / 1024 - 0.5) / 0.01;
    if (temp[i] > MAX_TEMP) {
      overTemp_state = LOW;
      Serial.println("OVER TEMPERATURE STATE DETECTED.");
    }
  }

  // read cells:
  wakeup_idle();
  LTC6804_adcv(); // do cell AD conversion and fill cell registers
  delay(10);
  wakeup_idle();
  error = LTC6804_rdcv(0, TOTAL_IC, cell_codes); // read cell voltages from registers
  if (error == -1)
  {
    Serial.println("A PEC error was detected in the received data");
  }

  // print to serial outputs:
  print_cells();

  // test for over charge/undercharge states:
  minV1 = MIN_CELL_V;
  maxV1 = MAX_CELL_V;

  if (overCharge_state == LOW) { // add hysteresis
    maxV1 = maxV1 - .2;
  }

  if (underCharge_state == LOW) { // add hysteresis
    minV1 = minV1 + .2;
  }

  // get maximum and minimum cells:
  cellMax_i = -1;
  cellMin_i = -1;
  cellMin_V = 100.;
  cellMax_V = 0.;
  for (int i = 0; i < 12; i++)
  {
    float V = cell_codes[0][i] * 0.0001;
    if (V < cellMin_V) {
      cellMin_V = V;
      cellMin_i = i;
    }
    if (V > cellMax_V) {
      cellMax_V = V;
      cellMax_i = i;
    }
  }

  underCharge_state = HIGH;
  overCharge_state = HIGH;
  overCurrent_state = HIGH;

  if (cellMin_V <= minV1)
  {
    underCharge_state = LOW;
    // Serial.println("V <= MIN_CELL_V");
  }
  if (cellMax_V >= maxV1)
  {
    overCharge_state = LOW;
    //Serial.println("V >= MAX_CELL_V");
  }
  if (abs(current) > MAX_CURRENT) {
    overCurrent_state = LOW;
  }
  // set relay states:

  chargeRelay_state = overCurrent_state &&  underCharge_state && overCharge_state &&  overTemp_state ;
  dischargeRelay_state =  overCurrent_state &&  overCharge_state && underCharge_state &&  overTemp_state;
  digitalWrite(chargeRelayPin, chargeRelay_state  );
  digitalWrite(dischargeRelayPin, dischargeRelay_state);

  //while (chargeRelay_state == LOW || dischargeRelay_state== LOW ) {
  //  Serial.println("RESET TO CONTINUE");
  //  delay(10000);
  //}

  //  if (abs(current) > MAX_CURRENT) {
  //    overCurrent_state = LOW;
  //    digitalWrite(chargeRelayPin,  overCurrent_state  );
  //    digitalWrite(dischargeRelayPin,  overCurrent_state );
  //    Serial.println("OVER CURRENT STATE DETECTED. PRESS RESET TO CONTINUE");
  //    delay(10000);
  //  } else {
  //    overCurrent_state = HIGH;
  //    //    chargeRelay_state = overCharge_state &&  overTemp_state ;
  //    //    dischargeRelay_state =  underCharge_state &&  overTemp_state;
  //    chargeRelay_state = underCharge_state && overCharge_state &&  overTemp_state ;
  //    dischargeRelay_state =  overCharge_state && underCharge_state &&  overTemp_state;
  //    digitalWrite(chargeRelayPin, chargeRelay_state  );
  //    digitalWrite(dischargeRelayPin, dischargeRelay_state);
  //  }

  //
  //  if (underCharge_state == LOW ) {
  //    Serial.println("UNDER VOLTAGE STATE DETECTED.");
  //    digitalWrite(dischargeRelayPin, dischargeRelay_state);
  //  }
  //
  //  if (overCharge_state == LOW ) {
  //    Serial.println("OVER VOLTAGE STATE DETECTED.");
  //    digitalWrite(chargeRelayPin, chargeRelay_state  );
  //  }


  // take advantage of open relay to recalibrate LEM zero current setting:
  if (underCharge_state == LOW or overCharge_state == LOW ) {
    lemZeroCal = zeroCurrentCalibrate();
  }


  //  cell balancing:
  //  Turn on switch Sx for highest cell x if voltage is above threshold
  //  Note: DCP is set to 0 in initialize() This turns off discharge when cell voltages are read.
  // set values in tx_cfg


  //cellMax_i = 5;
  if (cellMax_V >= CELL_BALANCE_THRESHOLD_V)
  {
    balance_cfg(0, cellMax_i);
    //Serial.print("Balance ");
    //Serial.println(cellMax_i);
  } else {
    balance_cfg(0, -1);
  }

  // write tx_cfg to LTC6804. This sets the LTC6804 DCCx registers which control the S pins for balancing:
  LTC6804_wrcfg( TOTAL_IC, tx_cfg);

  delay(5000);

}



/*!***********************************
  \brief Initializes the configuration array
 **************************************/
void init_cfg()
{
  for (int i = 0; i < TOTAL_IC; i++)
  {
    tx_cfg[i][0] = 0xFE;
    //tx_cfg[i][1] = 0x04 ;
    tx_cfg[i][1] = 0x4E1 ; // 2.0V
    //tx_cfg[i][2] = 0xE1 ;
    tx_cfg[i][2] = 0x8CA; // 3.6V
    tx_cfg[i][3] = 0x00 ;
    tx_cfg[i][4] = 0x00 ; // discharge switches  0->off  1-> on.  S0 = 0x01, S1 = 0x02, S2 = 0x04, 0x08, 0x10, 0x20, 0x40, 0x80
    // tx_cfg[i][5] = 0x00 ;
    tx_cfg[i][5] = 0x20 ; // sets the software timer to 1 minute
  }
}



/*!***********************************
  \brief sets  the configuration array for cell balancing
  uses CFGR4 and lowest 4 bits of CGFR5
 **************************************/
void balance_cfg(int ic, int cell)
{
  tx_cfg[ic][4] = 0x00; // clears S1-8
  tx_cfg[ic][5] = tx_cfg[ic][5]  & 0xF0; // clears S9-12 and sets software timer to 1 min
  //Serial.println(tx_cfg[ic][5] & 0xF0,BIN);
  if (cell >= 0 and cell <= 7) {
    tx_cfg[ic][4] = tx_cfg[ic][4] | 1 << cell;
  }
  if ( cell > 7) {
    tx_cfg[ic][5] = tx_cfg[ic][5] | ( 1 << (cell - 8));
  }
}


/*!************************************************************
  \brief Prints Cell Voltage Codes to the serial port
 *************************************************************/
void print_cells()
{
  unsigned long elasped = millis()  - tstart;
  float moduleV;
  serialPrint(elasped);   //ELAPSED TIME:
  
  //INDIVIDUAL CELL VOLTAGES:
  for (int current_ic = 0 ; current_ic < TOTAL_IC; current_ic++)
  {
    moduleV = 0.;
    for (int i = 0; i < 12; i++)
    {
      moduleV = moduleV + cell_codes[current_ic][i] * 0.0001;
      serialPrint(cell_codes[current_ic][i] * 0.0001);     
    }
  }  
  serialPrint(moduleV);      // TOTAL MODULE VOLTAGE:
  serialPrint(current);     //MODULE CURRENT:
  
  //TEMPERATURES:
  for (int i = 0; i < sizeof(tempPins) / sizeof(int) ; i++)
  {
    serialPrint( temp[i]);
  }

  //RELAY STATES:
  serialPrint( chargeRelay_state);
  serialPrint( dischargeRelay_state);
  
  serialPrint("\r\n");

}


/*!****************************************************************************
  \brief print function overloads:
 *****************************************************************************/
void serialPrint(String val)
{
  Serial.print(val);
  Serial.print("\t");
  XbeeSerial.print(val);
  XbeeSerial.print("\t");
}

void serialPrint(unsigned long val)
{
  Serial.print(val);
  Serial.print("\t");
  XbeeSerial.print(val);
  XbeeSerial.print("\t");
}


void serialPrint(double val)
{
  Serial.print(val, 4);
  Serial.print("\t");
  XbeeSerial.print(val, 4);
  XbeeSerial.print("\t");
}

void serialPrint(int val)
{
  Serial.print(val);
  Serial.print("\t");
  XbeeSerial.print(val);
  XbeeSerial.print("\t");
}



/*!****************************************************************************
  \brief Prints GPIO Voltage Codes and Vref2 Voltage Code onto the serial port
 *****************************************************************************/
void print_aux()
{

  for (int current_ic = 0 ; current_ic < TOTAL_IC; current_ic++)
  {
    Serial.print(" IC ");
    Serial.print(current_ic + 1, DEC);
    for (int i = 0; i < 5; i++)
    {
      Serial.print(" GPIO-");
      Serial.print(i + 1, DEC);
      Serial.print(":");
      Serial.print(aux_codes[current_ic][i] * 0.0001, 4);
      Serial.print(",");
    }
    Serial.print(" Vref2");
    Serial.print(":");
    Serial.print(aux_codes[current_ic][5] * 0.0001, 4);
    Serial.println();
  }
  Serial.println();
}
/*!******************************************************************************
  \brief Prints the Configuration data that is going to be written to the LTC6804
  to the serial port.
 ********************************************************************************/
void print_config()
{
  int cfg_pec;

  Serial.println("Written Configuration: ");
  for (int current_ic = 0; current_ic < TOTAL_IC; current_ic++)
  {
    Serial.print(" IC ");
    Serial.print(current_ic + 1, DEC);
    Serial.print(": ");
    Serial.print("0x");
    serial_print_hex(tx_cfg[current_ic][0]);
    Serial.print(", 0x");
    serial_print_hex(tx_cfg[current_ic][1]);
    Serial.print(", 0x");
    serial_print_hex(tx_cfg[current_ic][2]);
    Serial.print(", 0x");
    serial_print_hex(tx_cfg[current_ic][3]);
    Serial.print(", 0x");
    serial_print_hex(tx_cfg[current_ic][4]);
    Serial.print(", 0x");
    serial_print_hex(tx_cfg[current_ic][5]);
    Serial.print(", Calculated PEC: 0x");
    cfg_pec = pec15_calc(6, &tx_cfg[current_ic][0]);
    serial_print_hex((uint8_t)(cfg_pec >> 8));
    Serial.print(", 0x");
    serial_print_hex((uint8_t)(cfg_pec));
    Serial.println();
  }
  Serial.println();
}

/*!*****************************************************************
  \brief Prints the Configuration data that was read back from the
  LTC6804 to the serial port.
 *******************************************************************/
void print_rxconfig()
{
  Serial.println("Received Configuration ");
  for (int current_ic = 0; current_ic < TOTAL_IC; current_ic++)
  {
    Serial.print(" IC ");
    Serial.print(current_ic + 1, DEC);
    Serial.print(": 0x");
    serial_print_hex(rx_cfg[current_ic][0]);
    Serial.print(", 0x");
    serial_print_hex(rx_cfg[current_ic][1]);
    Serial.print(", 0x");
    serial_print_hex(rx_cfg[current_ic][2]);
    Serial.print(", 0x");
    serial_print_hex(rx_cfg[current_ic][3]);
    Serial.print(", 0x");
    serial_print_hex(rx_cfg[current_ic][4]);
    Serial.print(", 0x");
    serial_print_hex(rx_cfg[current_ic][5]);
    Serial.print(", Received PEC: 0x");
    serial_print_hex(rx_cfg[current_ic][6]);
    Serial.print(", 0x");
    serial_print_hex(rx_cfg[current_ic][7]);
    Serial.println();
  }
  Serial.println();
}

void serial_print_hex(uint8_t data)
{
  if (data < 16)
  {
    Serial.print("0");
    Serial.print((byte)data, HEX);
  }
  else
    Serial.print((byte)data, HEX);
}


/*!***********************************
  \brief Reads current input from LEM sensor
 **************************************/
float  readCurrent() {
  for (int i = 0 ; i < imax; i++) {
    lem = lemHistory.rolling(analogRead(currentPin));
    lemBias = lemBiasHistory.rolling(analogRead(currentBiasPin));
  }
  current =  ((lem - lemBias / 2. - lemZeroCal) * 3. * 5. / 1024 *  LEM_RANGE / 1.667) * 8.9 / 8.0;// assumes lem and bias are on 10k/5k voltage divider. Calibration fudge factor added.
  if (abs(current) < .2) current = 0;
  return current;
}
/*!***********************************
  \brief Reads  LEM sensor value when current is zero. Used to calibrates to zero output for zero current
 **************************************/
float  zeroCurrentCalibrate() {
  // get initial readings for current and set the zero calibration
  int iSample = 500;
  for (int i = 0 ; i < iSample; i++) {
    lemHistory.push(analogRead(currentPin));
    lemBiasHistory.push(analogRead(currentBiasPin));
  }
  lem = lemHistory.mean();
  lemBias = lemBiasHistory.mean();
  return  lem - lemBias / 2.;
}

Step 7: Operation

The above images show data collected from an operating BMS. The first is the output of the BMS to a serial terminal (the result of the Serial.print() operations in the Arduino code). You can obtain output by connecting the BMS Arduino to a USB port on your computer using an appropriate USB cable.. Open the Serial Monitor on your Arduino IDE or a serial terminal program such as PuTTY or Realterm and connect to the appropriate COM port. The first column is elapsed time in ms, then 12 columns of battery cell voltages, the total module voltage, current, temperature and relay states. This data was taken when the pack was floating and the current was zero.

The graph shows cell voltages and module current collected during charge, discharge and float testing of the BMS. Different voltage curves (Channels 2-13) represent different cells in the battery module. In this case, the cell connected to Channel 2 has lower capacity than the remaining cells. Since the cells are connected in series, Channel 2 is limiting the capacity of the entire battery pack. This shows the importance of cell balancing, which I discuss in a separate Instructable.

Step 8: Going Further

The BMS system presented here can be used as a stand-alone system for protecting a battery pack from overcharge, undercharge, overcurrent and overtemperature conditions. I will discuss additional important functionality in subsequent Instructables including module balancing and monitoring of one or more BMS systems from a remote base station.

Step 9: Files

1) BMS.lbr Eagle library file

Comments

[Roland Steinauer]

Hello David
Can you tell me the Digikey part number or MPN to the components on the balance board ?
Thanks and greetings Roland

[ibrahimabdulmaleek123]

can i follow this process for ltc6803-2 for bms.
and also what balancing method is best for ltc6803-2?
please reply.

[dcaditz]

Indian not use the LTC6803. You would have to compare the 03 and 04 data sheets to see whether they are pin compatible. Also, you should have to compare the firmware requirements. Hope this helps.

[Ahmedchegg2000]

Which stimulation is used for it. Please give me the answer

[dcaditz]

Hi. I am not sure I understand your question. Do you mean how is the BMS powered? You would have to provide a 12v supply from somewhere to power the Arduino. You could use a separate power supply or a DC-DC converter connected to the battery pack itself. If you want to power from the battery pack, it would be safest to use an isolated DC-DC converter. I would not recommend trying to tap directly into the battery pack to get 12V.

[julio s]

Hello dcaditz, Im a student in electronics engineering from polytechnic university of Valencia.
I am trying to build a prototype myself from scratch following your guidelines. I will be building it on protoboards, do you think it is doable in this way?
How would i connect for exaple the LEM current sensor you proposed without the header?
I have to my disposal a Lab power supply for Vin if necessary, as i do not understand where does Vin in your LEM_HEADER come from, i guessed form the Vin pin in arduino board, but im not too sure if that pin provides the 12V necessary por LEM sensor.
Also do you have available any of the calculus you made for the power dissipation in the passive balance circuit? It would be very much appreciated.
Thanks in advance for your time.

[dcaditz]

HI Julio. You will probably have to solder some jumper wires to the LEM current sensor if you want to try a protoboard. Also, you would have to supply your 12V from some power supply (or, if you are very careful, from the battery pack. Just make sure you don't short circuit the pack.) In general, I would not recommend trying a protoboard. There will be way too many jumper wires to deal with and too many chanced for bad connections and noise pickup. The custom PCB is best. The power dissipation is a straightforward I^2R (or V^2/R) calculation

[julio s]

Thanks for your response dcaditz.
I was also wondering, the bleed circuits funcionality.
I tried to simulate the balance circuit on proteus, which probably wasnt the best idea, i wasnt sure if the whole current from the batteries had to pass through the the p mosfet and the bleed resistor when signal S was deactivated, or just several milli amps.

So with the simulation i found out that the signal S had to be in the voltage range of Ci and C(i-1) of the measured cell, in order to keep the bleed circuit open, and it had to be at 0V for the circuit to flow ( as it is a P mosfet). And realised that for S12 for example, a lot of voltage was needed as it was close to v+.

Also i only managed to make 0.25A flow through the bleed resistor when activating an S signal, the thing is, that Id flowed in the same direction as the current in the batteries and ended up adding up at the cell it was suppose to dissipate energy from. So if there was 8A in the battery pack, in that series there would be 8.25.

[dcaditz]

Balancing currents for this BMS (and most others) are a few hundred milliamps at most. It should take many hours to balance the pack properly.

[julio s]

Ah i understand, but when simulating, the cell that was supposed to be being balanced, had more current when the P mosfet had Vg on low (and the drain circuit was working).
Isnt it supposed to take some of the current flowing through the battery in order to dissipate it? i think because of the mosfet type P current flows in the wrong direction and adds up at the battery again

[dcaditz]

I’m not sure how your simulation works, but the balance circuit is supposed to slowly drain current from the section of the battery with the highest voltage. I know for certain that it does work properly on my design.

[emrecevik335]

I'm developing a circuit that monitors 40 batteries, I am using 4 ltc6804-2.I don't know how to integrate each other. Can you help with codes and electronics?. Thank you

[dcaditz]

Hi thanks for your question. Integration of multiple LTC6804 is explained in detail in the LTC6804 datasheet. Please study the datasheet for answers to your question.

[emrecevik335]

I need to watch 20 cell battery and I couldn't find it in the dataset. Can you help me?

[iraslav]

Thank you for sharing such a wonderful project, I have been trying to replicate the design (with 12s pack) for some time now, but we seem to get 6.5335 voltage across all the cells. I ordered the original circuit boards of your design from internet soldered the IC (ltc 6804-2) and other discrete components but not able to get the desired results.

I would really appreciate if you could please suggest what could be possible issue with this circuit.

[dcaditz]

Hi iraslav. The behavior that you are describing is almost always due to one or more bad solder joints on the LTC6804. I would recommend that you try to methodically go through each pin with a multimeter and make sure there are no open circuits or short circuits on the LTC pins (or anywhere else). It can be very difficult to solder this IC perfectly until you get your technique down. It is very useful to have a hot air SMD rework station to try to reflow the solder and/or remove the IC. Also, make sure you are using lots and lots of flux to help the solder flow properly.

[dipalijav27]

I am designing BMS using LTC6804-2. But I am not getting correct output, it's showing PEC error. Can you please tell me what's problem with circuit

[zargana3541]

how did you find this IC in proteus. if you have a library link can you share with me?

[dcaditz]

I just made my own part in Eagle.......sorry for the delayed response.

[ibronix]

I am creating a circuit for 12 batteries and I wil use only one LTC6804-1. I have three LTC6804-1. Every LTC6804-1 makes SPI connection with Arduino. Firstly I connected LTCs one by one with the Ardunio. The tests of this LTC6804 gave the correct results. But when I connected the other two LTC6804-1 with the Ardunio (in the same circuit), the tests did not give the correct results for between 7-12 batteries. There is a problem for ADC2 . How can I solve this problem?