Main Content

Build Model of Battery Pack for Grid Application

This example shows how to use Simscape™ Battery™ to create and build a Simscape™ system model of a battery pack from prismatic cells for grid applications. The battery pack is a 150 kWh prismatic battery for grid-level applications. To create the system model of a battery pack, you must first create the Cell, ParallelAssembly, Module, and ModuleAssembly objects that comprise the battery pack, and then use the buildBattery function. The buildBattery function allows you to automatically generate Simscape models for these Simscape Battery objects:

This function creates a library in your working folder that contains a system model block of a battery pack that you can use as reference in your simulations. The run-time parameters for these models, such as the battery cell impedance or the battery open-circuit voltage, are defined after the model creation and are therefore not covered by the Battery Pack Builder classes. To define the run-time parameters, you can either specify them in the block mask of the generated Simscape models or use the MaskParameters argument of the buildBattery function.

To use the functions and objects in Simscape Battery, first import the required Simscape Battery package:

import simscape.battery.builder.*

Create Battery Pack Object in MATLAB

Battery-based energy storage is a good option for integrating intermittent renewable energy sources into the grid. To create a battery pack, you must first design and create the foundational elements of the battery pack.

This figure shows the overall process to create a battery pack object in a bottom-up approach:

A battery pack comprises multiple module assemblies. These module assemblies, in turn, comprise a number of battery modules connected electrically in series or in parallel. The battery modules are made of multiple parallel assemblies which, in turn, comprise a number of battery cells connected electrically in parallel under a specific topological configuration or geometrical arrangement.

Create Cell Object

To create the battery Module object, first create a Cell object of prismatic format.

prismaticGeometry = PrismaticGeometry(Height = simscape.Value(0.2,"m"),...
    Length = simscape.Value(0.35,"m"), Thickness =  simscape.Value(0.07,"m"));

The PrismaticGeometry object allows you to define the pouch geometrical arrangement of the battery cell. You can specify the height, length, and thickness of the cell by setting the Height, Length, and Thickness properties of the PrismaticGeometry object. For more information on the possible geometrical arrangements of a battery cell, see the CylindricalGeometry and PouchGeometry documentation pages.

Now use this PrismaticGeometry object to create a prismatic battery cell.

batteryCell = Cell(Geometry = prismaticGeometry)
batteryCell = 
  Cell with properties:

            Geometry: [1x1 simscape.battery.builder.PrismaticGeometry]
    CellModelOptions: [1x1 simscape.battery.builder.CellModelBlock]
                Mass: [1x1 simscape.Value]

Show all properties

For more information, see the Cell documentation page.

The Cell object allows you to simulate the thermal effects of the battery cell by using a simple 1-D model. To simulate the thermal effects of the battery cell, in the BlockParameters property of the CellModelOptions property of the Cell object, set the thermal_port parameter to "model".

batteryCell.CellModelOptions.BlockParameters.thermal_port = "model";

Create ParallelAssembly Object

A battery parallel assembly comprise multiple battery cells connected electrically in parallel under a specific topological configuration or geometrical arrangement. In this example, you create a parallel assembly of one prismatic cell.

To create the ParallelAssembly object, use the Cell object you created before and specify the NumParallelCells property according to your design.

batteryParallelAssembly = ParallelAssembly(Cell = batteryCell,...
    NumParallelCells = 1)
batteryParallelAssembly = 
  ParallelAssembly with properties:

    NumParallelCells: 1
                Cell: [1x1 simscape.battery.builder.Cell]
            Topology: "SingleStack"
                Rows: 1
     ModelResolution: "Lumped"

Show all properties

For more information, see the ParallelAssembly documentation page.

Create Module Object

A battery module comprises multiple parallel assemblies connected in series. In this example, you create a battery module of 22 parallel assemblies with an intergap between each assembly of 0.005 meters.

To create the Module object, use the ParallelAssembly object you created in the previous step and specify the NumSeriesAssemblies and InterParallelAssemblyGap properties.

