HEV能量管理建模实战：从零搭建 Simulink 物理环境到 Python(DQN) 强化学习联合仿真调通

1. 状态离散化 (State Discretization) 与网格构建

DP的第一步是把连续的物理世界变成计算机可以计算的离散网格。

时间离散化 (ttt)： 通常将给定的工况（如WLTC、NEDC）按 Δt=1s\Delta t = 1sΔt=1s 的步长进行离散。如果工况总时长为 NNN 秒，那么时间序列为 k∈{1,2,...,N}k \in \{1, 2, ..., N\}k∈{1,2,...,N}。
状态变量离散化 (xxx)： 对于HEV，核心状态变量是电池的荷电状态（SOC）。你需要定义一个工作区间，例如 SOC∈[0.3,0.8]SOC \in [0.3, 0.8]SOC∈[0.3,0.8]，并将其划分为 NxN_xNx 个离散点（例如100个网格点）。网格越密，精度越高，但计算时间会呈指数级增长（维度灾难）。
控制变量离散化 (uuu)： 这是EMS需要决策的量，通常是发动机功率、电机扭矩或功率分配比例（Power Split Ratio）。同样需要根据物理极限（如发动机最大转矩曲线、电机外特性曲线）设定上下限，并划分为 NuN_uNu 个离散点。

2. 代价累积 (Cost Accumulation) 与转移约束

在每一个时间步的每一个状态节点上，系统必须评估采取不同控制动作的"代价"。

阶段代价 (Stage Cost)： Lk(xk,uk)L_k(x_k, u_k)Lk(xk,uk) 通常代表在第 kkk 秒内消耗的燃油量。这需要通过查发动机的万有特性Map图（BSFC Map）来插值计算得到。
状态转移方程： 采取动作 uku_kuk 后，下一个状态 xk+1x_{k+1}xk+1（即下一秒的SOC）如何变化？公式通常为：

SOCk+1=SOCk−Ibatt(SOCk,uk)QmaxΔtSOC_{k+1} = SOC_k - \frac{I_{batt}(SOC_k, u_k)}{Q_{max}} \Delta tSOCk+1=SOCk−QmaxIbatt(SOCk,uk)Δt

其中 IbattI_{batt}Ibatt 是电池电流，QmaxQ_{max}Qmax 是电池最大容量。

罚函数 (Penalty Function)： 这是极其关键的一步。如果某个 uku_kuk 导致 SOCk+1SOC_{k+1}SOCk+1 超出了 [0.3,0.8][0.3, 0.8][0.3,0.8] 的安全范围，或者所需的总扭矩超过了动力系统的物理极限，必须将该动作的代价设为无穷大（∞\infty∞），在Matlab中通常赋予一个极大的数值（如 10610^6106），迫使算法放弃这条路径。

3. 逆向递推 (Backward Induction) 求解算法

这是DP求全局最优的灵魂，基于贝尔曼最优化原理（Bellman Equation）。必须从工况的最后一秒逆推回第一秒。

终点边界条件： 在终端时刻 NNN，我们需要设定目标代价 JN(xN)J_N(x_N)JN(xN)。通常要求HEV维持电量平衡（Charge-Sustaining），即最终SOC必须等于初始SOC。因此，若 SOCN=SOCinitSOC_N = SOC_{init}SOCN=SOCinit，代价为0；否则，施加巨大的终点惩罚。
核心递推方程： 从 k=N−1k = N-1k=N−1 步开始，一直倒推到 k=1k = 1k=1：

Jk∗(xk)=min⁡uk[Lk(xk,uk)+Jk+1∗(xk+1)]J_k^*(x_k) = \min_{u_k} \left[ L_k(x_k, u_k) + J_{k+1}^*(x_{k+1}) \right]Jk∗(xk)=ukmin[Lk(xk,uk)+Jk+1∗(xk+1)]

（当前状态采取某动作的瞬时油耗 + 采取该动作后导致下一状态的未来最优总代价）

Matlab代码关键点：插值 (Interpolation)。 当你计算出 xk+1x_{k+1}xk+1 时，它极大概率不会刚好落在你第一步定义的标准SOC网格点上。你必须使用 Matlab 的 interp1 函数，根据已知的下一时刻网格点代价，插值估算出 Jk+1∗(xk+1)J_{k+1}^*(x_{k+1})Jk+1∗(xk+1)。

4. 正向验证：Simulink 模型构建详解

第 0 步：准备工作区变量 (MATLAB Workspace)

Simulink 模型运行需要底层参数支撑。在打开 Simulink 之前，请先在 MATLAB 主界面新建一个脚本（例如命名为 init_hev.m），输入以下代码并点击"运行 (Run)"。这会将变量加载到你的工作区中。

matlab 复制代码

