Python 模拟执行器滞环特性：测试控制算法对阀门卡涩的适配能力

“现场最头疼的不是 PID 参数整定，而是阀门卡涩。明明输出在变，阀位却不动，等积够了‘死区能量’突然一跳，系统直接振荡——这就是执行器滞环在作祟。”

—— 参考哈尔滨工程大学《工业过程控制》第 4 章“执行机构特性”与第 5 章“PID 控制”

一、实际应用场景描述

在石化、化工、热电、制药等流程工业中，控制阀是控制回路的最终执行元件。由于机械摩擦、填料压紧、介质结垢等原因，阀门普遍存在滞环（Hysteresis）与死区（Deadband）特性：

┌──────────────────────────────────────────────────────┐

│ 执行器滞环特性测试系统架构 │

│ │

│ [控制算法输出 u(k)] │

│ │ │

│ ▼ │

│ ┌────────────────────────────┐ │

│ │ 滞环+死区模型（核心） │ │

│ │ • 死区宽度 DB │ │

│ │ • 滞环宽度 H │ │

│ │ • 卡涩位置随机变化 │ │

│ │ • 摩擦非线性 │ │

│ └──────────────┬─────────────┘ │

│ ▼ │

│ ┌────────────────────────────┐ │

│ │ 实际阀位 PV_actual │ │

│ │ • 机械限位 │ │

│ │ • 定位器反馈 │ │

│ └──────────────┬─────────────┘ │

│ ▼ │

│ ┌────────────────────────────┐ │

│ │ 被控对象（过程模型） │ │

│ │ • 一阶惯性/积分环节 │ │

│ │ • 纯滞后环节 │ │

│ └──────────────┬─────────────┘ │

│ ▼ │

│ ┌────────────────────────────┐ │

│ │ 过程变量 PV │ │

│ │ • 温度/压力/液位/流量 │ │

│ └────────────────────────────┘ │

│ │

│ 典型滞环来源: │

│ • 阀杆填料过紧（最常见） │

│ • 阀座结垢或介质结晶 │

│ • 定位器反馈连杆松动 │

│ • 气动薄膜老化，刚度不足 │

│ • 高温下金属膨胀卡涩 │

└──────────────────────────────────────────────────────┘

典型应用工况

工况 滞环表现 对控制的影响

低温甲醇洗 低温下阀杆收缩卡涩，滞环达 8% 液位控制持续振荡

锅炉给水 高温高压，填料热膨胀，滞环 3–5% 汽包水位小幅波动

聚合反应釜 聚合物粘在阀杆上，滞环随时间增大 温度控制响应滞后

脱硫塔液位 浆液结垢，滞环 + 死区复合 液位大幅波动

老装置改造 阀门年久失修，滞环可达 10% 以上 常规 PID 无法稳定

二、引入痛点

2.1 现场真实困境

场景 现场反馈 根因

“阀在抖” “输出在 48%–52% 来回变，阀位就是不动” 滞环 + 控制器高频小幅修正

“一跳就超” “憋久了突然一跳，直接超调 20%” 滞环能量积累后的突变

“整定无效” “放大比例就抖，放小了又不动” 未考虑执行器非线性

“换了还卡” “新阀装上去三个月又卡了” 介质特性导致，非阀门质量问题

“查不出” “趋势上看不出问题，就是稳不住” 滞环在趋势上表现为“平线”

“标准难定” “厂家说滞环≤2%，现场测出来 8%” 测试条件与实际工况不符

2.2 核心矛盾

控制算法的核心矛盾是“控制精度”与“执行器非线性”之间的不匹配。

标准 PID 假设执行器是理想比例环节，而实际阀门存在滞环、死区、摩擦等强非线性——这种不匹配是导致现场 60% 以上控制回路振荡的根本原因。

2.3 三种解决方案对比

方案 核心思想 优势 劣势

PID 参数弱化 降低增益、加长积分时间 简单、无需改造 牺牲控制性能，响应变慢

阀门维护 调整填料、清洗阀座 治本、效果最好 成本高、需停车、无法根治

算法适配滞环 在控制算法中补偿滞环 不改动硬件、效果明显 算法复杂、需精确建模

三、核心逻辑讲解

3.1 理论基础：执行器滞环特性

参考哈工程《工业过程控制》第 4 章“执行机构”，阀门滞环是典型的非线性环节：

滞环+死区模型:

u(k) ↑

│

H/2 │ ／← 正向（开阀方向）