batteryModule = Module(ParallelAssembly = batteryParallelAssembly,...
    NumSeriesAssemblies = 22, ...
    InterParallelAssemblyGap = simscape.Value(0.005,"m"), ...
    ModelResolution = "Lumped")
batteryModule = 
  Module with properties:

    NumSeriesAssemblies: 22
       ParallelAssembly: [1x1 simscape.battery.builder.ParallelAssembly]
        ModelResolution: "Lumped"
         SeriesGrouping: 22
       ParallelGrouping: 1

Show all properties

For more information, see the Module documentation page.

Create ModuleAssembly Object

A battery module assembly comprises multiple battery modules connected in series or in parallel. In this example, you create a battery module assembly of ten identical modules stacked on ten different levels, with an intergap between each module equal to 0.05 meters. By default, the ModuleAssembly object electrically connects the modules in series.

To create the ModuleAssembly object, use the Module object you created in the previous step and specify the InterModuleGap and NumLevels properties.

batteryModuleAssembly = ModuleAssembly(Module = repmat(batteryModule,1,10),...
    InterModuleGap = simscape.Value(0.05,"m"), ...
    NumLevels = 10)
batteryModuleAssembly = 
  ModuleAssembly with properties:

    Module: [1x10 simscape.battery.builder.Module]

Show all properties

For more information, see the ModuleAssembly documentation page.

Create Pack Object

You now have all the foundational elements to create your battery pack. A battery pack comprises multiple module assemblies connected in series or in parallel. In this example, you create a battery pack of one module assembly.

To create the Pack object, use the ModuleAssembly object you created in the previous step.

batteryPack = Pack(ModuleAssembly = batteryModuleAssembly)
batteryPack = 
  Pack with properties:

    ModuleAssembly: [1x1 simscape.battery.builder.ModuleAssembly]

Show all properties

For more information, see the Pack documentation page.

Visualize Battery Pack and Check Model Resolution

To visualize the battery pack before you build the system model and to view its model resolution, use the BatteryChart object. Create the figure where you want to visualize your battery pack.

f = uifigure(Color="w");

Then use the BatteryChart object to visualize the battery pack. To view the model resolution of the module, set the SimulationStrategyVisible property of the BatteryChart object to "On".

batteryPackChart = BatteryChart(Parent = f, Battery = batteryPack, ...
    SimulationStrategyVisible = "on");

{"String":"Figure contains an object of type simscape.battery.builder.batterychart.","Tex":[],"LaTex":[]}

To add default axis labels to the battery plot, use the setDefaultLabels method of the BatteryChart object.

For more information, see the BatteryChart documentation page.

Build Simscape Model for the Battery Pack Object

After you have created your battery objects, you need to convert them into Simscape models to be able to use them in block diagrams. You can then use these models as reference for your system integration and requirement evaluation, cooling system design, control strategy development, hardware-in-the-loop, and much more.

To create a library that contains the Simscape Battery model of the Pack object you created in this example, use the buildBattery function.

buildBattery(batteryPack,"LibraryName","packGridExample")
Generating Simulink library 'packGridExample_lib' in the current directory '/tmp/Bdoc22b_2134332_1821819/tpacc0024e/simscapebattery-ex24641848' ...

This function creates the packGridExample_lib and packGridExample SLX library files in your working directory. The packGridExample_lib library contains the Modules and ParallelAssemblies sublibraries.

To access the Simscape models of your Module and ParallelAssembly objects, open the packGridExample_lib. SLX file, double-click the sublibrary, and drag the Simscape blocks in your model.

The packGridExample library contains the Simscape models of your ModuleAssembly and Pack objects.

The Simscape models of your ModuleAssembly and Pack objects are subsystems. You can look inside these subsystems by opening the packLibrary SLX file and double-click the subsystem.

For more information, see the buildBattery documentation page.

Copyright 2022 The MathWorks, Inc.