% 车辆与环境参数
m = 1380;       % 整备质量 (kg)
g = 9.81;       % 重力加速度 (m/s^2)
f = 0.015;      % 滚动阻力系数
rho = 1.225;    % 空气密度 (kg/m^3)
Cd = 0.3;       % 风阻系数
A = 2.0;        % 迎风面积 (m^2)

% 电池参数
Voc = 201.6;    % 电池开路电压 (V)
Qcap = 6.5 * 3600; % 电池容量 (A*s)
SOC_init = 0.6; % 初始SOC

% 构建一个极简的测试工况 (时间 0-100秒，车速 0-20m/s)
t = (0:100)'; 
v = [linspace(0, 20, 40), 20*ones(1, 30), linspace(20, 0, 31)]';
cyc_data = [t, v]; % 用于Simulink调用的矩阵

第 1 步：创建模型与基础设置

在 MATLAB 命令行输入 simulink，按回车。
点击 Blank Model（空白模型）。
在上方菜单栏选择 Modeling -> Model Settings (齿轮图标)。

在 Solver 面板中，将 Type 改为 Fixed-step。
将 Solver 改为 discrete (no continuous states)。
将 Fixed-step size (fundamental sample time) 设为 1。
点击 OK。

第 2 步：搭建"工况输入与整车动力学"模块

目标：根据车速算出轮边需求功率 (PreqP_{req}Preq)

1. 拖入所需模块 (在 Library Browser 搜索以下英文名称)：

From Workspace (1个)
Derivative (1个)
Math Function (1个)
Gain (3个)
Add (1个)
Product (1个)

2. 参数设置 (双击模块修改)：

From Workspace: 将 Data 参数改为 cyc_data。
Math Function: 将 Function 改为 square (用于计算 v2v^2v2)。
Gain (命名为"滚阻"): 将 Gain 参数改为 m*g*f。
Gain (命名为"风阻"): 将 Gain 参数改为 0.5*rho*Cd*A。
Gain (命名为"惯性力"): 将 Gain 参数改为 m。
Add: 将 List of signs 改为 +++。

3. 连线方式：

将 From Workspace 的输出端（代表车速 vvv）引出三条分支线。
分支 1 连接到"滚阻" Gain 模块。
分支 2 连接到 Math Function，其输出再连接到"风阻" Gain 模块。
分支 3 连接到 Derivative，其输出再连接到"惯性力" Gain 模块。
将这三个 Gain 模块的输出全部连接到 Add 模块的三个输入端。此时 Add 的输出代表总需求力 (FFF)。
将 Add 的输出连接到 Product 的第一个输入端。
从 From Workspace 再次引出一根车速 vvv 的线，连接到 Product 的第二个输入端。
此时 Product 的输出端即为 需求功率 PreqP_{req}Preq。

第 3 步：搭建"能量管理策略 (EMS)"模块

目标：决定发动机和电机各自出多少力。因为你的 DP 数据还没算出来，我们先用一个简单的规则模块占位，方便模型跑通闭环。

1. 拖入所需模块：

MATLAB Function (1个)

2. 参数设置：

双击 MATLAB Function 模块，删掉里面的默认代码，复制粘贴以下代码：

matlab 复制代码

function [P_eng, P_mot] = ems_controller(P_req, SOC)
    % 简单的逻辑门限策略 (Rule-based) 占位
    if SOC > 0.3 && P_req < 30000 
        P_eng = 0;          % 纯电模式
        P_mot = P_req;
    else
        P_eng = P_req;      % 纯燃油模式
        P_mot = 0;
    end
end

3. 连线方式：

将第 2 步中 Product 算出的 需求功率 PreqP_{req}Preq 连接到 MATLAB Function 的第一个输入端口 P_req。
模块的第二个输入端口 SOC 暂时悬空（等最后一步连回来）。

第 4 步：搭建"发动机油耗"模块

目标：根据发动机输出功率计算耗油量。

1. 拖入所需模块：

1-D Lookup Table (1个)
Discrete-Time Integrator (1个)

2. 参数设置：

1-D Lookup Table:
Table data 填入 [0, 1.0, 2.5, 4.2, 6.0] (代表油耗率 g/s)。
Breakpoints 1 填入 [0, 15000, 30000, 45000, 60000] (代表功率 W)。
Discrete-Time Integrator (命名为"累计油耗"):
将 Initial condition 改为 0。

3. 连线方式：

将第 3 步 MATLAB Function 输出的第一根线 P_eng 连接到 1-D Lookup Table 的输入端。
将 1-D Lookup Table 的输出端连接到 Discrete-Time Integrator。积分器的输出即为总油耗 (g)。

第 5 步：搭建"电池 SOC 动态"模块（关键闭环）

目标：根据电机的功率计算 SOC 的变化，并反馈给大脑。

1. 拖入所需模块：

