N1-Simulating Battery Packs

ECE5720: Battery Management and Control 2–1
Simulating Battery Packs
2.1: Modeling approach #1: Equivalent-circuit models
■ One function of a battery management system is to compute

estimates of a number of fundamental quantities, including:
! State of charge, state of health, state of life,
! Available power, available energy / range.
■ The best methods require high-fidelity but computationally simple

math models of cell input/output (current/ voltage) dynamics.
■ We believe that future applications will also require insight into cell
internal dynamics (e.g., to predict and minimize degradation).
Equivalent-circuit models (ECMs):

■ Amounts to an empirical curve fit that interpolates between data
seen when fitting model (extrapolation not reliable).
■ Can predict input/output (current/voltage) behavior only, not
internal electro-chemical states.
■ But, yields fast, robust simulations.
Physics-based models (PBMs):

■ Can predict over wide range of operating conditions.
■ Can predict internal state of cell (useful for aging prediction).
■ But, slow simulations having robustness/convergence issues.
Lecture notes prepared by Dr. Gregory L. Plett. Copyright © 2013, 2015, Gregory L. Plett
ECE5720, Simulating Battery Packs 2–2
■ We studied both types of models in ECE5710, and also saw how to
compute a reduced-order PBM of similar complexity to an ECM.
■ We first review these two types of models in this chapter of notes.
■ We then apply them to simulating battery packs.
Modeling approach #1: Empirical

■ Current/voltage behavior of lithium-ion cell can appear very simple,
and is often well approximated by an equivalent circuit:
! Used extensively in real-time control algorithms.
■ The (continuous-time) “enhanced R1

hyst R0
self-correcting” (ESC) cell model C
OCV(z(t))
equivalent circuit is drawn to the C
right, modeling a single diffusion " C1 v(t)
voltage via a single R–C pair.

"
■ Enhanced: Model includes a (poor) description of hysteresis (which
is still better than not including it at all).
■ Self correcting: Model voltage converges to OCV + hysteresis on
X
rest, and to OCV + hysteresis " i R on constant current event.
■ R0, C1, and R1 are analogs of physical properties of diffusion
processes, but do not directly describe something physical.
■ Values of R0 , C1, and R1 are chosen to make model fit cell-test data:
! Values do not come from direct physical measurements.
! Parameters are typically a function of SOC and temperature.
■ The ESC model comprises the following terms:

! State-of-charge: ´kC1 D ´k " !k ik "t=Q.

! Diffusion resistor current:
! " ! ! ""
""t ""t
iR1 ;kC1 D exp R1 C1
iR1 ;k C 1 " exp R1 C1 ik .
! Hysteresis voltage:
! ˇ ˇ" ! ! ˇ ˇ""
ˇ !k ik #"t ˇ ˇ !k ik #"t ˇ
hkC1 D exp " ˇ Q ˇ hk C 1 " exp " ˇ Q ˇ sgn.ik /.
■ Note that the circuit can contain more than a single parallel
resistor-capacitor pair. We can define vector valued
2 ! " 3 2! ! "" 3
""t ""t
exp R1 C1 0 ### 1" exp R1 C1
6 ! " 7 6! ! "" 7
6 7 6 7
iR;kC1 D 4 5 iR;k C 4 1" exp R2 C2 5 ik .
""t ""t
0 exp R2 C2
::: ::: :::
„ ƒ‚ … „ ƒ‚ …
ARC BRC
! ˇ ˇ"
ˇ !k ik #"t ˇ
■ Then, if we define AHk D exp " ˇ Q ˇ ,
2 3 2 32 3 2 3
´kC1 1 0 0 ´k 0 " # " !kQ"t
6 7 6 76 7 6 7 ik
i D
4 R;kC1 5 4 0 A RC 0 i C
5 4 R;k 5 4 RC
B 0 5 .
sgn.ik /
hkC1 0 0 AHk hk 0 .1"AHk /
„ ƒ‚ … „ ƒ‚ …
A.ik / B.ik /
h iT
■ If we define xk D ´k iRTk hk , then we have
xkC1 D A.ik /xk C B.ik /ik .
■ This is the ESC “state equation”, and describes all dynamic effects.
■ The “output equation” is
X
vk D OCV.´k / C M hk " Ri iRi ;k " R0ik .
i
h i
■ We can define C D 0; "R1; "R2; : : : M and D D "R0 to arrive
at
vk D OCV.´k / C C xk C Dik .
■ So, we conclude that the ESC model looks similar to, but not identical
to, a linear state-space system of the form
xkC1 D Ak xk C Bk ik
yk D Ck xk C Dk ik .
! The dependencies of Ak and Bk on ik , and the OCV term in the
output make the equations nonlinear.
! Still, the nonlinear state-space form is conducive to applying
control-systems concepts, which we do in the following chapters.
■ ECE5710 talked about how to find the unknown model parameter
values, so we omit that discussion here.
! Finding the model:
OCV Test OCV

processOCV.m
Testing Data Relationship
Dynamic Test ESC Cell

processDynamic.m
Testing Data Model
! Simulating the model:
Cell
Current
Initial Predicted
simCell.m
State Voltage
ESC Cell
Model
2.2: Modeling approach #2: Physics-based
■ Continuum porous-electrode models use physics to derive equations
for all internal cell processes using coupled PDEs.
Negative electrode Positive electrode
Current collector
Current collector
Separator
r
x
■ Within the cell, the following state variables are of interest:

! The concentration of lithium in the solid, cs .x; r; t/, and particularly
at the surface of the solid, cs;e .x; t/,
! The concentration of lithium in the electrolyte, ce .x; t/,
! The potential in the solid, $s .x; t/,
! The potential in the electrolyte, $e .x; t/, and
! The rate of lithium movement between phases, j.x; t/.
■ These five electrochemical variables can be found by solving the five

coupled continuum-scale partial-differential equations (along with
their associated boundary conditions),
! Diffusion of lithium in the solid electrode particles
# $
@ Ds @ @cs
cs D 2 r2 .
@t r @r @r
! Charge balance in particles; electron current:
r # .%effr$s / D as F j .
! Diffusion of lithium in electrolyte:

@."e ce /
D r # .De;effrce / C as .1 " tC0 /j .
@t
! Charge balance in electrolyte; ion current:
r # .&effr$e C &D;effr ln ce / C as F j D 0.
! Reaction rate (where ! D .$s " $e / " Uocp " j FRfilm ):

% # $ # $&
.1 " ˛/F ˛F
j D k0 ce 1"˛ .cs;max"cs;e /1"˛ cs;e ˛ exp ! " exp " ! .
RT RT
■ We found that these equations could be solved by simulation, but that
simulation required considerable processor resources.
! Also, experience shows that PDE simulators can be very

fragile—have a hard time converging to robust solutions.
■ So, in ECE5710 we proposed a process to create a discrete-time
reduced-order model from the PDEs.
■ We made two basic assumptions:1
1. We assumed linear behavior: We linearized nonlinear equations

using Taylor series;
2. We assumed that the reaction current j.x; t/ was decoupled from
(not a function of) the electrolyte concentration ce .x; t/,
allowing us to create transfer functions from the linearized equations.

■ We then used a method called the “discrete-time realization
algorithm” (DRA) to create a discrete-time state-space model.
1
In simulations, we have found that the second assumption is quite good. The first
assumption is less good, but nonlinear corrections help improve linear predictions.
■ A pictorial overview of the two process steps is:
! Finding the model:
PDE Linearize Transfer Legend

model model functions
Computational process
Data
Analytic derivations
System Physics Execute Linear SS
ID/tests parameters DRA model
Lab process
Step 1: Step 2: Step 3: Step 4: hŒn' to
H.s/ to h.t / h.t / to hstep .t / hstep .t / to hŒn' b B,
A, b C b, D
b
! Simulating the model:
Input Legend: Data Computational process

current
Internal cell
Initial Make blended Simulate Linearized Make nonlinear
variables AND
state model blended model physics variables corrections
cell voltage
Multiple State of charge Physics
linear SS parameters
models
■ A key feature of the DRA-produced ROM is that nonlinear corrections

can be applied to the linearized model variables, greatly enhancing
prediction accuracy.
■ We will not discuss physics-based models further in this course—our
focus is on battery management using empirical models.
■ Battery management and controls using physics-based models is a
major focus of our present research efforts and (I hope) of a future
course.
2.3: Simulating an electric vehicle
■ When designing battery packs, it is important to be able to simulate

the pack before proceeding too far down the design path.
! Helps to ensure the pack will be able to meet all performance

requirements before a large investment has been made.
■ Battery packs may be used in all kinds of applications, but one area
of interest for large battery packs is for energy storage in xEVs.
■ To predict battery demand, we must simulate the vehicle over a
number of real-world operating scenarios, and see the profile of
power or current versus time demanded from the pack.
■ HEV simulations are extremely complex, because the internal-
combustion engine, multi-speed transmission, and hybrid blending
control algorithms need to be simulated accurately.
■ However, pure EV (and PHEV in electric-only mode) simulations are
fairly straightforward since there is no IC engine, a single-speed fixed
transmission is used, and there is no blending of power sources.
■ To simulate an electric vehicle, two things are needed.
1. An accurate description of the vehicle itself;

2. The task the vehicle is required to accomplish.
■ The vehicle description includes all factors needed for a dynamic
simulation, including battery cell characteristics, battery module
(groups of cells) characteristics, battery pack (groups of modules)
characteristics, motor and inverter (motor driving power electronics)
characteristics, drivetrain characteristics, and so forth.
■ The vehicle task is characterized by a “drive cycle”: a profile of
desired vehicle speed versus time. Some examples:
! The Urban Dynamometer Driving Schedule (UDDS)
! The Highway Fuel Efficiency Test (HW-FET)
! The New York City Cycle (NYCC), and
! The US06 drive cycle (recorded by NREL, near Golden, CO).
■ These four drive cycles are provided to you on the course web site.
They have a 1 Hz profile rate, which will be assumed below.
UDDS Drive Profile HW-FET Drive Profile

100 100
80 80
Speed (km h )
Speed (km h )
−1
−1
60 60
40 40
20 20
0 0
0 5 10 15 20 25 0 2 4 6 8 10 12 14
Time (min) Time (min)
NYCC Drive Profile US06 Drive Profile

140
40 120
Speed (km h )
Speed (km h )
100
−1
−1
30
80
20 60
40
10
20
0 0
0 2 4 6 8 10 0 2 4 6 8 10
■ All drive cycles are simulated using the same basic equations.
■ The approach is to compute, on a second-by-second basis, desired
accelerations to match the desired speed profile, therefore desired
road forces, therefore desired motor torques and power values.
■ These desired torques and power values are restricted by the
specifications of the motor chosen for the vehicle, and thus
achievable torques and power values may be of lesser magnitude.
■ Achievable torques are computed, and therefore achieved road force,
and achieved velocity (this will not always match the desired velocity).
■ Battery power is computed based on motor power, and battery SOC
is updated.
■ Over the course of the driving profile, the battery SOC is depleted a
certain amount, and the projected range of the vehicle is extrapolated
from this data.
Typical AC induction motor characteristic
■ We use a three-phase AC 300
Constant Constant power region
induction motor model, which 250
torque
region
Torque (N m)
200
limits torque and power based on
150
three design constants: 100
maximum torque, rated RPM, and 50
Rated RPM Maximum RPM
maximum RPM. 0
0 2000 4000 6000 8000 10000 12000
Speed (RPM)
■ Overall simulation flowchart calculations:
Desired Desired Desired Desired Battery

speed acceleration force torque SOC
Actual Actual Actual Limited Motor Battery

speed acceleration force torque power power
2.4: Equations for vehicle dynamics
■ In more detail: We calculate the desired vehicle acceleration as:2
desired acceleration Œm s"2' D
.desired speed Œm s"1' " actual speed Œm s"1'/=.1 Œs'/.
■ We compute desired acceleration force that the motor must produce

at the road surface:
desired acceleration force ŒN' D
equivalent mass Œkg' $ desired acceleration Œm s"2'.
■ The equivalent mass combines the maximum vehicle mass and the
equivalent mass of the rotating inertias
equivalent mass Œkg' D
maximum vehicle mass Œkg' C rotating equivalent mass Œkg'
rotating equivalent mass Œkg' D
..motor inertia Œkg m2' C gearbox inertia Œkg m2'/ $ N 2
C number of wheels $ wheel inertia Œkg m2'/=.wheel radius Œm'/2,
where N is gearbox ratio [unitless] = (motor RPM)/(wheel RPM), and

the gearbox inertia is measured at motor side, not output side.
■ Wheel radius is assumed to be that of the rolling wheel; i.e., taking
into account flattening due to load.
2
Vehicle modeling equations are from T. Gillespie, “Fundamentals of Vehicle Dynamics,”
Society of Automotive Engineers Inc, 1992.
■ Other forces acting on the vehicle are assumed to comprise:
1
aerodynamic force ŒN' D .air density ( Œkg m"3'/$.frontal area Œm2'/$
2
.drag coefficient Cd Œunitless'/ $ .prior actual speed Œm s"1'/2
rolling force ŒN' D .rolling friction coefficient Cr Œunitless'/ $
.max. vehicle mass Œkg'/ $ .acceleration of gravity Œ9:81 m s"2'/
grade force ŒN' D .maximum vehicle mass Œkg'/ $
.acceleration of gravity Œ9:81 m s"2'/ $ sin.grade angle Œrad'/
brake drag ŒN' D constant road force input by user,

where grade angle is the present (or average) slope of the road
(positive is an incline, negative is a decline).
■ Note that the rolling force is computed to be zero if the prior actual
speed is zero.
■ We can now compute the demand torque at the motor
demanded motor torque ŒN m' D .desired acceleration force ŒN' C
aerodynamic force ŒN' C rolling force [N] C grade force ŒN'C
brake drag ŒN'/ $ wheel radius Œm'=N Œunitless'.
■ Demanded torque must be compared to the maximum available

motor torque.
■ Available torque is based on a model of an ideal three-phase AC
induction motor.
■ When positive torque (acceleration) is demanded,
! If prior actual motor speed is less than rated motor speed, then the
maximum available torque is the rated maximum available torque;
! Otherwise, the maximum available torque is computed as (rated
maximum available torque ŒN m') $ (rated motor speed ŒRPM') /
(prior actual motor speed ŒRPM').
■ When negative torque (deceleration) is demanded, torque demand is
split between friction brakes (assumed infinitely powerful) and motor.
■ Energy recovered from the motor replaces energy depleted from the
battery (less inefficiency losses) in a “regeneration” event.
■ The maximum motor torque available for regeneration (in an unsigned
sense) is calculated as the minimum of the maximum available torque
for acceleration and a “regen fraction” times the rated maximum
available torque.
■ The limited torque at the motor is the lesser of the demanded motor
torque and the maximum available torque (in an unsigned sense).
■ Now that the motor torque limits have been established, we can
compute the actual acceleration force that is available, the actual
acceleration, and the actual velocity.
■ We can now compute the actual acceleration:
actual acceleration force ŒN' D limited torque at motor ŒN m' $
N Œunitless'=wheel radius Œm' " aerodynamic force ŒN' "
rolling force ŒN' " grade force ŒN' " brake drag [N]
actual acceleration Œm s"2' D
actual acceleration force ŒN'=equivalent mass Œkg':
■ The actual acceleration as just calculated may cause the motor to
spin at a higher angular velocity than it is rated for.
■ Therefore, we cannot compute actual speed as simply as follows:
actual speed Œm s"1' D prior actual speed Œm s"1' C
actual acceleration Œm s"2' $ 1 s.
■ Instead, we must compute a motor RPM first, then limit that RPM,
and then compute the actual vehicle speed.
test speed Œm s"1' D prior actual speed Œm s"1'C
actual acceleration Œm s"2' $ 1 s
motor speed ŒRPM' D test speed Œm s"1' $ N Œunitless'$
60 Œs min"1'=.2) $ wheel radius Œm'/.
■ Motor speed is limited by the maximum rated motor speed to make a

limited motor speed [RPM].
■ Then, actual vehicle speed is computed as:
actual speed Œm s"1' D limited motor speed ŒRPM' $ 2) $
wheel radius Œm'=.60 Œs min"1' $ N Œunitless'/.
■ The full circuit from desired to actual speed has now been described.
Desired Desired Desired Desired Battery

speed acceleration force torque SOC
Actual Actual Actual Limited Motor Battery

speed acceleration force torque power power
2.5: Vehicle range calculations, example
■ The equations developed so far show whether the vehicle is able to

develop the accelerations required to follow a specific drive profile.
■ They assume that sufficient battery power is available to supply the
motor demand at every time step.
■ To determine vehicle range based on battery capacity, the battery
must also be simulated—when a minimum battery SOC or voltage is
reached, the distance driven to that point is the vehicle range.
■ First, instantaneous power required by the motor is computed.
motor power ŒkW' D 2) Œrad revolution"1' $

# $
motor speed ŒRPM' C previous motor speed [RPM]
$
2
limited torque at motor ŒN m'=.60 Œs min"1' $ 1000 ŒW kW"1 '/.
■ If motor power is positive, then battery power is calculated as:
battery power ŒkW' D overhead power ŒkW' C
motor power ŒkW'=drivetrain efficiency Œunitless',
where overhead power is the constant power drain from other vehicle
systems, such as air conditioners, “infotainment” systems etc.
■ If motor power is negative (regen), battery power is calculated as:
battery power ŒkW' D overhead power ŒkW' C
motor power ŒkW' $ drivetrain efficiency Œunitless'.
■ Assuming for now a constant battery voltage (a poor assumption),
battery current ŒA' D battery power ŒkW' $ 1000 ŒW kW"1 '=
battery nominal voltage ŒV'.
■ Battery state of charge is updated as:
battery SOC Œ%' D prior battery SOC Œ%' " battery current ŒA' $ 1 Œs'=
.3600 Œs hr"1' $ battery capacity ŒA hr'/ $ 100 Œ%'.
■ Driving range is extrapolated from the drive cycle calculations
range Œmiles' D total distance of simulated drive cycle Œmiles' $
.max. rated battery SOC Œ%' " min. rated battery SOC Œ%'/=
.SOC at beginning Œ%' " SOC at end of drive cycle Œ%'/.
Sample code
■ Some sample EV simulation code is provided in the appendix.

■ There are two MATLAB scripts:
! setupSimVehicle.m is an example of how to set up the

parameter values that describe the vehicle and the drive cycle;
! simVehicle.m is the code that executes the equations we’ve just
described to accomplish the simulation.
■ setupSimVehicle.m defines the parameters of the battery cell,
module, and pack; the motor, the wheels, and the drivetrain.
■ The parameter values are stored in structures, combined to make a
vehicle description, and are later used to simulate the vehicle.
■ The values in the example code are a rough description of a Chevy
Volt operating in pure-electric mode, based on public information (and
speculation) prior to vehicle release.
! They’re probably close, but not exact or verified for this vehicle.
■ simVehicle.m simulates a drive profile and returns a structure

called results, which has all kinds of information in it.
EV simulation results
■ Some example results from the EV simulator using “Chevy Volt”
parameters and US06 drive profile:
US06 Battery Power Profile US06 Battery Current Profile
150 400
300
100
Battery power (kW)
Battery current (A)
200
50
100
0
0
−50 −100
−100 −200
0 2 4 6 8 10 0 2 4 6 8 10
US06 Motor Demanded Power
US06 Motor Torque versus RPM
300
80
200
60
Torque (N m)
Frequency
100
40 0
−100
20
−200
0 −300
−100 −50 0 50 100 0 2000 4000 6000 8000 10000 12000
Demanded Motor Power (kW) Speed (RPM)
■ Results can be used in sizing of motor, battery, electrical systems. . .
2.6: Simulating constant power and voltage
■ In the vehicle simulator, we made the simplifying assumption that

battery-pack voltage was constant when converting battery power
demand into battery current demand.
■ We know very well by now that this assumption is crude, at best.
■ But, until now, we have considered only battery cell models having
input equal to current.
■ How do we simulate battery cell models with input equal to desired
power or desired terminal voltage?
Constant power simulation
■ Consider the ESC cell model,
xk D Ak"1xk"1 C Bk"1ik"1
vk D OCV.xk / C hysteresis.xk / " diffusion.xk / "R0ik .

„ ƒ‚ …
not a function of instantaneous current
■ Note that xk does not depend on ik —it depends on ik"1, ik"2; etc.
■ So, cell voltage comprises the “fixed” part, which does not depend on
the present cell current, and the “variable” part, "R0ik , which does
depend on present cell current.
■ Defining the fixed part to be vf;k , we have vk D vf;k " R0 ik .
■ Power equals voltage times current
pk D vk ik D .vf;k " R0ik /ik
R0ik2 " vf;k ik C pk D 0.
■ This quadratic equation can be solved every time sample to
determine cell current to meet the power demand
q
2
vf;k ˙ vf;k " 4R0pk
ik D .
2R0
■ Sign of radical must be negative for positive overall cell voltage, so
q
2
vf;k " vf;k " 4R0pk
ik D .
2R0
Constant voltage simulation
■ Constant-voltage simulation is easier. Determine ik such that
vk D vf;k " R0ik

vf;k " vk
ik D .
R0
Example
■ Two common types of battery-cell charging profiles are:
! CC/CV: Constant current until a voltage limit is reached, then

constant voltage at that limit until current is negligible.
! CP/CV: Constant power until a voltage limit is reached, then
constant voltage at that limit until current is negligible.
■ CC/CV is often used in laboratory tests of cells, but CP/CV is more
commonly used in xEV chargers.
■ These are both straightforward to simulate.
■ Consider charging a battery cell from 50 % SOC to max voltage using
either a CC/CV or CP/CV profile:
State of charge versus time Terminal voltage versus time

100
CC/CV 4.15 CC/CV
CP/CV CP/CV
90
4.1
Voltage (V)
SOC (%)
80
4.05
70
4
60
50 3.95
0 500 1000 1500 2000 2500 3000 0 500 1000 1500 2000 2500 3000
Time (s) Time (s)
Cell current versus time Cell power versus time
0 0
CC/CV CC/CV
CP/CV CP/CV
−2
−10
Current (A)
Power (W)
−4
−20
−6
−30
−8
−10 −40
0 500 1000 1500 2000 2500 3000 0 500 1000 1500 2000 2500 3000
Time (s) Time (s)
■ Code to perform this simulation:

% --------------------------------------------------------------------
% simCharge: Simulate CC/CV and CP/CV charging of a battery cell
% --------------------------------------------------------------------
clear all; close all; clc;
load E1model; % creates var. "model" with E1 cell parameter values
% --------------------------------------------------------------------
% Get ESC model parameters
% --------------------------------------------------------------------
maxtime = 3001; T = 25; % Simulation run time, temperature
q = getParamESC('QParam',T,model);
rc = exp(-1./abs(getParamESC('RCParam',T,model)));
r = (getParamESC('RParam',T,model));
m = getParamESC('MParam',T,model);
g = getParamESC('GParam',T,model);
r0 = getParamESC('R0Param',T,model);
maxV = 4.15; % maximum cell voltage of 4.15 V
% --------------------------------------------------------------------
% First, simulate CC/CV
% --------------------------------------------------------------------
storez = zeros([maxtime 1]); % create storage for SOC
storev = zeros([maxtime 1]); % create storage for voltage
storei = zeros([maxtime 1]); % create storage for current
storep = zeros([maxtime 1]); % create storage for power
z = 0.5; irc = 0; h = -1; % initialize to 50% SOC, resting
CC = 9; % constant current of 9 A in CC/CV charge
for k = 1:maxtime,
v = OCVfromSOCtemp(z,T,model) + m*h - r*irc; % fixed voltage
ik = (v - maxV)/r0; % compute test ik to achieve maxV

ik = max(-CC,ik); % but limit current to no more than CC in mag.
z = z - (1/3600)*ik/q; % Update cell SOC

irc = rc*irc + (1-rc)*ik; % Update resistor currents
fac = exp(-abs(g.*ik)./(3600*q));
h = fac.*h + (1-fac).*sign(ik); % Update hysteresis voltages
storez(k) = z; % Store SOC for later plotting
storev(k) = v - ik*r0;
storei(k) = ik; % store current for later plotting
storep(k) = ik*storev(k);
end % for k
time = 0:maxtime - 1;
figure(1); clf; plot(time,100*storez); hold on
figure(2); clf; plot(time,storev); hold on
figure(3); clf; plot(time,storei); hold on
figure(4); clf; plot(time,storep); hold on
% --------------------------------------------------------------------
% Now, simulate CP/CV
% --------------------------------------------------------------------
z = 0.5; irc = 0; h = -1; % initialize to 50% SOC, resting
CP = 35; % constant power limit of 35 W in CP/CV charge
for k = 1:maxtime,
v = OCVfromSOCtemp(z,T,model) + m*h - r*irc; % fixed voltage
% try CP first
ik = (v - sqrt(v^2 - 4*r0*(-CP)))/(2*r0);
if v - ik*r0 > maxV, % too much!
ik = (v - maxV)/r0; % do CV instead
end
z = z - (1/3600)*ik/q; % Update cell SOC

irc = rc*irc + (1-rc)*ik; % Update resistor currents
fac = exp(-abs(g.*ik)./(3600*q));
storez(k) = z; % Store SOC for later plotting
storev(k) = v - ik*r0;
storei(k) = ik; % store current for later plotting
storep(k) = ik*storev(k);
end % for k
green = [0 0.5 0];

figure(1); plot(time,100*storez,'--','color',green); grid on
title('State of charge versus time'); ylim([49 101]);
xlabel('Time (s)'); ylabel('SOC (%)');
legend('CC/CV','CP/CV','location','northwest');
figure(2); plot(time,storev,'--','color',green); grid on

title('Terminal voltage versus time'); ylim([3.94 4.16]);
xlabel('Time (s)'); ylabel('Voltage (V)');
figure(3); plot(time,storei,'--','color',green); grid on

title('Cell current versus time'); ylim([-10 0.3]);
xlabel('Time (s)'); ylabel('Current (A)');
figure(4); plot(time,storep,'--','color',green); grid on

title('Cell power versus time'); ylim([-40 1]);
xlabel('Time (s)'); ylabel('Power (W)');
2.7: Simulating battery packs
■ We have now reviewed two models of battery cell dynamics.

■ To simulate cell behavior, the model equations are evaluated and the
model state equations are updated once per sample interval.
■ But, how to simulate battery packs?
Series-connected cells
■ Cells connected in series each experience the same current.

■ If all cells have the same initial state and identical parameters, then all
cells have exactly the same state and voltage for all time, so we need
to simulate only one cell (the others will be identical).
■ This is not generally true, however, so we can simulate all cells’
dynamics by keeping state and model information for every cell,
updating once per sample interval.
■ Can also include inter-cell “interconnect” resistance term when
computing pack voltage
Ns
!
X
vpack.t/ D vcell;k .t/ " Ns Rinterconnect i.t/.
kD1
Parallel-connected cells and modules
■ Series-connected packs are common for low-energy, high-power

applications, such as HEV.
■ High-energy applications usually have 96 Cell Groups (PCMs) in Series
cells and even entire sub-packs that are
3 Parallel Cells
Cell Cell Cell
connected in parallel.
Cell Cell Cell
Cell Cell Cell

PCM
■ One extreme is PCM; the other is SCM. 96 Cells in Series
(SCMs) in Parallel
Again, if cells differ, we will need to
3 Cell Groups
■ Cell Cell Cell SCM
Cell Cell Cell
simulate all cells individually, but how? Cell Cell Cell
■ Consider first PCM, recalling that cell voltage

comprises a “fixed” part that does not depend
on the present cell current, and a “variable”
part, "R0ik that does depend on present cell
current.
■ We can model cells in parallel as drawn,
where the voltage source in each branch is
the fixed part, and the resistor current is the
variable part.
■ By KVL, all terminal voltages must be equal; by KCL, the sum of
branch currents must equal the total battery pack current.
■ Define current through branch j of the PCM at time k as ij;k ; the
“fixed” voltage as vj;k , the PCM overall voltage as vk , and the
resistance of the j th branch as R0;j . Then,
vj;k " vk
ij;k D .
R0;j
■ We arrive at the total battery-pack current by summing:
v1;k " vk v2;k " vk vNp ;k " vk
ik D C C ###C .
R0;1 R0;2 R0;Np
■ By re-arranging, we find the PCM voltage
PNp vj;k
j D1 R0;j " ik
vk D PNp .
1
j D1 R0;j
■ All terms in this equation are known, so we can find vk and then from
it we can find all the ij;k .
■ Once we have the independent branch currents ij;k , we can update
the cell models associated with each cell.
■ When simulating SCM, the approach is very similar to simulating
PCM.
■ Each cell in a SCM has its own “fixed” and
“variable” parts.
■ All “fixed” parts sum together to get an
equivalent voltage source; all “variable” parts
sum together to get an equivalent resistance.
■ Each SCM collapses to something that looks
like a single high-voltage cell.
■ Then, the total lumped voltage of an SCM is v
j;k and the total lumped
resistance is R0;j .
■ The bus voltage is
PNp vj;k
j D1 R0;j " ik
vk D PNp .
1
j D1 R0;j
■ The SCM currents are then found as ij;k D .vj;k " vk /=R0;j .
■ With the currents through all cells now known, we can update all cell
models.
Example: Simulation of PCM
■ Here we look at an example simulation with Ns D 2 and Np D 3.
■ Cell SOCs are randomly initialized between 30 % and 70 %.
■ Cell R0 values are randomly initialized between 5 m* and 25 m*.
■ Cell capacities are randomly initialized between 4:5 Ah and 5:5 Ah.
■ The pack is repeatedly discharged until lowest cell hits 5 % and then
charged until highest cell hits 95 %. After 45 min, the pack rests.
■ Individual cell SOCs and PCM-average SOCs are shown below:
Cells in PCM 1 Cells in PCM 2
100 100
80 80
SOC (%)
SOC (%)
60 60
40 40
20 20
0 0
0 10 20 30 40 50 60 0 10 20 30 40 50 60
Cells in PCM 3 Average SOC for each PCM
100 80
PCM 1
PCM 2
80 PCM 3
60
SOC (%)
SOC (%)
60
40
40
20
20
0 0
0 10 20 30 40 50 60 0 10 20 30 40 50 60
■ The individual cell currents and the dispersion between PCM-average

SOCs are plotted below:
Cells in PCM 1 Cells in PCM 2

100 100
50 50
Current (A)
Current (A)
0 0
−50 −50
−100 −100
0 10 20 30 40 50 60 0 10 20 30 40 50 60
Cells in PCM 3 Max.-avg. SOC minus min.-avg. SOC
100 14
Difference in SOC (%)

50 13
Current (A)
0 12
−50 11
−100 10
0 10 20 30 40 50 60 0 10 20 30 40 50 60
■ The code to reproduce this example is in an appendix to this chapter.

It’s pretty easy to modify and use for other configurations as well.
Where from here?

■ We have now reviewed two types of models: our focus in this course
is on applying the empirical model for battery management (we are
actively researching physics-based models for same applications).
■ We have seen how to use the model to predict and simulate cell
performance.
■ The next step is to use these models in a model-based-estimation
scheme to estimate the internal state of the cell.
Appendix: setupSimVehicle.m
% setup simulation of vehicle - pass on to simVehicle.m
function results = setupSimVehicle
global cell module pack motor drivetrain vehicle cycle results
files = {'nycc.txt','udds.txt','us06col.txt','hwycol.txt'};
% Setup the Chevy Volt

% set up cell: capacity [Ah], weight [g], (vmax, vnom, vmin) [V]
cell = setupCell(15,450,4.2,3.8,3.0);
% set up module: number of cells in parallel, number of cells in

% series, overhead of module by fraction of total cells' weight
module = setupModule(3,8,0.08,cell);
% set up pack: number of modules in series, overhead of pack by

% fraction of total modules' weight, (full SOC, empty SOC) [%],
% efficiency for this module
pack = setupPack(12,0.1,75,25,0.96,module);
% set up motor: max torque "Lmax" [Nm], (RPMrated, RPMmax) [RPM],

% efficiency, inertia [kg/m2]
motor = setupMotor(275,4000,12000,0.95,0.2);
% set up wheel: radius [m], inertia [kg/m2], rollCoef

wheel = setupWheel(0.35,8,0.0111);
% set up drivetrain: inverter efficiency, fractional regen torque

% limit, gear ratio, gear inertia [kg/m2], gear efficiency for this
% pack, motor, and wheel
drivetrain = setupDrivetrain(0.94,0.9,12,0.05,0.97,pack,motor,wheel);
% set up vehicle: # wheels, roadForce [N], Cd, frontal area [m2],

% weight [kg], payload [kg], overhead power [W] for this drivetrain
vehicle = setupVehicle(4,0,0.22,1.84,1425,75,200,drivetrain);
fprintf('\n\nStarting sims...\n');
for theCycle = 1:length(files),
cycle = dlmread(files{theCycle},'\t',2,0);
results = simVehicle(vehicle,cycle,0.3);
range = (vehicle.drivetrain.pack.socFull - ...
vehicle.drivetrain.pack.socEmpty) /...
(vehicle.drivetrain.pack.socFull - ...
results.batterySOC(end)) * ...
results.distance(end);
fprintf('Cycle = %s, range = %6.1f [km]\n',files{theCycle},range);
end
end
function cell = setupCell(capacity,weight,vmax,vnom,vmin)

cell.capacity = capacity; % ampere hours
cell.weight = weight; % grams
cell.vmax = vmax; % volts
cell.vnom = vnom; % volts
cell.vmin = vmin; % volts
cell.energy = vnom * capacity; % Watt-hours
cell.specificEnergy = 1000 * cell.capacity * cell.vnom/ ...
cell.weight; % Wh/kg
end
function module = setupModule(numParallel,numSeries,overhead,cell)

module.numParallel = numParallel;
module.numSeries = numSeries;
module.overhead = overhead;
module.cell = cell;
module.numCells = numParallel * numSeries;
module.capacity = numParallel * cell.capacity;
module.weight = module.numCells * cell.weight * 1/(1 - overhead)/1000; %
kg
module.energy = module.numCells * cell.energy/1000; % kWh
module.specificEnergy = 1000 * module.energy / module.weight; % Wh/kg
end
function pack = setupPack(numSeries,overhead,socFull,socEmpty,...

efficiency,module)
pack.numSeries = numSeries;
pack.overhead = overhead;
pack.module = module;
pack.socFull = socFull;
pack.socEmpty = socEmpty; % unitless
pack.efficiency = efficiency; % unitless, captures I*I*R losses
pack.numCells = module.numCells * numSeries;
pack.weight = module.weight * numSeries * 1/(1 - overhead); % kg
pack.energy = module.energy * numSeries; % kWh
pack.specificEnergy = 1000 * pack.energy / pack.weight; % Wh/kg
pack.vmax = numSeries*module.numSeries*module.cell.vmax;
pack.vnom = numSeries*module.numSeries*module.cell.vnom;
pack.vmin = numSeries*module.numSeries*module.cell.vmin;
end
function motor = setupMotor(Lmax,RPMrated,RPMmax,efficiency,inertia)

motor.Lmax = Lmax; % N-m
motor.RPMrated = RPMrated;
motor.RPMmax = RPMmax;
motor.efficiency = efficiency;
motor.inertia = inertia; %kg-m2
motor.maxPower = 2*pi*Lmax*RPMrated/60000; % kW
end
function wheel = setupWheel(radius,inertia,rollCoef)

wheel.radius = radius; % m
wheel.inertia = inertia; % km-m2
wheel.rollCoef = rollCoef;
end
function drivetrain = setupDrivetrain(inverterEfficiency,regenTorque,...

gearRatio,gearInertia,gearEfficiency,pack,motor,wheel)
drivetrain.inverterEfficiency = inverterEfficiency;
% regen torque is fraction of braking power that is used to charge
% battery; e.g., value of 0.9 means 90% of braking power contributes
% to charging battery; 10% lost to heat in friction brakes
drivetrain.regenTorque = regenTorque;
drivetrain.pack = pack;
drivetrain.motor = motor;
drivetrain.wheel = wheel;
drivetrain.gearRatio = gearRatio;
drivetrain.gearInertia = gearInertia; % kg-m2, measured on motor side
drivetrain.gearEfficiency = gearEfficiency;
drivetrain.efficiency = pack.efficiency * inverterEfficiency * ...
motor.efficiency * gearEfficiency;
end
function vehicle = setupVehicle(wheels,roadForce,Cd,A,weight,payload,

overheadPwr,drivetrain)
vehicle.drivetrain = drivetrain;
vehicle.wheels = wheels; % number of them
vehicle.roadForce = roadForce; % N
vehicle.Cd = Cd; % drag coeff
vehicle.A = A; % frontal area, m2
vehicle.weight = weight; % kg
vehicle.payload = payload; % kg
vehicle.overheadPwr = overheadPwr; % W
vehicle.curbWeight = weight + drivetrain.pack.weight;
vehicle.maxWeight = vehicle.curbWeight + payload;
vehicle.rotWeight = ((drivetrain.motor.inertia + ...
drivetrain.gearInertia) * ...
drivetrain.gearRatio^2 + ...
drivetrain.wheel.inertia*wheels)/...
drivetrain.wheel.radius^2;
vehicle.equivMass = vehicle.maxWeight + vehicle.rotWeight;
vehicle.maxSpeed = 2 * pi * drivetrain.wheel.radius * ...
drivetrain.motor.RPMmax * 60 / ...
(1000 * drivetrain.gearRatio); % km/h
end
Appendix: simVehicle.m
% results = simVehicle(vehicle,cycle,grade)
% - simulate a vehicle defined by "vehicle", perhaps created using
% setupSimVehicle.m
% - cycle is Nx2, where first column is time in seconds and second
% column is desired speed in miles per hour
% - grade is road grade in percent - either a constant grade for all
% time, or a different grade value for every point in time
function results = simVehicle(vehicle,cycle,grade)
rho = 1.225; % air density, kg/m3
results.vehicle = vehicle;
results.cycle = cycle; % time in s, desired speed in miles/hour
results.time = cycle(:,1); % s
if isscalar(grade),
results.grade = repmat(atan(grade/100),size(results.time)); % rad
else
results.grade = atan(grade/100); % rad
end
results.desSpeedKPH = cycle(:,2) * 1.609344; % convert to km/h
results.desSpeed = min(vehicle.maxSpeed,...
results.desSpeedKPH*1000/3600); % m/s
% pre-allocate storage for results

results.desAccel = zeros(size(results.desSpeed)); % m/s2
results.desAccelForce = zeros(size(results.desSpeed)); % N
results.aeroForce = zeros(size(results.desSpeed)); % N
results.rollGradeForce = zeros(size(results.desSpeed)); % N
results.demandTorque = zeros(size(results.desSpeed)); % N-m
results.maxTorque = zeros(size(results.desSpeed)); % N-m
results.limitRegen = zeros(size(results.desSpeed)); % N-m
results.limitTorque = zeros(size(results.desSpeed)); % N-m
results.motorTorque = zeros(size(results.desSpeed)); % N-m
results.demandPower = zeros(size(results.desSpeed)); % kW
results.limitPower = zeros(size(results.desSpeed)); % kW
results.batteryDemand = zeros(size(results.desSpeed)); % kW
results.current = zeros(size(results.desSpeed)); % A
results.batterySOC = zeros(size(results.desSpeed)); % 0..100
results.actualAccelForce = zeros(size(results.desSpeed)); % N
results.actualAccel = zeros(size(results.desSpeed)); % m/s2
results.motorSpeed = zeros(size(results.desSpeed)); % RPM
results.actualSpeed = zeros(size(results.desSpeed)); % m/s
results.actualSpeedKPH = zeros(size(results.desSpeed)); % km/h
results.distance = zeros(size(results.desSpeed)); % km
prevSpeed = 0; prevTime = results.time(1) - 1; prevMotorSpeed = 0;

prevSOC = vehicle.drivetrain.pack.socFull; prevDistance = 0;
for k = 1:length(results.desSpeed),
results.desAccel(k) = (results.desSpeed(k) - prevSpeed)/ ...
(results.time(k) - prevTime);
results.desAccelForce(k) = vehicle.equivMass * results.desAccel(k);
results.aeroForce(k) = 0.5 * rho * vehicle.Cd * vehicle.A * ...
prevSpeed^2;
results.rollGradeForce(k) = vehicle.maxWeight * 9.81 * ...
sin(results.grade(k));
if abs(prevSpeed) > 0,
results.rollGradeForce(k) = results.rollGradeForce(k) + ...
vehicle.drivetrain.wheel.rollCoef * vehicle.maxWeight * 9.81;
end
results.demandTorque(k) = (results.desAccelForce(k) + ...
results.aeroForce(k) + ...
results.rollGradeForce(k) + ...
vehicle.roadForce) * ...
vehicle.drivetrain.wheel.radius / ...
vehicle.drivetrain.gearRatio;
if prevMotorSpeed < vehicle.drivetrain.motor.RPMrated,
results.maxTorque(k) = vehicle.drivetrain.motor.Lmax;
else
results.maxTorque(k) = vehicle.drivetrain.motor.Lmax * ...
vehicle.drivetrain.motor.RPMrated / prevMotorSpeed;
end
results.limitRegen(k) = min(results.maxTorque(k),...
vehicle.drivetrain.regenTorque * ...
vehicle.drivetrain.motor.Lmax);
results.limitTorque(k) = min(results.demandTorque(k),...
results.maxTorque(k));
if results.limitTorque(k) > 0,
results.motorTorque(k) = results.limitTorque(k);
else
results.motorTorque(k) = max(-results.limitRegen(k),...
results.limitTorque(k));
end
results.actualAccelForce(k) = results.limitTorque(k) * ...
vehicle.drivetrain.gearRatio / ...
vehicle.drivetrain.wheel.radius - ...
results.aeroForce(k) - ...
results.rollGradeForce(k) - ...
vehicle.roadForce;
results.actualAccel(k) = results.actualAccelForce(k) / ...
vehicle.equivMass;
results.motorSpeed(k) = min(vehicle.drivetrain.motor.RPMmax,...
vehicle.drivetrain.gearRatio * ...
(prevSpeed + results.actualAccel(k) * ...
(results.time(k) - prevTime)) * 60 / ...
(2*pi*vehicle.drivetrain.wheel.radius));
results.actualSpeed(k) = results.motorSpeed(k) * ...
2*pi*vehicle.drivetrain.wheel.radius / ...
(60 * vehicle.drivetrain.gearRatio);
results.actualSpeedKPH(k) = results.actualSpeed(k) * 3600/1000;
deltadistance = (results.actualSpeed(k) + prevSpeed)/2 *...
(results.time(k) - prevTime)/1000;
results.distance(k) = prevDistance + deltadistance;
if results.limitTorque(k) > 0,
results.demandPower(k) = results.limitTorque(k);
else
results.demandPower(k) = max(results.limitTorque(k),...
-results.limitRegen(k));
end
results.demandPower(k) = results.demandPower(k) * 2*pi * ...
(prevMotorSpeed + results.motorSpeed(k))/2 / 60000;
results.limitPower(k) = max(-vehicle.drivetrain.motor.maxPower,...
min(vehicle.drivetrain.motor.maxPower,...
results.demandPower(k)));
results.batteryDemand(k) = vehicle.overheadPwr/1000;
if results.limitPower(k) > 0,
results.batteryDemand(k) = results.batteryDemand(k) + ...
results.limitPower(k)/vehicle.drivetrain.efficiency;
else
results.batteryDemand(k) = results.batteryDemand(k) + ...
results.limitPower(k)*vehicle.drivetrain.efficiency;
end
results.current(k) = results.batteryDemand(k)*1000/...
vehicle.drivetrain.pack.vnom;
results.batterySOC(k) = prevSOC - results.current(k) * ...
(results.time(k) - prevTime) / ...
(36*vehicle.drivetrain.pack.module.capacity);
prevTime = results.time(k);
prevSpeed = results.actualSpeed(k);
prevMotorSpeed = results.motorSpeed(k);
prevSOC = results.batterySOC(k);
prevDistance = results.distance(k);
end
Appendix: Code to simulate PCM
% ------------------------------------------------------------------------
% simPCM: Simulate parallel-connected-module packs (cells are connected in
% parallel to make modules; these modules are connected in series to make
% packs).
%
% The parameters for each cell may be different (e.g., capacity,
% resistance, etc.)
% ------------------------------------------------------------------------
clear all; close all; clc;

% ------------------------------------------------------------------------
% Initialize some pack configuration parameters...
% ------------------------------------------------------------------------
load E2model; % creates var. "model" with E2 cell parameter values
Ns = 2; % Number of modules connected in series to make a pack
Np = 3; % Number of cells connected in parallel in each module
% ------------------------------------------------------------------------
% Initialize some simulation configuration parameters...
% ------------------------------------------------------------------------
maxtime = 3600; % Simulation run time in simulated seconds
t0 = 2700; % Pack rests after time t0
storez = zeros([maxtime Ns Np]); % create storage for SOC
storei = zeros([maxtime Ns Np]); % create storage for current
% ------------------------------------------------------------------------
% Initialize states for ESC cell model
% ------------------------------------------------------------------------
z = 0.25*ones(Ns,Np);
irc = zeros(Ns,Np);
h = zeros(Ns,Np);
% ------------------------------------------------------------------------
% Default initialization for cells within the pack
% ------------------------------------------------------------------------
kvec = [0; maxtime+1]; % Iteration (time) vector for temp. profile
tvec = [25; 25]; % Default temperature profile
q = getParamESC('QParam',25,model)*ones(Ns,Np);
rc = exp(-1./abs(getParamESC('RCParam',25,model)))'*ones(Ns,Np);
r = (getParamESC('RParam',25,model))';
m = getParamESC('MParam',25,model)*ones(Ns,Np);
g = getParamESC('GParam',25,model)*ones(Ns,Np);
r0 = getParamESC('R0Param',25,model)*ones(Ns,Np);
rt = 0.000125; % 125 microOhm resistance for each tab
% ------------------------------------------------------------------------
% Modified initialization for cell variability
% ------------------------------------------------------------------------
% Set individual random "initial SOC" values
if 1, % set to "if 1," to execute, or "if 0," to skip this code
z=0.30+0.40*rand([Ns Np]); % rand. init. SOC for ea. cell
end
% Set individual random cell-capacity values

q=4.5+rand([Ns Np]); % random capacity for ea. cell
end
% Set individual random cell-resistance relationships

r0 = 0.005+0.020*rand(Ns,Np);
end
r0 = r0 + 2*rt; % add tab resistance to cell resistance
% ------------------------------------------------------------------------
% Add faults to pack: cells faulted open- and short-circuit
% ------------------------------------------------------------------------
% To delete a PCM (open-circuit fault), set a resistance to Inf
%r0(1,1) = Inf; % for example...
% To delete a cell from a PCM (short-circuit fault), set its SOC to NaN
%z(1,2) = NaN; % for example, delete cell 2 in PCM 1
Rsc = 0.0025; % Resistance value to use for cell whose SOC < 0%
% ------------------------------------------------------------------------
% Get ready to simulate... first compute pack capacity in Ah
% ------------------------------------------------------------------------
totalCap = min(sum(q,2)); % pack capacity = minimum module capacity
I = 10*totalCap; % cycle at 10C... not realistic, faster simulation
% ------------------------------------------------------------------------
% Okay... now to simulate pack performance using ESC cell model.
% ------------------------------------------------------------------------
for k = 1:maxtime,
T = interp1(kvec,tvec,k); % cell temperature
v = OCVfromSOCtemp(z,T,model); % get OCV for each cell: Ns * Np matrix
v = v + m.*h - r.*irc; % add in capacitor voltages and hysteresis
r0(isnan(z)) = Rsc; % short-circuit fault has "short-circuit" resistance
V = (sum(v./r0,2) - I)./sum(1./r0,2);
ik = (v-repmat(V,1,Np))./r0;
z = z - (1/3600)*ik./q; % Update each cell SOC
z(z<0) = NaN; % set over-discharged cells to short-circuit fault
irc = rc.*irc + (1-rc).*ik; % Update capacitor voltages
fac = exp(-abs(g.*ik)./(3600*q));
minz = min(z(:)); maxz = max(z(:)); % Check to see if SOC limit hit
if minz < 0.05, I = -abs(I); end % stop discharging
if maxz > 0.95, I = abs(I); end % stop charging
if k>t0, I = 0; end % rest
storez(k,:,:) = z; % Store SOC for later plotting
storei(k,:,:) = ik; % store current for later plotting
end % for k
% ------------------------------------------------------------------------
% In Figure 1, plot the individual SOC vs. time for all cells in all
% series PCMs. There is one subplot for each PCM.
% ------------------------------------------------------------------------
nonocPCMs = ~isinf(sum(r0,2)); % modules that are not open-circuit faulted
figure(1); clf; t = (0:(length(storez(:,:,1))-1))/60;
xplots = round(1.0*ceil(sqrt(Ns))); yplots = ceil(Ns/xplots); means = [];
for k = 1:Ns,
zr=squeeze(100*storez(:,k,:));
subplot(yplots,xplots,k); plot(t,zr); axis([0 ceil(maxtime/60) 0 100]);
title(sprintf('Cells in PCM %d',k));
ylabel('SOC (%)'); xlabel('Time (min)');
zr(isnan(zr))=0; % exclude dead cells (failed short) from mean
if nonocPCMs(k), % exclude from average if open-circuit!
means = [means; mean(zr,2)']; %#ok<AGROW>
end
end
% ------------------------------------------------------------------------
% In Figure 2, plot the average SOC vs. time for all PCMs
% ------------------------------------------------------------------------
figure(2); clf; plot(t,means'); grid on
xlabel('Time (min)'); ylabel('SOC (%)');
title('Average SOC for each PCM');
legendstrings = [];
for k=1:Ns,
if nonocPCMs(k),
legendstrings = [legendstrings; ...
{ sprintf('String %d',k) }]; %#ok<AGROW>
end
end
legend(legendstrings);
% ------------------------------------------------------------------------
% In Figure 3, plot the (maximum average SOC) minus (minimum average SOC)
% ------------------------------------------------------------------------
figure(3); plot(t,(max(means)-min(means))); grid on
xlabel('Time (min)'); ylabel('Difference in SOC (%)');
title('Maximum-average SOC minus minimum-average SOC');
% ------------------------------------------------------------------------
% In Figure 4, plot the individual cell current vs. time for all cells in
% all series PCMs. There is one subplot for each PCM.
% ------------------------------------------------------------------------
figure(4); clf; t = (0:(length(storei(:,:,1))-1))/60;
for k = 1:Ns,
zr=squeeze(storei(:,k,:));
subplot(yplots,xplots,k); plot(t,zr);
axis([0 ceil(maxtime/60) -101 101]);
title(sprintf('Cells in PCM %d',k));
ylabel('Current (A)'); xlabel('Time (min)');
end

N1-Simulating Battery Packs

Uploaded by

Copyright:

Available Formats

N1-Simulating Battery Packs

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

N1-Simulating Battery Packs

Uploaded by

Copyright:

Available Formats

ECE5720: Battery Management and Control 2–1

Simulating Battery Packs

2.1: Modeling approach #1: Equivalent-circuit models

■ One function of a battery management system is to compute

! State of charge, state of health, state of life,

! Available power, available energy / range.

■ The best methods require high-fidelity but computationally simple

Equivalent-circuit models (ECMs):

Physics-based models (PBMs):

Modeling approach #1: Empirical

■ The (continuous-time) “enhanced R1

voltage via a single R–C pair.

■ The ESC model comprises the following terms:

! State-of-charge: ´kC1 D ´k " !k ik "t=Q.

OCV Test OCV

Dynamic Test ESC Cell

! Simulating the model:

■ Within the cell, the following state variables are of interest:

■ These five electrochemical variables can be found by solving the five

! Diffusion of lithium in electrolyte:

! Reaction rate (where ! D .$s " $e / " Uocp " j FRfilm ):

! Also, experience shows that PDE simulators can be very

1. We assumed linear behavior: We linearized nonlinear equations

allowing us to create transfer functions from the linearized equations.

! Finding the model:

PDE Linearize Transfer Legend

! Simulating the model:

Input Legend: Data Computational process

■ A key feature of the DRA-produced ROM is that nonlinear corrections

■ When designing battery packs, it is important to be able to simulate

! Helps to ensure the pack will be able to meet all performance

1. An accurate description of the vehicle itself;

! The Urban Dynamometer Driving Schedule (UDDS)

! The Highway Fuel Efficiency Test (HW-FET)

! The New York City Cycle (NYCC), and

! The US06 drive cycle (recorded by NREL, near Golden, CO).

UDDS Drive Profile HW-FET Drive Profile

NYCC Drive Profile US06 Drive Profile

Desired Desired Desired Desired Battery

Actual Actual Actual Limited Motor Battery

■ In more detail: We calculate the desired vehicle acceleration as:2

desired acceleration Œm s"2' D

.desired speed Œm s"1' " actual speed Œm s"1'/=.1 Œs'/.

■ We compute desired acceleration force that the motor must produce

desired acceleration force ŒN' D

equivalent mass Œkg' $ desired acceleration Œm s"2'.

equivalent mass Œkg' D

maximum vehicle mass Œkg' C rotating equivalent mass Œkg'

rotating equivalent mass Œkg' D

..motor inertia Œkg m2' C gearbox inertia Œkg m2'/ $ N 2

C number of wheels $ wheel inertia Œkg m2'/=.wheel radius Œm'/2,

where N is gearbox ratio [unitless] = (motor RPM)/(wheel RPM), and

rolling force ŒN' D .rolling friction coefficient Cr Œunitless'/ $

.max. vehicle mass Œkg'/ $ .acceleration of gravity Œ9:81 m s"2'/

grade force ŒN' D .maximum vehicle mass Œkg'/ $

.acceleration of gravity Œ9:81 m s"2'/ $ sin.grade angle Œrad'/

brake drag ŒN' D constant road force input by user,

aerodynamic force ŒN' C rolling force [N] C grade force ŒN'C

brake drag ŒN'/ $ wheel radius Œm'=N Œunitless'.