│ ／

│ ／

│ ／

DB/2 │╱─────────────→ 正向死区

│

│

-DB/2 │─────────────╲→ 反向死区

│ ╲

│ ╲

-H/2 │ ╲← 反向（关阀方向）

│

└────────────────────────→ y(k)

数学描述:

正向: y(k) = u(k) - DB/2, 当 u(k) > u_prev + DB/2

反向: y(k) = u(k) + DB/2, 当 u(k) < u_prev - DB/2

保持: y(k) = y(k-1), 否则

其中:

• u(k): 控制器输出（0–100%）

• y(k): 实际阀位（0–100%）

• DB: 死区宽度（Deadband）

• H: 滞环宽度（Hysteresis）

• u_prev: 上一次动作时的输出值

3.2 滞环对控制的影响机制

滞环导致振荡的机制:

┌─────────────────────────────────────────────────────┐

│ │

│ 控制器输出 u(k) 小幅增加 │

│ │ │

│ ▼ │

│ 阀门在死区内 → 阀位 y(k) 不变 │

│ │ │

│ ▼ │

│ 误差 e(k) = SP - PV 持续存在 │

│ │ │

│ ▼ │

│ 控制器继续增加输出（积分累积） │

│ │ │

│ ▼ │

│ 输出突破滞环阈值 → 阀位突然跳变 │

│ │ │

│ ▼ │

│ 过程变量 PV 快速变化 → 超调 │

│ │ │

│ ▼ │

│ 控制器反向调节 → 再次陷入滞环 │

│ │ │

│ ▼ │

│ 循环往复 → 极限环振荡（Limit Cycle） │

└─────────────────────────────────────────────────────┘

工程经验:

• 滞环宽度 H > 2% 时，标准 PID 开始出现可见振荡

• 滞环宽度 H > 5% 时，常规 PID 难以稳定

• 死区 DB 与滞环 H 叠加，效果更严重

3.3 滞环自适应 PID 算法

滞环自适应 PID 核心思想:

1. 检测滞环状态:

• 输出变化但阀位不变 → 滞环区

• 输出突破阈值 → 滞环边界

2. 滞环区内的控制策略:

• 停止积分累积（防止能量积累）

• 降低比例增益（减少输出波动）

• 或保持输出不变（等待突破）

3. 突破滞环后的控制策略:

• 恢复标准 PID

• 适当加强微分（抑制超调）

4. 滞环参数在线估计:

• 统计输出变化量与阀位变化量的关系

• 动态更新滞环宽度 H 和死区 DB

算法伪代码:

if |u(k) - u(k-1)| < threshold and |y(k) - y(k-1)| == 0:

# 滞环区

integral = integral # 停止积分

kp_adapted = kp * 0.5 # 降低增益

else:

# 正常区

integral += error * dt

kp_adapted = kp

本程序采用简化策略: 滞环区保持输出，避免无效动作

四、代码讲解（面向对象设计）

4.1 类结构总览

类名 职责 设计模式

"ActuatorState" 执行器状态枚举 枚举类型

"ActuatorConfig" 执行器参数配置 值对象

"ActuatorModel" 滞环+死区模型 策略模式

"PIDController" 标准 PID 算法 单一职责

"AdaptivePIDController" 滞环自适应 PID 装饰器模式

"ProcessModel" 被控过程模型 工厂模式

"HysteresisTester" 滞环测试与对比 聚合根

4.2 完整源代码（单文件，约 300 行）

直接复制下方代码保存为

"actuator_hysteresis_test.py" 即可运行，仅需 Python 3.8+ 标准库。

<details>

<summary></summary>

"""

执行器滞环特性模拟与滞环自适应 PID 测试

参考: 哈尔滨工程大学《工业过程控制》第4章"执行机构"、第5章"PID控制"

作者: 工业控制与上位机开发工程师

适用: CSDN技术博客完整发布版(单文件, ~300行)

"""

import enum

import dataclasses

import logging

import random

from typing import List, Optional

from dataclasses import dataclass, field

# ============================================================

# 1. 基础枚举与值对象

# ============================================================

class ActuatorState(enum.Enum):

"""执行器状态"""

STICKING = "卡涩中" # 输出变化但阀位不动

MOVING_UP = "开阀" # 正向动作

MOVING_DOWN = "关阀" # 反向动作

STEADY = "稳定" # 无变化

@dataclass(frozen=True)

class ActuatorConfig:

"""

执行器（控制阀）配置 —— 值对象

参考哈工程《工业过程控制》第4章:

- 理想执行器: 滞环≤1%, 死区≤0.5%

- 一般工业阀: 滞环≤2%, 死区≤1%

- 现场问题阀: 滞环可达5–10%

"""

deadband: float = 1.0 # 死区宽度 (%)

hysteresis: float = 3.0 # 滞环宽度 (%)

max_position: float = 100.0 # 最大阀位

min_position: float = 0.0 # 最小阀位

stick_slip_random: bool = True # 是否启用随机卡涩

stick_prob: float = 0.3 # 随机卡涩概率

def __post_init__(self):

if self.deadband < 0 or self.hysteresis < 0:

raise ValueError("死区和滞环宽度必须非负")

if self.deadband >= self.hysteresis:

logging.warning("死区宽度接近或超过滞环宽度，模型可能异常")

@dataclass

class ActuatorStateRecord:

"""执行器状态记录 —— 值对象"""

timestamp: float

controller_output: float

actual_position: float

target_position: float

actuator_state: ActuatorState

error: float

in_hysteresis: bool

# ============================================================

# 2. 执行器滞环模型（策略模式）

# ============================================================

class ActuatorModel:

"""

执行器滞环+死区模型

实现哈工程教材第4章描述的滞环特性:

- 死区: 输出变化小于阈值时阀位不变

- 滞环: 正向与反向动作阈值不同

- 随机卡涩: 模拟现场不确定性

参考: 哈工程《工业过程控制》§4.2 "执行机构特性"

"""

def __init__(self, config: ActuatorConfig):

self.config = config

self._position: float = 50.0 # 初始阀位50%

self._last_moving_output: float = 50.0 # 上次动作时的输出

self._last_direction: int = 0 # 1=开阀, -1=关阀, 0=静止

self._stick_count: int = 0

logging.info(f"[执行器模型] 初始化, 死区={config.deadband}%, "

f"滞环={config.hysteresis}%")

def update(self, controller_output: float) -> ActuatorStateRecord:

"""

更新执行器状态，返回当前状态记录

核心算法: 滞环+死区非线性模型

"""

target = controller_output

current = self._position

# 计算输出变化

delta_output = target - self._last_moving_output

# 滞环判定阈值

deadband_half = self.config.deadband / 2.0

hysteresis_half = self.config.hysteresis / 2.0

# 随机卡涩模拟（现场不确定性）

is_sticking = False

if self.config.stick_slip_random:

if random.random() < self.config.stick_prob:

is_sticking = True

self._stick_count += 1

# 滞环+死区逻辑

new_position = current

state = ActuatorState.STEADY

in_hysteresis = True

if is_sticking:

# 随机卡涩：输出变化但阀位不动

state = ActuatorState.STICKING

new_position = current # 保持不动

elif delta_output > deadband_half + hysteresis_half:

# 正向突破滞环（开阀方向）

new_position = target - deadband_half

state = ActuatorState.MOVING_UP

in_hysteresis = False

self._last_moving_output = target

self._last_direction = 1

elif delta_output < -deadband_half - hysteresis_half:

# 反向突破滞环（关阀方向）

new_position = target + deadband_half

state = ActuatorState.MOVING_DOWN

in_hysteresis = False

self._last_moving_output = target

self._last_direction = -1

elif abs(delta_output) <= deadband_half:

# 死区内：保持不动

state = ActuatorState.STEADY

new_position = current

in_hysteresis = True

else:

# 滞环区内：保持当前位置（卡涩）

state = ActuatorState.STICKING

new_position = current

in_hysteresis = True

# 限幅

new_position = max(self.config.min_position,

min(self.config.max_position, new_position))

# 更新位置

self._position = new_position

return ActuatorStateRecord(

timestamp=0.0, # 由外部设置

controller_output=controller_output,

actual_position=new_position,

target_position=target,

actuator_state=state,

error=target - new_position,

in_hysteresis=in_hysteresis

)

@property

def position(self) -> float:

return self._position

@property

def stick_count(self) -> int:

return self._stick_count

# ============================================================

# 3. 标准 PID 控制器（单一职责）

# ============================================================

class PIDController:

"""

标准 PID 控制器

离散位置式 PID，参考哈工程《工业过程控制》§5.1

"""

def __init__(self, kp: float = 1.0, ki: float = 0.1, kd: float = 0.05,

output_min: float = 0.0, output_max: float = 100.0):

