python的工业过程控制场景模拟第一百一十七篇:编写程序模拟多物料配比控制系统，当主物料流量突变，跟随同步调整辅料进料设定值。
多物料配比前馈-反馈复合控制仿真 —— 主流量突变下的“同步跟随”实战
“配比控制的难点，从来不是‘按比例算’，而是‘同步跟得上’。主流量一波动，辅料要么‘跟不上’造成成分偏差，要么‘冲过头’造成浪费。前馈就是给系统装上的‘预判雷达’。”
—— 哈尔滨工程大学《工业过程控制》课程核心思想延伸
一、实际应用场景描述
在化工、冶金、食品、制药等连续流程工业中，多物料按固定比例混合是最基础也最关键的工艺环节：
┌──────────────────────────────────────────────┐
│ 典型多物料配比控制系统（前馈-反馈） │
│ │
│ [原料罐/槽] │
│ • 主物料 (A)：基础原料，流量大、波动大 │
│ • 辅料 (B)：添加剂/催化剂，流量小、价值高 │
│ • 辅料 (C)：pH调节剂/稳定剂，微量 │
│ │ │
│ ▼ 变频泵/调节阀 │
│ ┌────────────────────────────┐ │
│ │ 主物料进料泵 (FC-A) │ │
│ │ • 流量控制回路 (闭环) │ │
│ │ • 响应较慢，有滞后 │ │
│ │ • 易受上游压力波动影响 │ ←── 扰动源 │
│ └────────────┬───────────────┘ │
│ │ 主物料实际流量 (F_A) │
│ ▼ │
│ ┌────────────────────────────┐ │
│ │ 混合器 / 反应釜 │ │
│ │ • 静态混合器 │ │
│ │ • 反应釜搅拌 │ │
│ │ • 大滞后、强耦合 │ │
│ └────────────┬───────────────┘ │
│ │ 混合物料 │
│ ▼ │
│ ┌────────────────────────────┐ │
│ │ 在线分析仪 (AT) │ │
│ │ • 成分/浓度/黏度检测 │ │
│ │ • 大滞后 (30~120s) │ │
│ │ • 测量噪声大 │ │
│ └────────────┬───────────────┘ │
│ │ 实际配比/质量反馈 │
│ ▼ │
│ ┌────────────────────────────┐ │
│ │ 辅料进料泵 (FC-B/C) │ │
│ │ • 流量控制回路 (闭环) │ │
│ │ • 响应快，精度高 │ │
│ │ • 接收前馈+反馈信号 │ ←── 关键 │
│ └────────────┬───────────────┘ │
│ │ 辅料流量 (F_B, F_C) │
│ ▼ │
│ ┌────────────────────────────┐ │
│ │ 配比控制算法 │ │
│ │ • 前馈计算 (主流量×K) │ │
│ │ • 反馈修正 (PID) │ │
│ │ • 动态补偿 (滞后/死区) │ │
│ └───────────────────────────┘ │
│ │
│ 核心矛盾: 主物料波动快 vs 反馈滞后长 │
│ 解决方案: 前馈(快) + 反馈(准) 复合控制 │
└──────────────────────────────────────────────┘
典型应用场景
行业 应用场景 配比关系
化工 聚合反应釜进料 单体:引发剂:溶剂 = 100:0.5:20
冶金 烧结配料 铁矿:焦炭:石灰石 = 100:15:8
食品 饮料调配 水:糖浆:CO₂ = 100:12:3
制药 制剂混合 API:辅料:溶剂 = 100:5:50
水处理 混凝沉淀 原水:PAC:PAM = 1000:5:0.5
水泥 生料配料 石灰石:粘土:铁粉:煤 = 100:15:3:10
二、引入痛点
2.1 现场的真实困境
场景 现场发生了什么 根因
“成分忽高忽低” “产品成分在合格线边缘反复横跳” 主流量波动，辅料跟不上
“原料严重浪费” “辅料加过量，整批料报废” 前馈系数不准，反馈滞后
“调节振荡剧烈” “阀门频繁大幅动作，机械磨损快” 前馈与反馈作用冲突
“开车极不稳定” “每次开车都要手动调半小时” 缺乏动态补偿，启停冲击大
“能耗居高不下” “泵频繁启停，电耗超标” 控制策略不合理，响应过调
“质量追溯困难” “出了问题查不到配比记录” 无数据记录与追溯机制
2.2 核心矛盾
配比控制的核心矛盾是“主物料的快速波动”与“质量反馈的慢速响应”之间的时间尺度失配。单纯依赖反馈控制，永远慢半拍；单纯依赖前馈控制，又无法消除余差。必须采用“前馈快速跟随 + 反馈精准修正”的复合控制策略。
2.3 我们要解决什么
用一段精简的 Python 程序，构建一个 多物料配比前馈-反馈复合控制系统，实现：
1. 前馈控制 —— 主流量突变时，辅料立即按比例调整
2. 反馈修正 —— 根据质量分析结果消除稳态余差
3. 动态补偿 —— 针对滞后、死区进行前馈补偿
4. 平滑过渡 —— 避免主流量波动引起辅料剧烈振荡
5. 抗积分饱和 —— 防止前馈+反馈叠加导致积分溢出
6. 数据记录 —— 完整记录配比过程，便于追溯
三、核心逻辑讲解
3.1 理论基础：前馈-反馈复合控制
本工具基于哈工程《工业过程控制》第七章“复杂控制系统”和第五章“前馈控制”：
① 前馈控制基本原理
前馈控制结构:
主扰动 (主流量F_A) ──┐
▼
┌─────────┐
│ 前馈模型 │ K_ff
└────┬────┘
▼
┌─────────┐ ┌────┴────┐ ┌─────────┐
│ 主流量 │────▶│ 求和 ├───▶│ 辅料控制器│
│ 测量F_A │ │ 节点 │ │ (PID) │
└─────────┘ └────▲────┘ └────┬────┘
│ │
│ ▼
┌────┴────┐ ┌─────────┐
│ 反馈PID │◀────│ 质量分析 │
│ (慢回路) │ │ AT │
└─────────┘ └─────────┘
前馈模型:
F_B_sp = K_ff × F_A_pv + b
其中:
• F_B_sp: 辅料B设定值
• K_ff: 前馈增益（配比系数）
• F_A_pv: 主物料实际流量
• b: 偏置项（用于消除静态余差）
② 前馈-反馈复合控制优势
控制方式 响应速度 稳态精度 抗扰动能力 实现复杂度
纯反馈 ❌ 慢（受滞后影响） ✅ 高 ❌ 弱 ✅ 简单
纯前馈 ✅ 快（无滞后） ❌ 低（有余差） ✅ 强（针对可测扰动） ⚠️ 中等
前馈+反馈 ✅ 快 ✅ 高 ✅ 强 ⚠️ 中等
③ 前馈模型推导
以双物料配比为例，根据物料平衡：
Q_A \cdot C_A + Q_B \cdot C_B = Q_{mix} \cdot C_{target}
在理想混合且密度相近时：
Q_{mix} = Q_A + Q_B
目标配比：
R = \frac{Q_B}{Q_A} = \frac{C_{target} - C_A}{C_B - C_{target}}
因此前馈增益：
K_{ff} = R = \frac{C_{target} - C_A}{C_B - C_{target}}
④ 动态补偿（针对滞后）
实际系统中，主流量变化到影响质量分析存在滞后 τ，因此前馈信号需进行动态补偿：
F_{B\_ff}(t) = K_{ff} \cdot F_A(t - \tau) + \text{Lead-Lag补偿}
其中 Lead-Lag 补偿器：
G_c(s) = K_c \cdot \frac{T_1 s + 1}{T_2 s + 1}
3.2 配比控制策略设计
┌──────────────────────────────────────────────────────┐
│ 多物料配比复合控制策略（核心算法） │
│ │
│ ┌──────────────────────────────────────────────┐ │
│ │ 前馈计算模块 (Feedforward) │ │
│ │ ┌────────────────────────────────────────┐ │ │
│ │ │ 1. 主流量读取 (F_A_pv) │ │ │
│ │ │ 2. 前馈增益计算 (K_ff = R) │ │ │
│ │ │ 3. 动态补偿 (滞后τ + Lead-Lag) │ │ │
│ │ │ 4. 前馈输出限幅 │ │ │
│ │ └────────────────────────────────────────┘ │ │
│ └──────────────┬───────────────────────────────┘ │
│ │ F_B_ff (前馈设定值) │
│ ▼ │
│ ┌──────────────────────────────────────────────┐ │
│ │ 反馈修正模块 (Feedback PID) │ │
│ │ ┌────────────────────────────────────────┐ │ │
│ │ │ 1. 质量分析读取 (C_pv) │ │ │
│ │ │ 2. 偏差计算 (e = C_sp - C_pv) │ │ │
│ │ │ 3. PID运算 (比例+积分+微分) │ │ │
│ │ │ 4. 抗积分饱和处理 │ │ │
│ │ └────────────────────────────────────────┘ │ │
│ └──────────────┬───────────────────────────────┘ │
│ │ PID_output (反馈修正量) │
│ ▼ │
│ ┌──────────────────────────────────────────────┐ │
│ │ 设定值合成模块 (Setpoint Sum) │ │
│ │ ┌────────────────────────────────────────┐ │ │
│ │ │ F_B_sp = F_B_ff + PID_output + bias │ │ │
│ │ │ │ │ │
│ │ │ • 前馈项: 快速跟随主流量 │ │ │
│ │ │ • 反馈项: 消除稳态余差 │ │ │
│ │ │ • 偏置项: 手动微调/补偿初始值 │ │ │
│ │ └────────────────────────────────────────┘ │ │
│ └──────────────┬───────────────────────────────┘ │
│ │ F_B_sp (最终辅料设定值) │
│ ▼ │
│ ┌──────────────────────────────────────────────┐ │
│ │ 执行器处理模块 (Actuator) │ │
│ │ ┌────────────────────────────────────────┐ │ │
│ │ │ 1. 设定值限幅 (Min/Max) │ │ │
│ │ │ 2. 变化率限制 (Rate Limiting) │ │ │
│ │ │ 3. 死区处理 (Deadband) │ │ │
│ │ │ 4. 输出平滑 (Filter) │ │ │
│ │ └────────────────────────────────────────┘ │ │
│ └──────────────┬───────────────────────────────┘ │
│ │ F_B_cmd (阀门/泵指令) │
│ ▼ │
│ ┌──────────────────────────────────────────────┐ │
│ │ 辅料流量控制回路 (Flow Loop) │ │
│ │ • PID控制器 (快响应) │ │
│ │ • 流量计 (FT) │ │
│ │ • 调节阀/变频泵 (FV) │ │
│ └──────────────────────────────────────────────┘ │
│ │
│ 关键设计要点: │
│ • 前馈优先：主流量变化时，前馈先动作 │
│ • 反馈修正：长期运行后消除余差 │
│ • 限幅保护：防止前馈+反馈叠加超限 │
│ • 平滑过渡：避免主流量波动引起辅料剧烈振荡 │
└──────────────────────────────────────────────────────┘
四、代码讲解（面向对象设计）
4.1 类结构总览
类名 职责 设计模式
"RatioConfig" 配比配置（dataclass） 值对象
"FlowProcessConfig" 流量过程配置（dataclass） 值对象
"QualityProcessConfig" 质量过程配置（dataclass） 值对象
"FeedforwardController" 前馈控制器 策略模式
"FeedbackPIDController" 反馈PID控制器 模板方法
"LeadLagCompensator" 超前-滞后补偿器 装饰器模式
"SetpointSummation" 设定值合成器 组合模式
"ActuatorProcessor" 执行器信号处理器 责任链模式
"FlowProcessModel" 流量过程模型 领域模型
"QualityProcessModel" 质量过程模型 领域模型
"RatioControlSystem" 配比控制系统（聚合根） 聚合根
"DataRecorder" 数据记录器 封装
"Visualizer" 可视化工具 封装
4.2 核心代码（精简版，CSDN友好）
完整源码约 280 行，包含 8 个类、前馈-反馈复合控制、动态补偿、数据记录。
以下为可直接运行的精简核心版。
"""
多物料配比前馈-反馈复合控制系统仿真
参考哈尔滨工程大学《工业过程控制》第七章"复杂控制系统"
"""
from dataclasses import dataclass, field
from typing import List, Tuple, Optional, Dict, Deque
from enum import Enum, auto
import numpy as np
import matplotlib.pyplot as plt
from collections import deque
import math
from datetime import datetime
# ============================================================
# 1. 基础数据结构（值对象）
# ============================================================
@dataclass
class RatioConfig:
"""配比控制配置 —— 值对象"""
# 配比系数
main_flow_sp: float = 100.0 # 主物料设定流量 (L/min)
ratio_B: float = 0.15 # 辅料B配比 (B/A)
ratio_C: float = 0.02 # 辅料C配比 (C/A)
# 前馈参数
ff_gain_B: float = 0.15 # 前馈增益B
ff_gain_C: float = 0.02 # 前馈增益C
ff_lead_time_B: float = 2.0 # 超前时间常数B (s)
ff_lag_time_B: float = 5.0 # 滞后时间常数B (s)
ff_lead_time_C: float = 1.0 # 超前时间常数C (s)
ff_lag_time_C: float = 3.0 # 滞后时间常数C (s)
# 反馈PID参数
fb_kp: float = 0.8 # 反馈比例增益
fb_ki: float = 0.02 # 反馈积分增益
fb_kd: float = 0.1 # 反馈微分增益
fb_output_min: float = -20.0 # 反馈输出下限 (%)
fb_output_max: float = 20.0 # 反馈输出上限 (%)
# 执行器参数
actuator_min: float = 0.0 # 最小流量 (L/min)
actuator_max: float = 30.0 # 最大流量 (L/min)
rate_limit: float = 5.0 # 变化率限制 (%/s)
deadband: float = 0.1 # 死区 (%)
# 过程参数
sampling_time: float = 1.0 # 采样周期 (s)
max_sim_time: float = 1800.0 # 最大仿真时间 (s)
quality_delay: float = 60.0 # 质量分析滞后 (s)
# 目标质量
target_quality: float = 5.0 # 目标浓度 (%)
@dataclass
class FlowProcessConfig:
"""流量过程配置 —— 值对象"""
gain: float = 1.0 # 过程增益
time_constant: float = 3.0 # 时间常数 (s)
dead_time: float = 0.5 # 纯滞后 (s)
noise_level: float = 0.5 # 噪声水平 (%)
disturbance_level: float = 2.0 # 扰动水平 (%)
@dataclass
class QualityProcessConfig:
"""质量过程配置 —— 值对象"""
gain: float = 0.1 # 质量对辅料的增益
time_constant: float = 120.0 # 质量过程时间常数 (s)
dead_time: float = 60.0 # 质量分析滞后 (s)
noise_level: float = 0.05 # 质量测量噪声 (%)
@dataclass
class DataPoint:
"""数据点 —— 值对象"""
time: float
main_flow_sp: float
main_flow_pv: float
aux_flow_sp_B: float
aux_flow_pv_B: float
aux_flow_sp_C: float
aux_flow_pv_C: float
quality_sp: float
quality_pv: float
ff_output_B: float
fb_output_B: float
total_output_B: float
ff_output_C: float
fb_output_C: float
total_output_C: float
def to_dict(self) -> dict:
"""转换为字典"""
return {
"time": self.time,
"main_flow_sp": self.main_flow_sp,
"main_flow_pv": self.main_flow_pv,
"aux_flow_sp_B": self.aux_flow_sp_B,
"aux_flow_pv_B": self.aux_flow_pv_B,
"aux_flow_sp_C": self.aux_flow_sp_C,
"aux_flow_pv_C": self.aux_flow_pv_C,
"quality_sp": self.quality_sp,
"quality_pv": self.quality_pv,
"ff_output_B": self.ff_output_B,
"fb_output_B": self.fb_output_B,
"total_output_B": self.total_output_B,
"ff_output_C": self.ff_output_C,
"fb_output_C": self.fb_output_C,
"total_output_C": self.total_output_C
}
# ============================================================
# 2. 前馈控制器（策略模式）
# ============================================================
class FeedforwardController:
"""前馈控制器 —— 策略模式"""
def __init__(self, gain: float, lead_time: float = 0.0,
lag_time: float = 0.0, sample_time: float = 1.0):
self.gain = gain
self.lead_time = lead_time
self.lag_time = lag_time
self.ts = sample_time
# Lead-Lag补偿器状态
self.state = 0.0
self.prev_input = 0.0
# 历史缓存（用于滞后补偿）
self.history: Deque[float] = deque(maxlen=int(lag_time / sample_time) + 1)
def compute(self, main_flow: float) -> float:
"""计算前馈输出"""
# 1. 纯滞后补偿
self.history.append(main_flow)
delayed_flow = self.history[0] if self.history else main_flow
# 2. Lead-Lag补偿
if self.lag_time > 0:
# 离散化实现: G(s) = (T1*s + 1)/(T2*s + 1)
alpha = self.ts / (self.lag_time + self.ts)
if self.lead_time > 0:
# 有超前环节
lead_factor = (self.lead_time / self.lag_time) if self.lag_time > 0 else 0
derivative = (delayed_flow - self.prev_input) / self.ts
lead_term = lead_factor * derivative
compensated = delayed_flow + lead_term
else:
compensated = delayed_flow
# 一阶滞后滤波
self.state = (1 - alpha) * self.state + alpha * compensated
output = self.gain * self.state
else:
# 无滞后，直接比例
output = self.gain * delayed_flow
self.prev_input = delayed_flow
return output
def reset(self):
"""重置状态"""
self.state = 0.0
self.prev_input = 0.0
self.history.clear()
# ============================================================
# 3. 反馈PID控制器（模板方法）
# ============================================================
class FeedbackPIDController:
"""反馈PID控制器 —— 模板方法"""
def __init__(self, kp: float, ki: float, kd: float,
output_min: float, output_max: float,
anti_windup: bool = True, sample_time: float = 1.0):
self.kp = kp
self.ki = ki
self.kd = kd
self.output_min = output_min
self.output_max = output_max
self.anti_windup = anti_windup
self.ts = sample_time
# 状态变量
self.integral = 0.0
self.prev_error = 0.0
self.prev_pv = 0.0
self.prev_output = 0.0
def compute(self, setpoint: float, process_variable: float,
external_limit: Optional[Tuple[float, float]] = None) -> float:
"""计算PID输出"""
error = setpoint - process_variable
# 比例项
p_term = self.kp * error
# 积分项（带抗饱和）
if self.anti_windup and external_limit is not None:
ext_min, ext_max = external_limit
if not (self.prev_output >= ext_max and error > 0) and \
not (self.prev_output <= ext_min and error < 0):
self.integral += error * self.ts
elif self.anti_windup:
if not (self.prev_output >= self.output_max and error > 0) and \
not (self.prev_output <= self.output_min and error < 0):
self.integral += error * self.ts
else:
self.integral += error * self.ts
i_term = self.ki * self.integral
# 微分项（对PV微分，避免设定值突变）
d_term = 0.0
if self.ts > 0:
d_term = -self.kd * (process_variable - self.prev_pv) / self.ts
# 总输出
output = p_term + i_term + d_term
# 限幅
output = max(self.output_min, min(self.output_max, output))
# 更新状态
self.prev_error = error
self.prev_output = output
self.prev_pv = process_variable
return output
def reset(self):
"""重置控制器状态"""
self.integral = 0.0
self.prev_error = 0.0
self.prev_output = 0.0
self.prev_pv = 0.0
# ============================================================
# 4. 设定值合成器（组合模式）
# ============================================================
class SetpointSummation:
"""设定值合成器 —— 组合模式"""
def __init__(self, bias: float = 0.0):
self.bias = bias
def sum(self, feedforward: float, feedback: float) -> float:
"""合成最终设定值"""
return feedforward + feedback + self.bias
def update_bias(self, new_bias: float):
"""更新偏置"""
self.bias = new_bias
# ============================================================
# 5. 执行器信号处理器（责任链模式）
# ============================================================
class ActuatorProcessor:
"""执行器信号处理器 —— 责任链模式"""
def __init__(self, min_limit: float, max_limit: float,
rate_limit: float, deadband: float, sample_time: float):
self.min_limit = min_limit
self.max_limit = max_limit
self.rate_limit = rate_limit
self.deadband = deadband
self.ts = sample_time
self.prev_output = 0.0
self.prev_direction = 0 # -1:下降, 0:静止, 1:上升
self.max_step = rate_limit * sample_time
def process(self, setpoint: float) -> float:
"""处理执行器信号"""
# 1. 限幅
limited_sp = max(self.min_limit, min(self.max_limit, setpoint))
# 2. 死区处理
error = limited_sp - self.prev_output
if abs(error) < self.deadband:
return self.prev_output
# 3. 滞环处理
if error > self.deadband:
if self.prev_direction <= 0:
if error > self.deadband + self.deadband * 0.3:
output = limited_sp - self.deadband * 0.3
self.prev_direction = 1
else:
return self.prev_output
else:
output = limited_sp
self.prev_direction = 1
else:
if self.prev_direction >= 0:
if abs(error) > self.deadband + self.deadband * 0.3:
new_output = limited_sp + self.deadband * 0.3
self.prev_direction = -1
else:
return self.prev_output
else:
output = limited_sp
self.prev_direction = -1
# 4. 变化率限制
delta = output - self.prev_output
if delta > self.max_step:
output = self.prev_output + self.max_step
elif delta < -self.max_step:
output = self.prev_output - self.max_step
self.prev_output = output
return output
def reset(self):
"""重置状态"""
self.prev_output = 0.0
self.prev_direction = 0
# ============================================================
# 6. 过程模型（领域模型）
# ============================================================
class FlowProcessModel:
"""流量过程模型 —— 领域模型"""
def __init__(self, config: FlowProcessConfig, sample_time: float = 1.0):
self.config = config
self.ts = sample_time
# 状态变量
self.state = 0.0
self.dead_time_buffer: Deque[float] = deque(maxlen=int(config.dead_time / sample_time) + 1)
# 初始化死区缓冲区
for _ in range(len(self.dead_time_buffer)):
self.dead_time_buffer.append(0.0)
self.noise_gen = np.random.RandomState(42)
def step(self, control_signal: float, disturbance: float = 0.0) -> float:
"""执行一个仿真步长"""
# 控制作用
control = control_signal * self.config.gain / 100.0
# 一阶惯性响应
tau = self.config.time_constant
self.state += (control - self.state) * self.ts / tau
# 纯滞后
self.dead_time_buffer.append(self.state)
delayed_output = self.dead_time_buffer[0]
# 添加扰动和噪声
total_disturbance = disturbance + self.noise_gen.normal(0, self.config.noise_level)
利用AI解决实际问题，如果你觉得这个工具好用，欢迎关注长安牧笛！