Gain (1个)
Discrete-Time Integrator (1个)
Unit Delay (1个，极其重要，用于消除代数环报错)

2. 参数设置：

Gain:
将 Gain 改为 -1 / (Voc * Qcap)。（注意前面的负号，代表放电导致 SOC 降低）。
Discrete-Time Integrator (命名为"SOC积分"):
将 Initial condition 改为 SOC_init。
建议勾选 Limit output ，将 Upper limit 设为 1，Lower limit 设为 0。
Unit Delay:
Sample time 保持为 -1。

3. 连线方式：

将第 3 步 MATLAB Function 输出的第二根线 P_mot 连接到刚刚设置好的 Gain 模块。
将 Gain 的输出端连接到 Discrete-Time Integrator (SOC积分)。
将 Discrete-Time Integrator 的输出端连接到 Unit Delay 模块。
形成闭环： 从 Unit Delay 的输出端引出一根长线，往回拉 ，连接到第 3 步 MATLAB Function 那个一直悬空的 SOC 输入端口。

第 6 步：运行与查看结果

在 Simulink 顶部的工具栏中，将仿真停止时间 (Stop Time) 设为 100（因为我们第一步设置的测试工况就是 100 秒）。
从 Library Browser 中拖入两个 Scope (示波器) 模块。
将一个 Scope 连接到第 5 步 Discrete-Time Integrator 的输出线上（查看 SOC 变化曲线）。
将另一个 Scope 连接到第 4 步算出的"总油耗"线上。
点击绿色的 Run 按钮。

双击打开示波器，你应该能看到 SOC 随着车速的变化而下降，并在特定逻辑下触发发动机工作。

这就完成了一个具备完整闭环逻辑的 HEV 后向仿真模型。当你的 DP、PSO 或 GA 算法得出真实的策略矩阵或权重后，只需要把第 3 步的 MATLAB Function 替换成相应的高阶查表或神经网络模块即可。

实现路线一（动态规划 DP）需要严格分为两个阶段：阶段一是在 MATLAB 中编写并运行逆向递推代码，阶段二是在 Simulink 中将计算结果通过查表模块正向调用。

下面是完整的落地实现方法。

阶段一：MATLAB 逆向递推求解代码 (Backward Induction)

在运行 Simulink 之前，你必须先运行这段 MATLAB 代码。这段代码会从工况的最后一秒往回算，找出每一个时间点、每一个 SOC 状态下，最省油的发动机功率，并生成一个最优控制矩阵 opt_P_eng_matrix。

在 MATLAB 中新建一个脚本文件（例如命名为 run_dp_hev.m），复制并运行以下代码：

matlab 复制代码

% ==========================================
% HEV 动态规划 (DP) 能量管理基准求解器
% ==========================================

%% 1. 导入工况与基础参数
% (假设你已经运行了之前我们定义的 init_hev.m，工作区有 m, g, f, rho, Cd, A, Voc, Qcap 等参数)
t_cyc = 0:1:100; % 100秒测试工况时间轴
v_cyc = [linspace(0, 20, 40), 20*ones(1, 30), linspace(20, 0, 31)]; % 车速 m/s
N_time = length(t_cyc);

% 提前计算每一秒的需求功率 Preq (W)
a_cyc = [0, diff(v_cyc)]; % 简单差分求加速度
F_req = m*g*f + 0.5*rho*Cd*A.*(v_cyc.^2) + m.*a_cyc;
P_req = F_req .* v_cyc; 

%% 2. 状态与控制变量离散化
% 状态变量：SOC 
N_soc = 100;
SOC_grid = linspace(0.3, 0.8, N_soc); 

% 控制变量：发动机功率 Peng (W)
N_u = 50;
P_eng_grid = linspace(0, 73000, N_u); 

%% 3. 初始化代价矩阵
% Cost-to-go 矩阵 J，尺寸为 [SOC网格数, 时间步数]
J = zeros(N_soc, N_time); 
% 最优控制策略矩阵 opt_u，尺寸与 J 相同
opt_P_eng_matrix = zeros(N_soc, N_time); 

% 设定终点(t=N)边界条件：强制电量维持 (Charge-Sustaining)
target_soc = 0.6;
penalty_weight = 1e6; % 巨大惩罚系数
J(:, end) = penalty_weight * (SOC_grid - target_soc).^2; % 越偏离目标SOC，终点代价越大