self.kp = kp

self.ki = ki

self.kd = kd

self.output_min = output_min

self.output_max = output_max

self._integral: float = 0.0

self._prev_error: float = 0.0

self._first_run: bool = True

logging.info(f"[PID控制器] 初始化, Kp={kp}, Ki={ki}, Kd={kd}")

def reset(self):

"""复位控制器状态"""

self._integral = 0.0

self._prev_error = 0.0

self._first_run = True

def compute(self, pv: float, sp: float, dt: float) -> float:

"""计算 PID 输出"""

error = sp - pv

# 比例项

p_term = self.kp * error

# 积分项（抗饱和）

if not self._first_run:

self._integral += error * dt

# 抗饱和：输出限幅时停止积分

proposed = p_term + self.ki * self._integral

if proposed > self.output_max:

self._integral -= error * dt

elif proposed < self.output_min:

self._integral -= error * dt

i_term = self.ki * self._integral

# 微分项（对 PV 微分，避免设定值冲击）

if self._first_run:

d_term = 0.0

else:

d_pv = -(pv - self._prev_error) / dt # 对 PV 微分

d_term = self.kd * d_pv

# 总输出

output = p_term + i_term + d_term

# 限幅

output = max(self.output_min, min(self.output_max, output))

# 保存状态

self._prev_error = error

self._first_run = False

return output

# ============================================================

# 4. 滞环自适应 PID 控制器（装饰器模式）

# ============================================================

class AdaptivePIDController:

"""

滞环自适应 PID 控制器

在滞环区内采用特殊策略，避免无效动作和振荡

策略:

1. 滞环区内：保持输出，停止积分累积

2. 突破滞环：恢复标准 PID

3. 随机卡涩：降低增益，避免抖动

"""

def __init__(self, base_pid: PIDController,

hysteresis_threshold: float = 2.0):

self.base_pid = base_pid

self.hysteresis_threshold = hysteresis_threshold

self._in_hysteresis_zone: bool = False

self._last_output: float = 50.0

self._hold_output: float = 50.0

logging.info(f"[自适应PID] 初始化, 滞环阈值={hysteresis_threshold}%")

def reset(self):

"""复位控制器"""

self.base_pid.reset()

self._in_hysteresis_zone = False

self._last_output = 50.0

self._hold_output = 50.0

def compute(self, pv: float, sp: float, dt: float,

actuator_in_hysteresis: bool,

actuator_state: ActuatorState) -> float:

"""

滞环自适应 PID 计算

参数:

actuator_in_hysteresis: 执行器是否处于滞环区

actuator_state: 执行器当前状态

"""

# 滞环区判定

if actuator_in_hysteresis or actuator_state == ActuatorState.STICKING:

if not self._in_hysteresis_zone:

# 刚进入滞环区：保持当前输出

self._hold_output = self._last_output

self._in_hysteresis_zone = True

logging.debug(f"[自适应PID] 进入滞环区，保持输出={self._hold_output:.2f}")

# 滞环区内：保持输出，避免无效动作

# 注意：不调用 base_pid.compute()，避免积分累积

return self._hold_output

else:

# 突破滞环：恢复标准 PID

if self._in_hysteresis_zone:

logging.debug(f"[自适应PID] 突破滞环，恢复PID调节")

self._in_hysteresis_zone = False

# 正常 PID 计算

output = self.base_pid.compute(pv, sp, dt)

self._last_output = output

return output

# ============================================================

# 5. 被控过程模型（工厂模式）

# ============================================================

class ProcessModel:

"""

被控过程模型（一阶惯性+纯滞后）

参考哈工程《工业过程控制》§2.3 "过程动态特性"

"""

def __init__(self, gain: float = 1.0, time_constant: float = 10.0,

dead_time: float = 2.0, sample_time: float = 1.0):

self.gain = gain

self.time_constant = time_constant

self.dead_time = dead_time

self.sample_time = sample_time

self._state: float = 50.0 # 初始值

self._delay_buffer: List[float] = []

delay_steps = int(dead_time / sample_time)

self._delay_buffer = [50.0] * (delay_steps + 1)

logging.info(f"[过程模型] 初始化, K={gain}, T={time_constant}s, τ={dead_time}s")

def update(self, valve_position: float) -> float:

"""

更新过程状态，返回过程变量 PV

"""

# 纯滞后环节

delayed_input = self._delay_buffer.pop(0)

