How a BMS Knows What It Cannot See

The BMS estimates state of charge using three algorithms that each fail in different ways — the engineering challenge is combining them so the failures do not overlap.

The BMS must know things it cannot directly measure. State of Charge is not a physical quantity you can probe with a sensor — it is an internal thermodynamic state accessible only through imperfect proxies (voltage, current, temperature). State of Health is even more abstract — it describes the cumulative result of thousands of electrochemical aging events that individually leave no measurable trace. This article explains how the algorithms behind these estimates work, where they fail, and how protection logic translates estimates into safe operating decisions.

Coulomb Counting: The Integration Engine

Coulomb counting is the backbone of every production BMS. The equation is simple:

SOC(t) = SOC(t₀) + (1/Q_rated) × ∫[η × I(τ)]dτ

where η is the coulombic efficiency (~0.99 for Li-ion, slightly less during fast charging), I is the measured current (positive for discharge), and Q_rated is the total cell capacity.

In discrete firmware implementation:

SOC[k] = SOC[k-1] - (η × I[k] × Δt) / Q_rated

What it does well: Tracks SOC continuously during active operation. Responds immediately to current changes. Works for any chemistry. Computationally trivial.

Where it fails: The integration accumulates error. The starting SOC must be known (or estimated). If Q_rated is wrong (battery has aged), every percentage is systematically off. The current sensor's offset and gain errors integrate into SOC drift over time.

def coulomb_count(soc_prev: float, I_A: float, dt_s: float, Q_Ah: float) -> float:
    """SOC update via Coulomb counting. I_A > 0 = discharge."""
    delta_soc = (I_A * dt_s) / (Q_Ah * 3600.0)
    return float(max(0.0, min(1.0, soc_prev - delta_soc)))

def ocv_lookup(soc: float, ocv_table: list) -> float:
    """Linear interpolation from (soc, ocv_V) pairs."""
    for i in range(len(ocv_table) - 1):
        s0, v0 = ocv_table[i]
        s1, v1 = ocv_table[i + 1]
        if s0 <= soc <= s1:
            return v0 + (v1 - v0) * (soc - s0) / (s1 - s0)
    return ocv_table[-1][1]

# Example: 1C discharge on a 50 Ah NMC pack
nmc_ocv = [(0.0, 3.00), (0.25, 3.65), (0.50, 3.82), (0.75, 3.97), (1.00, 4.18)]
soc = 0.80
for step in range(5):
    soc = coulomb_count(soc, I_A=50.0, dt_s=60.0, Q_Ah=50.0)
    print(f"Step {step+1}: SOC={soc:.4f}  OCV={ocv_lookup(soc, nmc_ocv):.3f} V")

OCV Lookup: The Periodic Anchor

Open Circuit Voltage (OCV) is the battery's terminal voltage in thermodynamic equilibrium — after sufficient rest. Each SOC corresponds to a specific OCV (at a given temperature). The BMS stores this OCV-SOC relationship as a lookup table, characterised during cell development.

Rest detection: The BMS monitors |dV/dt| — the rate of voltage change. When this falls below approximately 1 mV/minute, the BMS considers the voltage stabilised and applies an OCV correction.

The LFP plateau problem: LFP's OCV changes by only ~50 mV across the 15–90% SOC range. Voltage measurement noise of 1–2 mV translates directly to 1–2% SOC uncertainty. Hysteresis (OCV is different on charge vs discharge approach) adds another 3–8% uncertainty. In the plateau, OCV correction for LFP is largely useless — it cannot improve on what coulomb counting already estimated.

The Kalman Filter: Optimal Fusion

The Extended Kalman Filter is the standard algorithm for combining coulomb counting with voltage-based correction in a statistically optimal way.

The key insight: The Kalman filter is not a replacement for coulomb counting or OCV lookup — it is a framework for fusing them. The filter:

1. Predicts next SOC from coulomb counting (process model)
2. Predicts what terminal voltage the battery should show at that SOC (measurement model)
3. Compares predicted to measured terminal voltage
4. Updates the SOC estimate by the discrepancy, weighted by how much it trusts the model vs the measurements

The weighting is the Kalman gain K. If the model is trusted more (R large), corrections are small. If measurements are trusted more (Q large), corrections are aggressive.

