Integrated PV-Battery Smart Energy Management

🎯 Lab Objectives

• Integrate PV generation, electrical load, battery storage, and the utility grid.
• Formulate the power-balance equation.
• Model charging and discharging of the battery.
• Calculate grid import and export.
• Use electricity prices in an energy-management objective.
• Optimize the battery schedule.
• Evaluate PV self-consumption and grid-energy reduction.

1. Smart Energy System

The energy-management system contains four main components:

2. Power-Balance Equation

Using the battery sign convention:

The grid power is:

3. Grid Import and Export

A negative grid-power value means excess local energy is exported.

4. Example Profiles

5. Battery Parameters

6. Energy-Management Objective

The simplest objective is to minimize electricity-purchase cost:

where:

7. Import Power

Only positive grid power corresponds to purchased electricity:

8. Optional Export Revenue

If exported electricity is compensated:

Then:

and the net objective becomes:

9. Battery Energy Model

Charging:

Discharging:

10. SOC Constraints

For this case:

11. Decision Vector

For six hours:

Each candidate solution is therefore a complete battery schedule.

12. Baseline Without Battery

Before optimization:

therefore:

This provides a reference cost for comparison.

13. MATLAB Input Data

loadMW = [5.0 4.8 4.5 5.0 6.5 7.0];

pvMW = [0.0 0.5 2.0 4.5 3.0 0.5];

buyPrice = [45 40 35 45 85 95];

N = length(loadMW);

dt = 1;

14. Baseline Calculation

PgridBase = loadMW - pvMW;

PimportBase = max(PgridBase,0);

baseCost = sum(buyPrice .* PimportBase * dt);

15. SOC Penalty

If the battery violates its limits:

A large penalty coefficient ensures infeasible schedules are unattractive.

16. Final SOC Condition

We also require:

This prevents the optimizer from artificially lowering cost simply by emptying the battery at the end.

17. Complete MATLAB Program

clear; clc; close all;

% ------------------------------------------------
% Integrated PV-Battery Smart Energy Management
% Educational evolutionary optimization example
% ------------------------------------------------

loadMW = [5.0 4.8 4.5 5.0 6.5 7.0];

pvMW = [0.0 0.5 2.0 4.5 3.0 0.5];

buyPrice = [45 40 35 45 85 95];

N = length(loadMW);

dt = 1;

% ------------------------------------------------
% Battery parameters
% ------------------------------------------------

Emax = 5;

SOC0 = 0.50;

SOCmin = 0.20;
SOCmax = 0.90;

PchMax = 2;
PdisMax = 2;

etaCh = 0.95;
etaDis = 0.95;

% ------------------------------------------------
% Optimization parameters
% ------------------------------------------------

popSize = 70;
maxGen = 180;

Pc = 0.8;
Pm = 0.12;

sigmaMut = 0.4;

lambdaSOC = 1e5;
lambdaFinal = 1e5;

% ------------------------------------------------
% Baseline without battery
% ------------------------------------------------

PgridBase = loadMW - pvMW;

PimportBase = max(PgridBase,0);

baseCost = ...
    sum(buyPrice .* PimportBase * dt);

% ------------------------------------------------
% Initial population
% ------------------------------------------------

population = ...
    -PchMax + ...
    rand(popSize,N)*(PchMax+PdisMax);

bestHist = zeros(maxGen,1);

% ------------------------------------------------
% Evolutionary optimization
% ------------------------------------------------