self._delay_buffer.append(valve_position)

# 一阶惯性环节: T·dy/dt + y = K·u

# 离散化: y(k) = y(k-1) + (K·u - y(k-1))·dt/T

dt = self.sample_time

T = self.time_constant

K = self.gain

self._state = self._state + (K * delayed_input - self._state) * dt / T

# 加入测量噪声（模拟现场）

import random

noise = random.gauss(0, 0.2)

return self._state + noise

# ============================================================

# 6. 滞环测试与对比（聚合根）

# ============================================================

class HysteresisTester:

"""

执行器滞环特性测试与对比工具

对比:

1. 标准 PID + 滞环执行器

2. 自适应 PID + 滞环执行器

"""

def __init__(self):

self.results_standard: List[dict] = []

self.results_adaptive: List[dict] = []

def run_test(self, steps: int = 200):

"""运行对比测试"""

logging.basicConfig(

level=logging.INFO,

format="%(asctime)s [%(levelname)s] %(message)s",

datefmt="%H:%M:%S",

)

print("=" * 70)

print(" 执行器滞环特性与自适应 PID 对比测试")

print(" 参考: 哈尔滨工程大学《工业过程控制》")

print("=" * 70)

# 配置

actuator_config = ActuatorConfig(

deadband=1.0,

hysteresis=4.0, # 严重滞环

stick_slip_random=True,

stick_prob=0.2

)

# 创建执行器模型

actuator = ActuatorModel(actuator_config)

# 创建 PID 控制器

pid_standard = PIDController(kp=1.5, ki=0.1, kd=0.05)

pid_adaptive = AdaptivePIDController(

PIDController(kp=1.5, ki=0.1, kd=0.05),

hysteresis_threshold=2.0

)

# 创建过程模型

process = ProcessModel(gain=1.0, time_constant=15.0,

dead_time=2.0, sample_time=1.0)

# 设定值

sp = 55.0 # 从50%阶跃到55%

print("\n【测试配置】")

print(f" 执行器滞环: {actuator_config.hysteresis}%")

print(f" 执行器死区: {actuator_config.deadband}%")

print(f" 随机卡涩概率: {actuator_config.stick_prob*100}%")

print(f" 过程模型: 一阶惯性+纯滞后 (T=15s, τ=2s)")

print(f" 设定值阶跃: 50% → 55%")

print("\n【阶段1: 标准 PID 控制（滞环执行器）】")

print(f"{'步数':>4s} {'PV':>8s} {'输出':>8s} {'阀位':>8s} {'状态':>10s}")

print("-" * 62)

# 测试标准 PID

actuator.reset()

pid_standard.reset()

process._state = 50.0

process._delay_buffer = [50.0] * len(process._delay_buffer)

for i in range(steps):

# 获取过程变量

pv = process.update(actuator.position)

# 标准 PID 计算

output = pid_standard.compute(pv, sp, 1.0)

# 执行器更新

actuator_record = actuator.update(output)

actuator_record.timestamp = float(i)

# 记录

self.results_standard.append({

'step': i,

'pv': pv,

'output': output,

'valve_position': actuator_record.actual_position,

'actuator_state': actuator_record.actuator_state.value,

'in_hysteresis': actuator_record.in_hysteresis

})

if i % 20 == 0 or i < 10:

print(f"{i:4d} {pv:8.2f} {output:8.2f} "

f"{actuator_record.actual_position:8.2f} "

f"{actuator_record.actuator_state.value:>10s}")

# 加入扰动（模拟现场波动）

if i == 80:

sp = 52.0 # 设定值回撤

print(f"\n >>> 设定值阶跃: 55% → 52% (步数 {i})")

print(f"\n 标准 PID 完成，执行器卡涩次数: {actuator.stick_count}")

# 测试自适应 PID

print("\n【阶段2: 滞环自适应 PID 控制】")

print(f"{'步数':>4s} {'PV':>8s} {'输出':>8s} {'阀位':>8s} {'状态':>10s}")

print("-" * 62)

actuator.reset()

pid_adaptive.reset()

process._state = 50.0

process._delay_buffer = [50.0] * len(process._delay_buffer)

sp = 55.0

for i in range(steps):

pv = process.update(actuator.position)

# 自适应 PID 计算

output = pid_adaptive.compute(pv, sp, 1.0,

actuator_

利用AI解决实际问题，如果你觉得这个工具好用，欢迎关注长安牧笛！