import numpy as np

class ExtendedKalmanFilter:
    """1-state SOC EKF for lithium-ion cells."""
    def __init__(self, Q_noise: float = 1e-5, R_noise: float = 1e-3):
        self.x = np.array([0.8])    # initial SOC estimate
        self.P = np.array([[0.1]])   # initial error covariance
        self.Q = np.array([[Q_noise]])
        self.R = np.array([[R_noise]])

    def predict(self, I_A: float, dt_s: float, Q_Ah: float):
        """Time update — integrate current measurement."""
        self.x[0] -= (I_A * dt_s) / (Q_Ah * 3600.0)
        self.x[0]  = np.clip(self.x[0], 0.0, 1.0)
        self.P     = self.P + self.Q                  # F=1 for this model

    def update(self, V_meas: float, ocv_table: list):
        """Measurement update — correct with terminal voltage."""
        V_pred = ocv_lookup(self.x[0], ocv_table)
        H = np.array([[1.0]])                         # linearised dV/dSOC (simplification)
        S = H @ self.P @ H.T + self.R
        K = self.P @ H.T @ np.linalg.inv(S)          # Kalman gain
        self.x = self.x + K @ (V_meas - V_pred)
        self.P = (np.eye(1) - K @ H) @ self.P

Protection Algorithms: From Estimate to Action

Protection logic translates continuous sensor measurements and state estimates into discrete actions (derate, warn, disconnect). The architecture requires careful threshold design:

Hysteresis in the thresholds prevents oscillation — once a fault is triggered at Level 2, it does not clear until the parameter falls well below the Level 1 threshold. Timers prevent nuisance trips from brief transients (overvoltage during a regenerative braking spike that lasts 50 ms should not trigger a hard disconnect).

/* BMS protection thresholds -- NMC 21700 pack */
#define CELL_OV_WARN_MV     4180U   /* Level-1: reduce charge current  */
#define CELL_OV_FAULT_MV    4200U   /* Level-2: stop charging           */
#define CELL_UV_WARN_MV     3000U   /* Level-1: derate discharge        */
#define CELL_UV_FAULT_MV    2800U   /* Level-2: disconnect load         */
#define CELL_OT_CHARGE_DC   450     /* deg-C x10: max charge temp 45C   */
#define CELL_OT_DISCHG_DC   600     /* deg-C x10: max dischg temp 60C   */

typedef struct {
    uint16_t cell_mv;
    int16_t  temp_dc;        /* temperature in 0.1 C units */
    uint8_t  fault_flags;    /* bitmask: bit0=OV, bit1=UV, bit2=OT */
} CellState_t;

uint8_t bms_check_cell(const CellState_t *c) {
    uint8_t f = 0;
    if (c->cell_mv  >= CELL_OV_FAULT_MV) f |= 0x01;
    if (c->cell_mv  <= CELL_UV_FAULT_MV) f |= 0x02;
    if (c->temp_dc  >= CELL_OT_DISCHG_DC) f |= 0x04;
    return f;
}

Cell Balancing Algorithms

Passive balancing is simpler to implement but requires balancing algorithm decisions:

When to balance: During charging only (most common — avoids wasted energy during driving), during charging and discharging (more effective but more complex), or continuously.

Threshold: Start balancing cell N when V_N > V_min_in_pack + 5–10 mV. This prevents trivial differences from triggering balancing constantly.

End condition: Stop balancing when all cells are within 3–5 mV of each other, or when the total pack is at the target charge level.

Fault Logging and Diagnostics

A production BMS maintains a fault log — typically stored in non-volatile memory — recording every protection event with a timestamp and the measured value that triggered it. This log is essential for:

• Warranty claims: Proving or disproving that a cell failure was caused by user abuse (overcharge, overdischarge) vs manufacturing defect
• Fleet management: Early warning of cells or packs that are trending toward their protection thresholds before hard faults occur
• Regulatory compliance: AIS-156 requires fault documentation and data retention for incident investigation

The fault log is one of the most practically valuable features of a BMS that is often underutilised in Indian fleet deployments. Most BMS units in Indian commercial EVs have comprehensive fault logging capability; most fleet operators never retrieve or analyse the data.

Key Takeaways