%% 4. DP 逆向递推主循环 (Bellman Equation)
for k = N_time-1 : -1 : 1
    
    current_P_req = P_req(k);
    
    % 遍历每一个 SOC 状态网格
    for i = 1:N_soc
        current_soc = SOC_grid(i);
        
        % 预分配一个数组来存当前状态下，采取所有可能动作的总代价
        total_cost_vector = inf(1, N_u);
        
        % 遍历每一个控制动作
        for j = 1:N_u
            P_eng_action = P_eng_grid(j);
            P_mot_action = current_P_req - P_eng_action; % 电机需要补齐的功率
            
            % --- 物理模型计算 ---
            % 1. 计算瞬时油耗 (阶段代价 L)
            % 这里使用简单的线性等效代入，实际应使用 interp1 查发动机燃油消耗率Map
            fuel_rate = P_eng_action * 0.0001; % 假设的油耗系数 g/s
            
            % 2. 计算下一时刻的 SOC (状态转移方程)
            % 假设简单的线性电池模型
            I_batt = P_mot_action / Voc; 
            next_soc = current_soc - (I_batt / Qcap);
            
            % --- 约束与惩罚 ---
            % 如果下一时刻SOC越界，赋予无穷大代价
            if next_soc < 0.3 || next_soc > 0.8
                stage_cost = inf;
            else
                stage_cost = fuel_rate;
            end
            
            % --- 核心：贝尔曼方程 ---
            if stage_cost ~= inf
                % 使用 interp1 查出下一状态在未来(k+1)的已知代价值
                future_cost = interp1(SOC_grid, J(:, k+1), next_soc, 'linear', 'extrap');
                total_cost_vector(j) = stage_cost + future_cost;
            end
        end
        
        % --- 寻找当前状态下的最小代价和最优动作 ---
        [min_cost, min_idx] = min(total_cost_vector);
        
        J(i, k) = min_cost;                      % 记录最小未来总代价
        opt_P_eng_matrix(i, k) = P_eng_grid(min_idx); % 保存最优动作
    end
end

disp('DP 逆向递推计算完成！最优控制矩阵 opt_P_eng_matrix 已生成在工作区。');

阶段二：Simulink 建模验证与连接

运行完上述脚本后，你的 MATLAB 工作区 (Workspace) 中会多出一个二维矩阵 opt_P_eng_matrix。现在打开你之前搭好的 Simulink 模型，我们将之前的规则模块替换为 DP 最优策略。

1. 替换核心模块

删除模块 ：将模型中第三步建立的 MATLAB Function 模块（里面写了 if-else 逻辑的那个）直接删除。
添加新模块 ：打开 Simulink Library Browser，在 Simulink / Lookup Tables 中找到并拖入 2-D Lookup Table 模块。

2. 参数设置 (Parameters)

双击打开 2-D Lookup Table 模块，严格按照以下参数进行设置，将我们在 MATLAB 中算出的 DP 数据映射进去：

Table and Breakpoints 选项卡：
Table data : 输入 opt_P_eng_matrix
Breakpoints 1 : 输入 SOC_grid (这是我们在代码中定义的行向量)
Breakpoints 2 : 输入 t_cyc (这是我们在代码中定义的时间列向量)
Algorithm 选项卡：
Interpolation method : 选择 Linear point-slope (线性插值)
Extrapolation method : 选择 Clip (截断，防止查表越界报错)
点击 OK 保存设置。

3. 信号连接方式 (Connections)

此时 2-D Lookup Table 模块左侧会有两个输入端口，右侧有一个输出端口。

输入端口 1 (对应 Breakpoints 1, 即 SOC)：
将模型中负责"电池 SOC 动态"的 Unit Delay 模块的输出端，通过一根反馈线拉过来，连接到这个端口。它代表实时的车辆 SOC 状态。
输入端口 2 (对应 Breakpoints 2, 即 Time)：
从 Simulink 库 (Simulink / Sources) 中拖入一个 Clock 模块。
将 Clock 模块的输出端直接连接到查表模块的第二个输入端口。它代表当前的仿真时间 ttt。
输出端口 (最优控制动作)：
查表模块的输出即为当前时刻、当前 SOC 下的最优发动机功率指令 (PengP_{eng}Peng)。
将其连接到后续的油耗计算模块 (查油耗 Map) 以及功率分配模块 (与 PreqP_{req}Preq 相减得到电机功率 PmotP_{mot}Pmot)。

如何修正（仅需增加 1 个模块）：

在工作区空白处，拖入一个 Subtract (减法) 模块（或者拖入一个 Sum 模块并把符号改为 +-）。
将左侧 Product 模块输出的**总需求功率 P_req**，拉一根线连到减法模块的 + (正极端)。
将中间 2-D T(u) 查表模块的输出端（代表发动机功率 ），分出一根线，连到减法模块的 - (负极端)。
将这个减法模块的输出端 ，连接到那根红色虚线 的位置（也就是接入 -1/(Voc*Qcap) 增益模块）。

修正后的信号流逻辑就完美了：

左侧算出今天总共需要多少力气 (PreqP_{req}Preq) →\rightarrow→ DP查表大脑决定发动机出多少力 (PengP_{eng}Peng) →\rightarrow→ 两者相减，剩下的差额交给电机补齐 (PmotP_{mot}Pmot) →\rightarrow→ 电机工作导致电池 SOC 变化 →\rightarrow→ 更新后的 SOC 反馈给下一次查表。

