Extended Kalman Filter (EKF) Battery SOC Estimation in MATLAB

Extended Kalman Filter (EKF) for Lithium-Ion Battery State-of-Charge Estimation in MATLAB

Dr. Elena Rostova, PhD 15 min read Doctoral Peer-Reviewed Updated Sep 2026

Toolboxes: MATLAB Base Simscape Battery

Executive Engineering Summary

Complete, runnable MATLAB implementation of an Extended Kalman Filter based on the 1st-Order Thevenin Equivalent Circuit Model (ECM). Includes covariance tuning matrix setup, Coulomb counting comparison, and automated terminal plotting.

Battery management systems need an accurate State-of-Charge (SOC) estimate to calculate driving range and protect cells from over-discharge. You cannot measure SOC directly with a physical probe. Integrating current over time (Coulomb counting: SOC(t) = SOC₀ − (1 / Q_n) ∫ I(t) dt) suffers from sensor bias that accumulates drift, and any error in your starting assumption persists indefinitely. Looking up open-circuit voltage (OCV) avoids this drift, but resting voltage curves only match terminal voltage once the cell has sat idle for several hours.

An Extended Kalman Filter (EKF) combines both methods. It treats Coulomb counting as a predictive state step and uses real-time terminal voltage measurements to correct the estimate whenever the model drifts from sensor data.

1. The 1st-order Thevenin equivalent circuit model (ECM)

To run the filter, we represent the cell as a 1st-order RC network with three primary elements:

V_oc(SOC): Open-circuit voltage source that varies nonlinearly with charge.
R₀: Ohmic resistance capturing immediate IR voltage drops across the electrolyte and current collectors.
R₁ ∥ C₁: Parallel RC branch with time constant τ = R₁ · C₁ that models charge transfer and diffusion dynamics.

Discrete-Time State Space Equations:

State 1 (Charge): SOC_k+1 = SOC_k − [η Δt / (3600 · Q_n)] · I_k + w_1,k

State 2 (RC Voltage): V_1,k+1 = e^{−Δt / τ} · V_1,k + R₁ (1 − e^{−Δt / τ}) · I_k + w_2,k

Terminal Output: V_t,k = V_oc(SOC_k) − V_1,k − R₀ · I_k + v_k

Where τ = R₁ · C₁, I_k > 0 denotes discharge, and w_k, v_k are zero-mean Gaussian process and measurement noises with covariance matrices Q and R.

2. Filter formulation and linearization

The state dynamics are linear, but the measurement equation is not: the open-circuit voltage curve V_oc(SOC) is strongly nonlinear. Because the standard Kalman filter requires a linear observation matrix, we linearize V_t,k around the predicted state using a first-order Taylor expansion:

Measurement Jacobian Matrix:

H_k = [ (∂V_oc / ∂SOC) |_{x̂_k|k−1} , −1 ]

The scalar term (∂V_oc / ∂SOC) is the local slope of the OCV curve evaluated at the current state estimate. On flat portions of the curve, this derivative is small, so terminal voltage provides little information about charge. On steeper portions, this derivative is large, and the filter updates the state estimate aggressively.

3. Runnable MATLAB implementation

This script builds an ECM for a 2.5 Ah cylindrical cell, simulates a 1-hour dynamic current profile, and corrupts current and voltage with realistic sensor noise (100 mA and 15 mV standard deviations). We deliberately initialize the filter at 65% SOC while the true cell starts at 85% to test convergence under real operating conditions.

4. Tuning the covariance matrices Q and R

The filter's convergence speed and noise rejection come down to the balance between Q and R:

Measurement variance R: Match this directly to your ADC hardware noise: R = σ_V². For an analog front end with 15 mV RMS noise, set R = (0.015)² = 2.25 × 10⁻⁴ V². Setting R too small makes the filter chase sensor jitter; setting it too high causes the estimate to ignore valid voltage corrections.
Process noise Q(1, 1) for SOC: This controls how much the algorithm trusts Coulomb counting against model discrepancies. A value around 10⁻⁶ to 10⁻⁵ works well for typical dynamic load cycles. Setting it below 10⁻⁸ makes the filter behave like open-loop Coulomb counting, preventing it from correcting initial SOC errors. Setting it above 10⁻³ allows dynamic current pulses to cause artificial jumps in estimated SOC.
Process noise Q(2, 2) for V₁: Set this between 10⁻⁵ and 10⁻⁴ to absorb unmodeled polarization effects that the single RC pair misses.

Drop-in MATLAB Implementation

The following production-ready helper script can be downloaded or integrated directly into your workspace:

% =========================================================================
% helper_battery_ekf_soc.m
% Extended Kalman Filter for Li-Ion Battery SOC Estimation
% MATLAB Helpers Technical Laboratory
% =========================================================================
clear; clc; close all;

%% 1. Cell Parameters (3.7V, 2.5Ah Cylindrical 18650 Cell)
Q_n   = 2.5;       % Nominal capacity (Ah)
R0    = 0.035;     % Ohmic resistance (Ohms)
R1    = 0.020;     % Polarization resistance (Ohms)
C1    = 1500;      % Polarization capacitance (Farads)
tau   = R1 * C1;   % RC Time constant (seconds)
eta   = 1.0;       % Coulombic efficiency

% Polynomial fit for OCV = f(SOC): Voc = p1*s^5 + p2*s^4 + ... + p6
ocv_poly = [-14.65, 41.58, -44.25, 22.06, -3.83, 3.42];

%% 2. Simulation Time Vector & Dynamic Load Generation
dt = 0.5;                  % Sampling step: 0.5 s
t  = (0:dt:3600)';         % 1 hour dynamic simulation
N  = length(t);

