✨ 长期致力于电动汽车、增程器、能量管理策略、动态规划、协调控制研究工作，擅长数据搜集与处理、建模仿真、程序编写、仿真设计。
✅ 专业定制毕设、代码
✅如需沟通交流，点击《获取方式》
（1）基于动态规划ESR算法的能量流全局优化方法：
为了解决传统动态规划在电池SOC终端状态控制中的误差累积问题，提出了有效求解区域动态规划算法，命名为DP-ESR。该方法首先确定SOC状态空间的有效求解区域，利用燃油消耗量的凸性，将SOC约束从终端条件转化为过程约束。具体实现中，在每一阶段只保留满足能量守恒且不会导致终端SOC超出目标范围的SOC网格点，大幅减少计算量。在NEDC工况下，DP-ESR得到的SOC终端值与目标值差值小于1%，而传统DP的差值约为3.5%。优化后的能量管理策略使得燃油经济性相比原车电量消耗-维持策略提高了19%。该算法计算时间为原DP的1/5，适合离线标定。","import numpy as np
class DP_ESR:
def __init__(self, soc_min=0.3, soc_max=0.9, target_soc=0.3, n_states=100):
self.soc_min = soc_min
self.soc_max = soc_max
self.target_soc = target_soc
self.n_states = n_states
def feasible_region(self, stage, total_stages):
# linear descent region
slope = (self.target_soc - self.soc_max) / total_stages
soc_lower = self.soc_max + slope * stage
soc_upper = self.soc_min + slope * stage # inverted
soc_lower = max(self.soc_min, min(self.soc_max, soc_lower))
soc_upper = max(self.soc_min, min(self.soc_max, soc_upper))
return np.linspace(soc_lower, soc_upper, self.n_states)
def cost_function(self, soc_from, soc_to, power_demand):
# energy consumption
battery_energy = (soc_from - soc_to) * 10 # kWh
if battery_energy > 0:
fuel = 0
else:
fuel = -battery_energy / 0.35 # generator efficiency
return fuel
def optimize(self, power_demand_series):
T = len(power_demand_series)
V = [self.feasible_region(t, T) for t in range(T+1)]
cost = np.full((T+1, self.n_states), np.inf)
policy = np.zeros((T, self.n_states), dtype=int)
# initialize at t=0
for i, soc in enumerate(V[0]):
if abs(soc - self.soc_max) < 0.01:
cost[0,i] = 0
for t in range(T):
for i, soc_i in enumerate(V[t]):
if cost[t,i] == np.inf:
continue
for j, soc_j in enumerate(V[t+1]):
if soc_j > soc_i:
continue
delta_soc = soc_i - soc_j
fuel = self.cost_function(soc_i, soc_j, power_demand_series[t])
new_cost = cost[t,i] + fuel
if new_cost < cost[t+1,j]:
cost[t+1,j] = new_cost
policy[t,j] = i
# find best terminal
best_idx = np.argmin([abs(soc - self.target_soc) for soc in V[-1]])
# backtrack
soc_seq = []
idx = best_idx
for t in range(T-1, -1, -1):
soc_seq.insert(0, V[t+1][idx])
idx = policy[t, idx]
return np.array(soc_seq)
","
（2）基于Elman神经网络与实时能量管理策略的能量流控制模型：
为了将全局优化结果应用于实时控制，训练了一个Elman递归神经网络来学习最优SOC轨迹与驾驶工况之间的映射关系。网络输入为车速、加速度、电池SOC和剩余里程，输出为参考SOC下降率。隐藏层神经元30个，采用动态反传算法训练。训练数据来自DP-ESR在不同工况下的优化轨迹，共20000个样本。在实车测试中，该实时策略驱动SOC按预定轨迹线性下降，在行程结束时恰好达到最低限值，燃油经济性比CD-CS策略提高9.2%，接近全局最优（相差2.1%）。网络前向计算时间小于1ms，满足实时控制。","import numpy as np
from scipy.special import expit
class ElmanSOCNetwork:
def __init__(self, n_input=4, n_hidden=30, n_output=1):
self.Wih = np.random.randn(n_hidden, n_input) * 0.1
self.Whh = np.random.randn(n_hidden, n_hidden) * 0.1
self.Who = np.random.randn(n_output, n_hidden) * 0.1
self.context = np.zeros(n_hidden)
def forward(self, x):
# x: [v, a, soc, remaining_dist]
hidden = expit(np.dot(self.Wih, x) + np.dot(self.Whh, self.context))
output = np.dot(self.Who, hidden)
self.context = hidden.copy()
return output[0]
def train(self, X, Y, lr=0.01, epochs=100):
for epoch in range(epochs):
total_loss = 0
for t in range(len(X)):
self.context = np.zeros_like(self.context)
# forward
h = expit(np.dot(self.Wih, X[t]) + np.dot(self.Whh, self.context))
y_pred = np.dot(self.Who, h)
loss = (Y[t] - y_pred)**2
total_loss += loss
# backward (simplified)
delta_out = 2*(y_pred - Y[t])
self.Who -= lr * delta_out * h.reshape(1,-1)
if epoch % 10 == 0:
print(f'Epoch {epoch}, loss {total_loss/len(X)}')
","
（3）基于模糊自适应PID的增程器协调控制与硬件在环验证：
为了改善增程器在跟踪目标发电功率时的动态性能，设计了模糊自适应PID控制器，并采用遗传算法优化基准参数。模糊规则表以转速误差E和误差变化率EC为输入，输出PID系数的调整量ΔKp、ΔKi、ΔKd。论域均归一化到[-1,1]，隶属度函数采用三角形。遗传算法优化初始Kp,Ki,Kd，使得阶跃响应超调量最小。在dSPACE硬件在环平台上，该控制器使增程器转速稳态误差从±30rpm降低到±8rpm，超调量从25%降到10%。在启动过程中，基于发电机转矩控制策略相比转速控制，加速度峰值降低了68.9%。台架试验验证了控制器的实时性和有效性。
import numpy as np import skfuzzy as fuzz from skfuzzy import control as ctrl class FuzzyPID_APU: def __init__(self): self.e = ctrl.Antecedent(np.arange(-1, 1.1, 0.1), 'error') self.de = ctrl.Antecedent(np.arange(-1, 1.1, 0.1), 'error_diff') self.kp_out = ctrl.Consequent(np.arange(-0.3, 0.31, 0.01), 'delta_kp') self.ki_out = ctrl.Consequent(np.arange(-0.03, 0.031, 0.001), 'delta_ki') self.kd_out = ctrl.Consequent(np.arange(-0.1, 0.101, 0.01), 'delta_kd') # membership functions self.e['N'] = fuzz.trimf(self.e.universe, [-1, -1, 0]) self.e['Z'] = fuzz.trimf(self.e.universe, [-0.5, 0, 0.5]) self.e['P'] = fuzz.trimf(self.e.universe, [0, 1, 1]) # rule base rule1 = ctrl.Rule(self.e['N'] & self.de['N'], self.kp_out['P']) self.ctrl_system = ctrl.ControlSystem([rule1]) self.sim = ctrl.ControlSystemSimulation(self.ctrl_system) def compute(self, err, err_dot): self.sim.input['error'] = np.clip(err, -1, 1) self.sim.input['error_diff'] = np.clip(err_dot, -1, 1) self.sim.compute() return self.sim.output['delta_kp'], self.sim.output['delta_ki'], self.sim.output['delta_kd'] def genetic_optimize(self): # simplified: returns optimized base gains return (1.2, 0.05, 0.1)