路线二（启发式算法，如 PSO 或 GA 联合仿真）是目前学术界和工程界极其常用的一种参数寻优手段。它的核心思想是：让 MATLAB 充当"大脑"（负责生成参数、判断好坏），让 Simulink 充当"跑分软件"（负责根据特定参数跑出油耗结果）。

要实现这个闭环，我们需要完成三个文件的编写与修改：Simulink 模型改造 、适应度评价函数 (fitness_hev.m) 以及主优化脚本 (main_pso_hev.m)。

以下是保姆级的具体实现方法。

第一阶段：改造 Simulink 模型 (准备联合仿真)

为了让 MATLAB 能够外部控制 Simulink，我们需要把模型里"写死"的参数变成"变量"，并把仿真的最终结果输出回 MATLAB。

1. 修改控制策略 (MATLAB Function)

打开你之前建好的 Simulink 模型（假设另存为命名为 hev_rule_model.slx），双击第三步的 MATLAB Function 模块，将代码修改为支持外部参数传入的形式：

matlab 复制代码

function [P_eng, P_mot] = ems_controller(P_req, SOC, opt_soc_low, opt_p_thresh)
    % 核心参数现在由外部(PSO算法)传入
    % opt_soc_low: 允许纯电行驶的最低 SOC 门限 (例如 0.35)
    % opt_p_thresh: 强制发动机启动的功率门限 (例如 25000 W)
    
    if SOC > opt_soc_low && P_req < opt_p_thresh 
        P_eng = 0;          % 纯电模式
        P_mot = P_req;
    else
        P_eng = P_req;      % 纯燃油模式
        P_mot = 0;
    end
end

修改后，模块左侧会多出两个输入端口。

2. 接入外部变量

在 Simulink 库中找到 Constant (常数) 模块，拖入 2 个。
双击第一个 Constant，将其 Constant value 填为变量名：opt_soc_low。将其连接到 MATLAB Function 的 opt_soc_low 端口。
双击第二个 Constant，将其 Constant value 填为变量名：opt_p_thresh。将其连接到 opt_p_thresh 端口。

3. 导出仿真结果

算法需要知道两件事：这趟跑了多少油？最终电池还剩多少电？

拖入 2 个 To Workspace 模块。
将第一个连接到"累计油耗"积分器的输出端。双击它，将 Variable name 改为 out_fuel，Save format 改为 Array。
将第二个连接到"SOC"延迟模块的输出端。双击它，将 Variable name 改为 out_soc，Save format 改为 Array。

第二阶段：编写适应度函数 (Fitness Function)

这是连接优化算法和 Simulink 模型的桥梁。在 MATLAB 中新建一个脚本，严格命名为 fitness_hev.m。

matlab 复制代码

function J = fitness_hev(x)
    % 适应度函数：接收粒子参数 x，运行 Simulink，返回油耗代价值 J
    % x(1) -> opt_soc_low (SOC下限)
    % x(2) -> opt_p_thresh (功率阈值)
    
    % 1. 将算法生成的当前粒子参数，强行推入 MATLAB 基础工作区 (Base Workspace)
    % 这是因为 Simulink 的 Constant 模块只能从 Base 工作区读取变量
    assignin('base', 'opt_soc_low', x(1));
    assignin('base', 'opt_p_thresh', x(2));
    
    % 2. 静默调用 Simulink 模型进行联合仿真
    % 注意：'hev_rule_model' 必须和你的 Simulink 文件名完全一致
    % 禁用诊断警告以加快运行速度
    try
        simOut = sim('hev_rule_model', 'ReturnWorkspaceOutputs', 'on', 'FastRestart', 'off');
        
        % 3. 提取仿真结果的最后一行数据 (即工况结束时的总油耗和最终 SOC)
        total_fuel = simOut.out_fuel(end);
        final_soc = simOut.out_soc(end);
        
        % 4. 计算惩罚项 (Penalty Function) ------ HEV 优化的灵魂
        % 混合动力汽车必须保证电量平衡 (Charge-Sustaining)
        % 如果最终 SOC 偏离初始 SOC (比如 0.6)，必须给予严重的惩罚
        target_soc = 0.6;
        penalty_weight = 100000; % 惩罚权重，视油耗的数量级而定
        penalty = penalty_weight * abs(final_soc - target_soc);
        
        % 5. 计算总适应度 (越小越好)
        J = total_fuel + penalty;
        
    catch ME
        % 如果仿真因为参数不合理(如代数环、非法输入)报错崩溃
        % 赋予该粒子一个极大的惩罚值，让算法自动淘汰它
        J = 1e6; 
    end
end

第三阶段：编写 PSO 主优化脚本

