Arduino LTC6804 BMS - Part 1: Main Board

22,585

19

58

Introduction: 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

Attachments

Be the First to Share

    Recommendations

    • Laser Challenge

      Laser Challenge
    • Paint Challenge

      Paint Challenge
    • Unusual Uses Contest

      Unusual Uses Contest

    58 Comments

    0
    dipalijav27
    dipalijav27

    Question 3 months ago on Step 4

    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

    Screenshot (912).pngScreenshot (913).png
    0
    ibronix
    ibronix

    Question 6 months ago

    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?

    ltc3.png
    0
    dcaditz
    dcaditz

    Answer 6 months ago

    Hi Thanks for your comment. I don't think I have enough information about your circuit to give an answer here. Why are you trying to use more that one LTC6804? Also, I only have experience using a single LTC6804-2. Please make sure your circuit complies with the relevant portions of the data LTC6804 sheet (specifically the SPI interface section on p.35, Figure 17a). You may have to modify the Arduino code to handle more than one LTC6804.

    0
    ibronix
    ibronix

    Reply 6 months ago

    Thank you for comment.

    I built the circuit with DIP sheath. I test each LTC6804 in turn. As I mentioned in the picture, I get the correct results for the 1st LTC, but for the 2nd and 3rd LTC I get the wrong results. There are no daisy chains and addressed links among themselves. Communicates with Arduino SPI. The ISOMD pin is always connected to GND. The legs of the LTCs were widened and connected to the circuit by plug and play. I misread the ADC2 (CELL 7,8,9,10,11,12) for the 2nd LTC and 3rd LTC. What can I do about it?

    3. Tried all ADC mods for LTC but it didn't fix.


    0
    dcaditz
    dcaditz

    Reply 6 months ago

    I see, you are only using one LTC at a time. Just plugging in a different one and it no longer works properly, correct? Did you say that you widened the legs of the LTC to fit it in the DIP socket?

    0
    ibronix
    ibronix

    Reply 6 months ago

    Yes, I expanded the LTC legs in copper ways. My goal is to establish a balancing system for 30 battery series. I am moving slowly and systematically. The circuit and codes are the same. I just plug in LTCs respectively. I'm testing LTCs for the first attempts. While the 1st LTC is measured in the tests, the ADC2 (Cell 7,8,9,10,11,12) of the 2nd and 3rd LTC are measuring incorrectly, maybe they cannot. How we can solve this problem? (I deleted the pictures, I'm sorry.)

    0
    dcaditz
    dcaditz

    Reply 6 months ago

    I got similar behavior (some cells measuring 0 or incorrect voltage) when I had shorted or open solder joints on the LTC. I only ever used the surface mount version.

    0
    ibronix
    ibronix

    Question 6 months ago

    We build the circuit. We connected with LTC6804-1, passed SPI with arduino, but we have a problem. We removed the LTC6804-1 IC from the scale, but there is a short circuit between some C and S pins. There is a short circuit between C4 and S5 and the IC is not connected to the circuit. What could be the reason for this? At the same time, sometimes C10-S11 short circuit among themselves. What could be the reason? We set up the circuit as DIP.
    https://prnt.sc/123tyi7

    0
    dcaditz
    dcaditz

    Answer 6 months ago

    Hi ibronix. It is hard to tell, but it sounds like some solder bridging or wiring short circuits. This is not behavior that I have experienced with my PCB.

    0
    SDogi
    SDogi

    7 months ago

    Thank you very much for the guide, can I use this scheme when increasing the number of cells, and connecting additional LTC through IBP and IMP, as described in the documentation. Will Arduino be able to control them?

    0
    dcaditz
    dcaditz

    Reply 7 months ago

    Hi thanks for your question. You should be able to add additional LTCs to monitor more cells in series. You will have to study the datasheet for how to do this. The arduino should be able to handle it with some minor modifications to the code. I believe the TOTAL_IC value determines the number of LTCs used. I had set to 1.

    0
    SDogi
    SDogi

    Reply 6 months ago

    Hello, it's me again. I have a problem communicating with LTC via SPI. Instead of arduion, I used esp 32. It turns out that I do not receive a return response from LTC. Tell me where exactly in the documentation I can see the SPI connection.

    0
    ibronix
    ibronix

    Question 7 months ago

    After connecting the CSB pin, Arduino D10, how did you change the codes to indicate this pin?

    0
    ibronix
    ibronix

    Answer 7 months ago

    Please, send me answer?

    0
    dcaditz
    dcaditz

    Reply 7 months ago

    I'm not sure I understand the question. D10 is the default SS (CSB) pin on Arduino Uno. I don't believe there is anything further you have to do in the code.

    0
    ibronix
    ibronix

    Reply 6 months ago

    I want to replace D10 pin with D9. How can I edit as D9 instead of D10 in code?

    0
    shengyie97
    shengyie97

    Question 7 months ago

    Hi, thanks for your effort!
    Do you still have the assembled PCB?

    0
    dcaditz
    dcaditz

    Reply 7 months ago

    Yes I do still have fully assembled and working PCBs.

    0
    shengyie97
    shengyie97

    Reply 7 months ago

    May I know the price you going to sell?