for gen = 1:maxGen

    Jvec = zeros(popSize,1);

    for i = 1:popSize

        schedule = population(i,:);

        E = SOC0*Emax;

        energyCost = 0;
        penaltySOC = 0;

        for k = 1:N

            PB = schedule(k);

            % ------------------------------------
            % Update battery energy
            % ------------------------------------

            if PB < 0

                E = E + ...
                    etaCh*(-PB)*dt;

            else

                E = E - ...
                    PB*dt/etaDis;

            end

            SOC = E/Emax;

            % ------------------------------------
            % SOC constraint penalty
            % ------------------------------------

            if SOC < SOCmin

                penaltySOC = penaltySOC + ...
                    lambdaSOC*(SOCmin-SOC)^2;

            elseif SOC > SOCmax

                penaltySOC = penaltySOC + ...
                    lambdaSOC*(SOC-SOCmax)^2;

            end

            % ------------------------------------
            % Grid power balance
            % ------------------------------------

            Pgrid = ...
                loadMW(k) - ...
                pvMW(k) - ...
                PB;

            Pimport = max(Pgrid,0);

            % ------------------------------------
            % Energy purchase cost
            % ------------------------------------

            energyCost = ...
                energyCost + ...
                buyPrice(k)*Pimport*dt;

        end

        % ----------------------------------------
        % Final SOC penalty
        % ----------------------------------------

        SOCfinal = E/Emax;

        penaltyFinal = ...
            lambdaFinal*(SOCfinal-SOC0)^2;

        % ----------------------------------------
        % Total objective
        % ----------------------------------------

        Jvec(i) = ...
            energyCost + ...
            penaltySOC + ...
            penaltyFinal;

    end

    % ------------------------------------------------
    % Elitism
    % ------------------------------------------------

    [bestJ,bestIdx] = min(Jvec);

    elite = population(bestIdx,:);

    bestHist(gen) = bestJ;

    % ------------------------------------------------
    % New population
    % ------------------------------------------------

    newPopulation = zeros(size(population));

    newPopulation(1,:) = elite;

    row = 2;

    while row <= popSize

        % ----------------------------------------
        % Tournament selection: Parent 1
        % ----------------------------------------

        a = randi(popSize);
        b = randi(popSize);

        if Jvec(a) < Jvec(b)
            parent1 = population(a,:);
        else
            parent1 = population(b,:);
        end

        % ----------------------------------------
        % Tournament selection: Parent 2
        % ----------------------------------------

        a = randi(popSize);
        b = randi(popSize);

        if Jvec(a) < Jvec(b)
            parent2 = population(a,:);
        else
            parent2 = population(b,:);
        end

        % ----------------------------------------
        % Crossover
        % ----------------------------------------

        if rand < Pc

            alpha = rand;

            child1 = ...
                alpha*parent1 + ...
                (1-alpha)*parent2;

            child2 = ...
                (1-alpha)*parent1 + ...
                alpha*parent2;

        else

            child1 = parent1;
            child2 = parent2;

        end

        % ----------------------------------------
        % Mutation
        % ----------------------------------------

        for k = 1:N

            if rand < Pm

                child1(k) = ...
                    child1(k) + ...
                    sigmaMut*randn;

            end

            if rand < Pm

                child2(k) = ...
                    child2(k) + ...
                    sigmaMut*randn;

            end

        end

        % ----------------------------------------
        % Battery power limits
        % ----------------------------------------

        child1 = ...
            min(max(child1,-PchMax),PdisMax);

        child2 = ...
            min(max(child2,-PchMax),PdisMax);

        % ----------------------------------------
        % Store children
        % ----------------------------------------

        newPopulation(row,:) = child1;

        if row+1 <= popSize
            newPopulation(row+1,:) = child2;
        end

        row = row + 2;

    end

    population = newPopulation;

end

% ------------------------------------------------
% Final population evaluation
% ------------------------------------------------

Jvec = zeros(popSize,1);

for i = 1:popSize

    schedule = population(i,:);

    E = SOC0*Emax;

    energyCost = 0;
    penaltySOC = 0;

    for k = 1:N

        PB = schedule(k);

        if PB < 0

            E = E + ...
                etaCh*(-PB)*dt;

        else

            E = E - ...
                PB*dt/etaDis;

        end

        SOC = E/Emax;

        if SOC < SOCmin

            penaltySOC = penaltySOC + ...
                lambdaSOC*(SOCmin-SOC)^2;

        elseif SOC > SOCmax

            penaltySOC = penaltySOC + ...
                lambdaSOC*(SOC-SOCmax)^2;

        end

        Pgrid = ...
            loadMW(k) - ...
            pvMW(k) - ...
            PB;

        Pimport = max(Pgrid,0);

        energyCost = ...
            energyCost + ...
            buyPrice(k)*Pimport*dt;

    end

    SOCfinal = E/Emax;

    penaltyFinal = ...
        lambdaFinal*(SOCfinal-SOC0)^2;

    Jvec(i) = ...
        energyCost + ...
        penaltySOC + ...
        penaltyFinal;

end

[bestJ,bestIdx] = min(Jvec);

bestSchedule = population(bestIdx,:);

% ------------------------------------------------
% Simulate optimal schedule
% ------------------------------------------------

SOCbest = zeros(1,N+1);

SOCbest(1) = SOC0;

PgridBest = zeros(1,N);
PimportBest = zeros(1,N);

E = SOC0*Emax;

optimizedCost = 0;

for k = 1:N

    PB = bestSchedule(k);

    if PB < 0

        E = E + ...
            etaCh*(-PB)*dt;

    else

        E = E - ...
            PB*dt/etaDis;

    end

    SOCbest(k+1) = E/Emax;

    PgridBest(k) = ...
        loadMW(k) - ...
        pvMW(k) - ...
        PB;

    PimportBest(k) = ...
        max(PgridBest(k),0);

    optimizedCost = ...
        optimizedCost + ...
        buyPrice(k)*PimportBest(k)*dt;

end

saving = baseCost - optimizedCost;

% ------------------------------------------------
% PV self-consumption indicators
% ------------------------------------------------

gridImportEnergyBase = ...
    sum(PimportBase)*dt;

gridImportEnergyOpt = ...
    sum(PimportBest)*dt;

importReduction = ...
    gridImportEnergyBase - ...
    gridImportEnergyOpt;

% ------------------------------------------------
% Display results
% ------------------------------------------------

fprintf('Integrated PV-Battery Energy Management\n\n')

fprintf('Base cost without battery = %.2f EUR\n', ...
        baseCost)