现在大脑和桥梁都建好了，我们使用 MATLAB 内置的粒子群算法库来启动优化。新建一个脚本，命名为 main_pso_hev.m。

matlab 复制代码

% ==========================================
% HEV 能量管理策略 - 粒子群 (PSO) 参数寻优
% ==========================================
clear; clc;

% 1. 确保基础物理参数和工况已经加载到工作区
% (这里调用我们最初写的初始化脚本)
init_hev; 

% 2. 定义寻优变量的边界 (Lower Bounds & Upper Bounds)
% 变量 1: opt_soc_low (合理范围 0.2 到 0.5)
% 变量 2: opt_p_thresh (合理范围 10000W 到 50000W)
lb = [0.2, 10000];
ub = [0.5, 50000];
nvars = 2; % 变量个数

% 3. 设置 PSO 算法核心参数
options = optimoptions('particleswarm', ...
    'SwarmSize', 20, ...          % 种群规模 (粒子数量)
    'MaxIterations', 30, ...      % 最大迭代次数
    'Display', 'iter', ...        % 在控制台打印每代结果
    'UseParallel', false);        % 如果你的电脑核心多，可设为 true 开启并行加速运算

% 4. 启动粒子群算法！
disp('>>> 开始 Simulink 联合仿真寻优...');
tic; % 开始计时
[x_opt, fval_opt, exitflag, output] = particleswarm(@fitness_hev, nvars, lb, ub, options);
toc; % 结束计时

% 5. 结果展示
disp('------------------------------------');
disp('优化完成！最佳策略参数为：');
fprintf('最优 SOC 下限门限 (opt_soc_low) = %.4f\n', x_opt(1));
fprintf('最优 功率启动阈值 (opt_p_thresh) = %.1f W\n', x_opt(2));
fprintf('此时的最低综合代价 (油耗+惩罚) = %.2f\n', fval_opt);

% 6. 使用最优参数再跑一次 Simulink，查看完美曲线
assignin('base', 'opt_soc_low', x_opt(1));
assignin('base', 'opt_p_thresh', x_opt(2));
sim('hev_rule_model');
disp('>>> 已使用最优参数运行模型，请打开 Simulink Scope 查看最终 SOC 与油耗曲线。');

避坑指南与执行顺序：

**先运行 init_hev.m** 确保物理参数（车重、空气密度等）都在。
确保你的 Simulink 模型名称叫 hev_rule_model.slx，并且和这三个 .m 脚本放在同一个文件夹下。
直接点击运行 main_pso_hev.m。

你会看到 MATLAB 命令行窗口开始滚动，显示每一代（Iteration）的种群最佳油耗正在逐渐降低。算法实际上在后台疯狂地启动和关闭 Simulink 模型（20×30=60020 \times 30 = 60020×30=600 次），自动帮你寻找那个能让油耗最低、且 SOC 不掉的黄金分割点。

如果你的参数扩展到 5 个甚至 10 个（比如引入电机效率区间的划分），只需要在 lb 和 ub 数组中增加维度，并修改 fitness_hev 里的参数映射即可，框架是完全通用的。

bash 复制代码

>>> 开始 Simulink 联合仿真寻优...

                                 Best            Mean     Stall
Iteration     f-count            f(x)            f(x)    Iterations
    0              20            2151            8957        0
    1              40            1929            5379        0
    2              60            1929            2733        1
    3              80            1929            2052        2
    4             100            1929            1940        3
    5             120            1929            1929        4
    6             140            1929            1940        5
    7             160            1929            1951        6
    8             180            1929            1929        7
    9             200            1929            1929        8
   10             220            1929            1940        9
   11             240            1929            1929       10
   12             260            1929            1940       11
   13             280            1929            1929       12
   14             300            1929            1929       13
   15             320            1929            1929       14
   16             340            1929            1929       15
   17             360            1929            1929       16
   18             380            1929            1929       17
   19             400            1929            1929       18
   20             420            1929            1929       19
   21             440            1929            1929       20
Optimization ended: relative change in the objective value 
over the last OPTIONS.MaxStallIterations iterations is less than OPTIONS.FunctionTolerance.
历时 222.334548 秒。
------------------------------------
优化完成！最佳策略参数为：
最优 SOC 下限门限 (opt_soc_low) = 0.3936
最优 功率启动阈值 (opt_p_thresh) = 10350.9 W
此时的最低综合代价 (油耗+惩罚) = 1928.82
>>> 已使用最优参数运行模型，请打开 Simulink Scope 查看最终 SOC 与油耗曲线。

搭建一个专为深度强化学习 (DQN) 准备的、标准且严谨的 Simulink HEV 交互环境。

在这个终极版本中，Simulink 模型将不再拥有自己的"大脑"，它将变成一个纯粹的"物理肉身"（环境）。它唯一的作用就是：接收来自 Python 的动作（发动机功率），执行 1 秒，然后向 Python 汇报当前的油耗（奖励）和电池电量（状态）。