% Dynamic current profile (Amperes, positive = discharge)
I_true = 1.5 * sin(2*pi*t/400) + 2.0 * cos(2*pi*t/1200) + 1.2;
I_true(I_true < -0.5) = -0.5; % Regenerative braking limit

%% 3. True System Simulation (Ground Truth with Noise)
soc_true = zeros(N, 1);
soc_true(1) = 0.85;        % True initial SOC = 85%
V1_true  = zeros(N, 1);
Vt_true  = zeros(N, 1);

for k = 1:N-1
    soc_true(k+1) = soc_true(k) - (eta * dt / (3600 * Q_n)) * I_true(k);
    V1_true(k+1)  = exp(-dt/tau) * V1_true(k) + R1 * (1 - exp(-dt/tau)) * I_true(k);
    
    Voc = polyval(ocv_poly, soc_true(k));
    Vt_true(k) = Voc - V1_true(k) - R0 * I_true(k);
end
Vt_true(N) = polyval(ocv_poly, soc_true(N)) - V1_true(N) - R0 * I_true(N);

% Inject sensor noise (Current sigma = 100mA, Voltage sigma = 15mV)
I_meas = I_true + 0.100 * randn(N, 1);
Vt_meas = Vt_true + 0.015 * randn(N, 1);

%% 4. Extended Kalman Filter (EKF) Implementation
% State Vector: x = [SOC; V1]
x_est = zeros(2, N);
x_est(:, 1) = [0.65; 0.0]; % Initial guess = 65% (20% intentional error)

% Covariance Initialization
P = diag([1e-2, 1e-4]);     % Initial estimation error covariance
Q = diag([1e-6, 1e-5]);     % Process noise covariance
R = 2.25e-4;                % Measurement noise variance (0.015^2)

A = [1, 0; 0, exp(-dt/tau)];
B = [-eta * dt / (3600 * Q_n); R1 * (1 - exp(-dt/tau))];

% Coulomb Counting baseline
soc_coulomb = zeros(N, 1);
soc_coulomb(1) = x_est(1, 1);

soc_sigma = zeros(N, 1);
soc_sigma(1) = sqrt(P(1, 1));

for k = 1:N-1
    % --- Step A: Pure Coulomb Counting Baseline ---
    soc_coulomb(k+1) = soc_coulomb(k) - (eta * dt / (3600 * Q_n)) * I_meas(k);

    % --- Step B: EKF Time Update (Prediction) ---
    x_pred = A * x_est(:, k) + B * I_meas(k);
    P_pred = A * P * A' + Q;
    
    % --- Step C: Linearization of Measurement Equation ---
    soc_p = x_pred(1);
    dVoc_dSOC = polyval(polyder(ocv_poly), soc_p);
    H = [dVoc_dSOC, -1];
    
    % Predicted Terminal Voltage:
    Voc_pred = polyval(ocv_poly, soc_p);
    Vt_pred = Voc_pred - x_pred(2) - R0 * I_meas(k);
    
    % --- Step D: Measurement Update (Correction) ---
    y_tilde = Vt_meas(k) - Vt_pred;
    S = H * P_pred * H' + R;
    K = (P_pred * H') / S;
    
    x_est(:, k+1) = x_pred + K * y_tilde;
    P = (eye(2) - K * H) * P_pred;
    
    soc_sigma(k+1) = sqrt(P(1, 1));
end

%% 5. Visualization
figure('Color', [1 1 1], 'Position', [150, 100, 950, 700]);

subplot(3, 1, 1);
plot(t/60, I_meas, 'Color', [0.7 0.7 0.7], 'LineWidth', 0.8); hold on;
plot(t/60, I_true, 'Color', [0.1 0.4 0.8], 'LineWidth', 1.4);
ylabel('Current (A)'); grid on;
title('Dynamic Load Current Profile'); legend('Measured (Noisy)', 'True Current');

subplot(3, 1, 2);
plot(t/60, soc_true*100, 'k-', 'LineWidth', 1.8); hold on;
plot(t/60, soc_coulomb*100, 'r--', 'LineWidth', 1.4);
plot(t/60, x_est(1, :)*100, 'Color', [0.1 0.7 0.3], 'LineWidth', 1.8);
ylabel('SOC (%)'); grid on;
title('State-of-Charge: True vs. EKF vs. Coulomb Counting');
legend('True SOC', 'Coulomb Counting (Drifting)', 'EKF Estimate (Converging)');

subplot(3, 1, 3);
soc_err = (x_est(1, :)' - soc_true) * 100;
plot(t/60, soc_err, 'b-', 'LineWidth', 1.2); hold on;
plot(t/60, 3*soc_sigma*100, 'r:', 'LineWidth', 1.5);
plot(t/60, -3*soc_sigma*100, 'r:', 'LineWidth', 1.5);
xlabel('Time (minutes)'); ylabel('Estimation Error (%)'); grid on;
title('EKF Error with \pm3\sigma Covariance Confidence Bounds');
legend('Estimation Error', '\pm3\sigma Bound');

Dr. Elena Rostova, PhD

Principal Energy Systems Engineer

Contributing Simulation & Algorithm Research Engineer at the MATLAB Helpers Technical Laboratory. Specializing in numerical analysis, state estimation, and physical system architecture.

Need Hands-on Engineering Assistance With This Model?

Whether diagnosing non-converging numerical solvers, tuning observers, or optimizing embedded code generation, our doctoral team collaborates directly on complex engineering codebases.

Request Technical Engineering Consultation →