fprintf('Optimized cost = %.2f EUR\n', ...
        optimizedCost)

fprintf('Cost saving = %.2f EUR\n\n', ...
        saving)

fprintf('Grid import without battery = %.3f MWh\n', ...
        gridImportEnergyBase)

fprintf('Grid import with battery = %.3f MWh\n', ...
        gridImportEnergyOpt)

fprintf('Grid import reduction = %.3f MWh\n\n', ...
        importReduction)

fprintf('Optimal Battery Schedule [MW]:\n')
disp(bestSchedule)

fprintf('SOC Trajectory:\n')
disp(SOCbest)

% ------------------------------------------------
% Convergence
% ------------------------------------------------

figure

plot(1:maxGen,bestHist,'LineWidth',1.6)

grid on

xlabel('Generation')
ylabel('Best Objective')

title('PV-Battery Energy Management Convergence')

% ------------------------------------------------
% Load and PV
% ------------------------------------------------

figure

plot(1:N,loadMW,'o-','LineWidth',1.6)
hold on

plot(1:N,pvMW,'s-','LineWidth',1.6)

grid on

xlabel('Hour')
ylabel('Power [MW]')

legend('Load','PV Generation', ...
       'Location','best')

title('Load and PV Profiles')

% ------------------------------------------------
% Battery schedule
% ------------------------------------------------

figure

bar(1:N,bestSchedule)

grid on

xlabel('Hour')
ylabel('Battery Power [MW]')

title('Optimal Battery Schedule')

% ------------------------------------------------
% SOC trajectory
% ------------------------------------------------

figure

plot(0:N,SOCbest,'o-','LineWidth',1.6)

hold on

yline(SOCmin,'--')
yline(SOCmax,'--')

grid on

xlabel('Hour')
ylabel('State of Charge')

title('Battery SOC')

% ------------------------------------------------
% Grid exchange
% ------------------------------------------------

figure

plot(1:N,PgridBase,'o-','LineWidth',1.6)
hold on

plot(1:N,PgridBest,'s-','LineWidth',1.6)

yline(0,'--')

grid on

xlabel('Hour')
ylabel('Grid Power [MW]')

legend('Without Battery','With Battery', ...
       'Location','best')

title('Grid Exchange Comparison')

% ------------------------------------------------
% Electricity price
% ------------------------------------------------

figure

stairs(1:N,buyPrice,'LineWidth',1.6)

grid on

xlabel('Hour')
ylabel('Price [EUR/MWh]')

title('Electricity Price')

18. Interpreting Midday Operation

During high PV production:

or even:

charging the battery may increase local use of solar energy.

19. Interpreting Evening Operation

During high-price evening hours:

the stored solar energy can be discharged:

reducing expensive grid purchases.

20. PV Self-Consumption

PV self-consumption means using locally generated PV energy locally rather than exporting or curtailing it.

21. Experiment 1 — Remove PV

pvMW = zeros(size(pvMW));

Compare the battery schedule and energy cost.

22. Experiment 2 — Increase PV Size

pvMW = 1.5*pvMW;

Observe grid exchange and battery charging.

23. Experiment 3 — Remove Battery

Set:

PchMax = 0;
PdisMax = 0;

This reproduces the PV-only reference case.

24. Experiment 4 — Increase Battery Capacity

Emax = 3;
Emax = 5;
Emax = 10;

25. Add Export Price

Define:

sellPrice = [20 20 20 20 20 20];

Then use:

26. Add Battery Degradation

A more realistic objective can include:

Then:

27. Add PV Curtailment

When PV production is larger than local demand and storage capability, some PV power may need to be curtailed.

The power balance becomes:

28. Multi-Objective Smart Energy Management

An advanced objective can combine:

29. From Optimization to AI Control

The optimizer can generate many optimal operating examples:

These examples can then train a neural network:

30. Lab Tasks

1. Enter load, PV, and electricity-price profiles.
2. Calculate the baseline grid exchange without battery.
3. Calculate baseline electricity cost.
4. Implement the battery SOC equations.
5. Implement the grid-power equation.
6. Add SOC and final-SOC penalties.
7. Run the optimizer.
8. Plot load and PV generation.
9. Plot the optimal battery schedule.
10. Plot SOC.
11. Compare grid exchange before and after optimization.
12. Calculate economic savings.
13. Calculate grid-import reduction.
14. Increase PV size and compare results.
15. Increase battery capacity and compare results.
16. Explain how this optimization can provide training data for an ANN.

📝 Review Questions

1. Write the power-balance equation for the PV-battery-grid system.
2. What does positive battery power mean?
3. What does negative grid power mean?
4. Why can a battery increase PV self-consumption?
5. Why is the final-SOC condition important?
6. How does electricity price influence battery scheduling?
7. What is the effect of increasing PV capacity?
8. What is the effect of increasing battery capacity?
9. Why should battery degradation be included in realistic optimization?
10. How can optimal schedules be used to train an AI controller?