请打开你的 MATLAB，按照以下"保姆级"步骤，一步不差地进行操作。

第一阶段：初始化工作区 (MATLAB 脚本)

在开始画图之前，必须给系统注入物理灵魂。

在 MATLAB 中新建一个脚本，严格命名为 init_hev_env.m。
复制以下代码，并点击运行 (Run)，确保右侧的 Workspace 出现了这些变量。

matlab 复制代码

% ==========================================
% HEV 强化学习联合仿真 - 物理参数与环境初始化
% ==========================================

% --- 1. 车辆物理参数 ---
m = 1380;       % 整备质量 (kg)
g = 9.81;       % 重力加速度 (m/s^2)
f = 0.015;      % 滚动阻力系数
rho = 1.225;    % 空气密度 (kg/m^3)
Cd = 0.3;       % 风阻系数
A = 2.0;        % 迎风面积 (m^2)

% --- 2. 电池与电机参数 ---
Voc = 201.6;       % 电池开路电压 (V)
Qcap = 6.5 * 3600; % 电池容量 (A*s)
SOC_init = 0.6;    % 测试初始电量 (这里定义了 SOC_init)

% --- 3. 测试工况 (前100秒简易测试用) ---
t = (0:100)'; 
v = [linspace(0, 20, 40), 20*ones(1, 30), linspace(20, 0, 31)]';
cyc_data = [t, v]; 

% --- 4. 为 RL 交互提前"占坑" ---
% (必须放在文件最末尾，确保前面的参数都已经定义好)
Action_Peng = 0;       % 动作输入占位
live_SOC = SOC_init;   % 状态1占位 (使用上面定义的 0.6)
live_Preq = 0;         % 状态2占位
live_Reward = 0;       % 奖励占位

第二阶段：搭建纯物理环境 (Simulink 画布)

在 MATLAB 命令行输入 simulink，创建一个 Blank Model (空白模型)。
点击上方菜单栏的齿轮图标 (Model Settings)：

Solver Type 改为 Fixed-step。
Solver 改为 discrete (no continuous states)。
Fixed-step size 设为 1。
点击 OK。

现在，我们分 4 个区块来拖拽模块（在 Library Browser 中搜索英文名）：

区块 1：计算需求功率 (PreqP_{req}Preq)

拖入 From Workspace，双击将 Data 改为 cyc_data。
拖入 Derivative、Math Function (设为 square)、3个 Gain、Add、Product。
连线：

From Workspace (车速) 分出三根线。
线1 -> Gain (设为 m*g*f)。
线2 -> Math Function -> Gain (设为 0.5*rho*Cd*A)。
线3 -> Derivative -> Gain (设为 m)。
把这 3 个 Gain 的输出连入 Add (符号设为 +++)，得到总阻力 FFF。
将 Add 的输出与最早的车速信号一起连入 Product，得到总需求功率 PreqP_{req}Preq。

区块 2：计算瞬时油耗 (Reward 的来源)

拖入 In1 (Inport) 模块，双击改名为 Action_Peng。(重要：这就是 Python 以后控制发动机的入口！)
拖入 1-D Lookup Table。

Table data 设为 [0, 1.0, 2.5, 4.2, 6.0] (油耗率 g/s)。
Breakpoints 1 设为 [0, 15000, 30000, 45000, 60000] (功率 W)。

连线：将 Action_Peng 连入查表模块，输出即为瞬时油耗。

区块 3：功率分配 (核心物理约束)

拖入 Subtract (减法模块)。
连线：

将区块 1 算出的总需求功率 PreqP_{req}Preq 连到 + 端。
将区块 2 的 Action_Peng 分出一根线，连到 - 端。
输出即为电机需求功率 PmotP_{mot}Pmot。

区块 4：电池动态 (State 的来源)

拖入 Gain、Discrete-Time Integrator、Unit Delay。
双击 Gain，设为 -1 / (Voc * Qcap)。
双击 Discrete-Time Integrator，Initial condition 设为 SOC_init。
连线：

将区块 3 的 PmotP_{mot}Pmot 连入 Gain，再连入积分器。
积分器的输出连入 Unit Delay (破除代数环)。输出即为实时 SOC。

第三阶段：封装强化学习接口 (神级改造)

纯物理模型做好了，现在我们要把它包装成符合 DQN 标准的"状态-动作-奖励" (State-Action-Reward) 格式。

1. 整合状态 (State) 暴露给外部：

拖入一个 Mux (多路复用) 模块。
将模型里的 实时 SOC 连入 Mux 第一个口。
将区块 1 的 需求功率 PreqP_{req}Preq 连入 Mux 第二个口。
拖入一个 Out1 (Outport) 模块，重命名为 State，连接到 Mux 的输出端。

2. 计算奖励 (Reward) 并暴露给外部：

拖入一个 MATLAB Function 模块，双击写入计算奖励的代码：

matlab 复制代码

function Reward = calc_reward(fuel_rate, SOC)
    % DQN 需要最大化奖励，所以油耗越高，给的奖励越负
    R_fuel = -fuel_rate * 10; 

    % 如果 SOC 掉出安全范围，给予严重惩罚
    if SOC < 0.3 || SOC > 0.8
        R_soc = -1000;
    else
        R_soc = -50 * abs(SOC - 0.6); % 尽量维持在0.6
    end

    Reward = R_fuel + R_soc;
end

第一步：在 Simulink 里安插"数据间谍"

打开你的 HEV_RL_Env.slx 模型。
之前的 State 和 Reward 端口你留着不用管它。
从库里拖入一个全新的 MATLAB Function 模块，放到图纸的空白处。
双击打开它，清空里面的代码，原封不动地复制粘贴以下代码：

matlab 复制代码

function force_export(SOC, Preq, Reward)
    % 声明这是一个不参与 C 代码编译的外部 MATLAB 调用
    coder.extrinsic('assignin'); 
    
    % 强行将这三个变量写入 MATLAB 的基础工作区 (Base Workspace)
    assignin('base', 'live_SOC', SOC);
    assignin('base', 'live_Preq', Preq);
    assignin('base', 'live_Reward', Reward);
end

连线：

这个模块现在有三个输入口：SOC、Preq、Reward。
把模型里实时计算出来的 SOC 信号、需求功率 Preq 信号、以及奖励 Reward 信号，分出一根线，对应连接到这三个输入口上。

保存模型。

（原理：Simulink 每跑一秒，经过这个模块时，就会无视一切缓冲机制，强制把这三个当前的瞬时标量砸进 MATLAB 的工作区里。）

恭喜！模型搭建完毕！

将这个模型保存为 HEV_RL_Env.slx。

为了确保你对刚刚搭建的这个强化学习环境的结构有绝对清晰的认知，我为你生成了一个交互式的架构蓝图。点击其中的模块，可以复习它们的功能和所需的 Simulink 组件。

第四阶段：Python 握手测试 (终极验证)

现在，确保 HEV_RL_Env.slx 关闭。在同一个文件夹下，打开你的 Python 编辑器（如 PyCharm/Jupyter），运行以下极简的测试代码。这能证明你的 Python 已经成功"劫持"了 Simulink！

python 复制代码

import matlab.engine
import time

print("正在启动 MATLAB 后台引擎...")
eng = matlab.engine.start_matlab()

print("正在加载初始化参数...")
eng.eval("init_hev_env", nargout=0)

model_name = 'HEV_RL_Env'
print(f"正在加载 Simulink 模型: {model_name}...")
eng.eval(f"load_system('{model_name}')", nargout=0)

# 确保模型处于停止状态
eng.set_param(model_name, 'SimulationCommand', 'stop', nargout=0)

print("\n--- 开始单步强化学习交互测试 ---")
for step in range(1, 6):
    action = 20000.0 + step * 5000 
    
    # 1. 注入动作
    eng.set_param(f'{model_name}/Constant', 'Value', str(action), nargout=0)
    
    # 2. 往前走 1 步
    eng.set_param(model_name, 'SimulationCommand', 'step', nargout=0)
    
    # 3. 等待这一步走完
    status = eng.get_param(model_name, 'SimulationStatus')
    while status not in ['paused', 'stopped']:
        time.sleep(0.01)
        status = eng.get_param(model_name, 'SimulationStatus')
    
    # 4. 【极简抓取】：直接从 Workspace 里拿走间谍扔出来的数据！
    current_soc = eng.workspace['live_SOC']
    current_preq = eng.workspace['live_Preq']
    current_reward = eng.workspace['live_Reward']
    
    print(f"第 {step} 秒 | 发动机: {action}W | 状态 [SOC: {current_soc:.4f}, Preq: {current_preq:.1f}] | 奖励: {current_reward:.2f}")

# 训练结束，关闭引擎
eng.set_param(model_name, 'SimulationCommand', 'stop', nargout=0)
eng.quit()
print("\n交互测试结束！强化学习底层通道已彻底打通！")

(注意：要让上面的 Python 代码完美抓到数据，你需要在 Simulink 的 Model Settings -> Data Import/Export 中，勾选 Time 和 Output，并将 Format 设为 Array。)

现在，这套系统完完全全是你的了。它没有多余的代码，没有黑盒，是一个绝对干净的强化学习试验场。如果 Python 报错连不上 MATLAB 引擎，请查阅 matlab.engine 的官方安装说明（通常是在 MATLAB 安装目录下的 extern/engines/python 执行 python setup.py install）。