《自动控制原理》 - 第二章控制系统的数学模型

啊阿狸不会拉杆

发布于 2026-01-21 11:39:48

2210

2-1 控制系统的时域数学模型

控制系统的时域数学模型是描述系统输入输出关系的数学表达式，主要包括微分方程和差分方程。对于连续系统，常用微分方程来描述；对于离散系统，则用差分方程。

微分方程建模

微分方程是控制系统最基本的数学模型，它直接描述了系统输入输出之间的动态关系。下面通过一个机械系统和一个电路系统的例子来说明如何建立控制系统的微分方程模型。

机械系统建模

考虑一个弹簧 - 质量 - 阻尼系统，如图 2-1 所示：

图 2-1 弹簧 - 质量 - 阻尼系统

根据牛顿第二定律，可以建立该系统的微分方程：

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import solve_ivp

# 系统参数
m = 1.0  # 质量(kg)
k = 10.0  # 弹簧刚度(N/m)
c = 2.0  # 阻尼系数(N·s/m)

# 系统微分方程
def system_dynamics(t, x, F):
    """
    弹簧-质量-阻尼系统的微分方程
    x = [位置, 速度]
    """
    dxdt = np.zeros_like(x)
    dxdt[0] = x[1]  # 位置的导数是速度
    dxdt[1] = (F - c*x[1] - k*x[0]) / m  # 速度的导数根据牛顿第二定律计算
    return dxdt

# 模拟系统响应
def simulate_system(F, t_span, y0):
    """
    模拟系统在给定外力F作用下的响应
    """
    sol = solve_ivp(
        lambda t, x: system_dynamics(t, x, F),
        t_span, y0, t_eval=np.linspace(t_span[0], t_span[1], 500)
    )
    return sol.t, sol.y

# 初始条件
y0 = [0.0, 0.0]  # 初始位置和速度

# 模拟阶跃输入响应
F_step = 10.0  # 阶跃外力(N)
t_span = [0, 10]  # 时间范围

# 求解微分方程
t, y = simulate_system(F_step, t_span, y0)

# 绘制结果
plt.figure(figsize=(10, 6))
plt.plot(t, y[0], 'b-', label='位置')
plt.plot(t, y[1], 'r-', label='速度')
plt.axhline(y=F_step/k, color='g', linestyle='--', label='稳态位置')
plt.xlabel('时间(秒)')
plt.ylabel('响应')
plt.title('弹簧-质量-阻尼系统的阶跃响应')
plt.legend()
plt.grid(True)
plt.show()

# 计算稳态值
steady_state_position = F_step / k
print(f"稳态位置: {steady_state_position:.4f} m")

上述代码模拟了弹簧 - 质量 - 阻尼系统在外力作用下的响应。通过求解二阶微分方程，得到了系统的位置和速度随时间的变化曲线。从结果可以看出，系统最终会达到一个稳态值，这个值取决于外力大小和弹簧刚度。

电路系统建模

考虑一个 RC 电路，如图 2-2 所示：

图 2-2 RC 电路

根据基尔霍夫定律，可以建立该电路的微分方程：

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import solve_ivp

# 系统参数
R = 1000.0  # 电阻(Ω)
C = 0.001  # 电容(F)

# 系统微分方程
def circuit_dynamics(t, Vout, Vin):
    """
    RC电路的微分方程
    dVout/dt = (Vin - Vout) / (R*C)
    """
    return (Vin - Vout) / (R * C)

# 模拟系统响应
def simulate_circuit(Vin, t_span, Vout0):
    """
    模拟RC电路在给定输入电压Vin下的响应
    """
    sol = solve_ivp(
        lambda t, Vout: circuit_dynamics(t, Vout, Vin),
        t_span, [Vout0], t_eval=np.linspace(t_span[0], t_span[1], 500)
    )
    return sol.t, sol.y[0]

# 初始条件
Vout0 = 0.0  # 初始输出电压(V)

# 模拟阶跃输入响应
Vin_step = 5.0  # 阶跃输入电压(V)
t_span = [0, 5]  # 时间范围(秒)

# 求解微分方程
t, Vout = simulate_circuit(Vin_step, t_span, Vout0)

# 绘制结果
plt.figure(figsize=(10, 6))
plt.plot(t, Vout, 'b-', label='输出电压')
plt.axhline(y=Vin_step, color='g', linestyle='--', label='输入电压')
plt.xlabel('时间(秒)')
plt.ylabel('电压(V)')
plt.title('RC电路的阶跃响应')
plt.legend()
plt.grid(True)
plt.show()

# 计算时间常数和稳态值
time_constant = R * C
steady_state_voltage = Vin_step
print(f"时间常数: {time_constant:.4f} 秒")
print(f"稳态输出电压: {steady_state_voltage:.4f} V")

上述代码模拟了 RC 电路在阶跃输入电压作用下的响应。通过求解一阶微分方程，得到了电容电压随时间的变化曲线。从结果可以看出，电容电压会逐渐上升到输入电压值，上升的速度取决于时间常数 RC。

线性系统与非线性系统

控制系统可以分为线性系统和非线性系统。线性系统满足叠加原理，而非线性系统则不满足。下面通过一个简单的例子来说明两者的区别：

import numpy as np
import matplotlib.pyplot as plt

# 线性系统示例: y = 2x
def linear_system(x):
    return 2 * x

# 非线性系统示例: y = x^2
def nonlinear_system(x):
    return x ** 2

# 测试叠加原理
x1 = 2
x2 = 3
a = 1.5
b = 2.5

# 线性系统验证
y1_linear = linear_system(x1)
y2_linear = linear_system(x2)
y_linear_superposition = linear_system(a * x1 + b * x2)
linear_check = a * y1_linear + b * y2_linear

# 非线性系统验证
y1_nonlinear = nonlinear_system(x1)
y2_nonlinear = nonlinear_system(x2)
y_nonlinear_superposition = nonlinear_system(a * x1 + b * x2)
nonlinear_check = a * y1_nonlinear + b * y2_nonlinear

# 打印结果
print("线性系统验证:")
print(f"叠加输入响应: {y_linear_superposition}")
print(f"响应叠加: {linear_check}")
print(f"叠加原理是否成立: {np.isclose(y_linear_superposition, linear_check)}")

print("\n非线性系统验证:")
print(f"叠加输入响应: {y_nonlinear_superposition}")
print(f"响应叠加: {nonlinear_check}")
print(f"叠加原理是否成立: {np.isclose(y_nonlinear_superposition, nonlinear_check)}")

# 绘制系统响应
x = np.linspace(-5, 5, 100)
y_linear = linear_system(x)
y_nonlinear = nonlinear_system(x)

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.plot(x, y_linear, 'b-')
plt.title('线性系统 y = 2x')
plt.xlabel('输入 x')
plt.ylabel('输出 y')
plt.grid(True)

plt.subplot(1, 2, 2)
plt.plot(x, y_nonlinear, 'r-')
plt.title('非线性系统 y = x^2')
plt.xlabel('输入 x')
plt.ylabel('输出 y')
plt.grid(True)

plt.tight_layout()
plt.show()

上述代码通过比较线性系统和非线性系统对不同输入的响应，验证了叠加原理只在线性系统中成立。线性系统的输出曲线是一条直线，而非线性系统的输出曲线是一条抛物线。

2-2 控制系统的复数域数学模型

控制系统的复数域数学模型主要包括传递函数-H(s)和频率特性-H(jw)。传递函数是在拉普拉斯变换的基础上定义的，它是分析线性定常系统的有力工具。

传递函数的定义与计算

传递函数定义为零初始条件下，系统输出量的拉普拉斯变换与输入量的拉普拉斯变换之比。下面通过几个例子来说明传递函数的计算方法：

import numpy as np
import matplotlib.pyplot as plt
from control import tf, step_response

# 1. RC电路的传递函数
R = 1000.0  # 电阻(Ω)
C = 0.001  # 电容(F)
num = [1]  # 分子多项式系数
den = [R*C, 1]  # 分母多项式系数
sys_rc = tf(num, den)

print("RC电路传递函数:")
print(sys_rc)

# 2. 弹簧-质量-阻尼系统的传递函数
m = 1.0  # 质量(kg)
k = 10.0  # 弹簧刚度(N/m)
c = 2.0  # 阻尼系数(N·s/m)
num = [1]  # 分子多项式系数
den = [m, c, k]  # 分母多项式系数
sys_spring = tf(num, den)

print("\n弹簧-质量-阻尼系统传递函数:")
print(sys_spring)

# 3. 系统阶跃响应比较
plt.figure(figsize=(10, 6))

# RC电路阶跃响应
t_rc, y_rc = step_response(sys_rc)
plt.plot(t_rc, y_rc, 'b-', label='RC电路')

# 弹簧-质量-阻尼系统阶跃响应
t_spring, y_spring = step_response(sys_spring)
plt.plot(t_spring, y_spring, 'r-', label='弹簧-质量-阻尼系统')

plt.xlabel('时间(秒)')
plt.ylabel('响应')
plt.title('不同系统的阶跃响应比较')
plt.legend()
plt.grid(True)
plt.show()

# 计算系统特性
from control import damp, pole, zero

print("\nRC电路特性:")
print(f"极点: {pole(sys_rc)}")
print(f"阻尼比和自然频率: {damp(sys_rc)}")

print("\n弹簧-质量-阻尼系统特性:")
print(f"极点: {pole(sys_spring)}")
print(f"阻尼比和自然频率: {damp(sys_spring)}")

上述代码计算了 RC 电路和弹簧 - 质量 - 阻尼系统的传递函数，并比较了它们的阶跃响应。通过分析系统的极点和阻尼比，可以了解系统的稳定性和动态特性。

传递函数的等效变换

传递函数可以进行各种等效变换，如串联、并联和反馈连接。下面通过代码演示这些变换：

import numpy as np
import matplotlib.pyplot as plt
from control import tf, series, parallel, feedback

# 定义两个子系统
G1 = tf([1], [1, 2, 1])  # 子系统1: 1/(s^2 + 2s + 1)
G2 = tf([1], [1, 1])    # 子系统2: 1/(s + 1)

print("子系统1:")
print(G1)
print("\n子系统2:")
print(G2)

# 1. 串联连接
G_series = series(G1, G2)
print("\n串联连接后的传递函数:")
print(G_series)

# 2. 并联连接
G_parallel = parallel(G1, G2)
print("\n并联连接后的传递函数:")
print(G_parallel)

# 3. 反馈连接
G_feedback = feedback(G1, G2)
print("\n负反馈连接后的传递函数:")
print(G_feedback)

# 绘制各种连接方式的阶跃响应
plt.figure(figsize=(12, 10))

plt.subplot(2, 2, 1)
t, y = step_response(G1)
plt.plot(t, y)
plt.title('子系统1的阶跃响应')
plt.xlabel('时间(秒)')
plt.ylabel('响应')
plt.grid(True)

plt.subplot(2, 2, 2)
t, y = step_response(G2)
plt.plot(t, y)
plt.title('子系统2的阶跃响应')
plt.xlabel('时间(秒)')
plt.ylabel('响应')
plt.grid(True)

plt.subplot(2, 2, 3)
t, y = step_response(G_series)
plt.plot(t, y)
plt.title('串联系统的阶跃响应')
plt.xlabel('时间(秒)')
plt.ylabel('响应')
plt.grid(True)

plt.subplot(2, 2, 4)
t, y = step_response(G_feedback)
plt.plot(t, y)
plt.title('反馈系统的阶跃响应')
plt.xlabel('时间(秒)')
plt.ylabel('响应')
plt.grid(True)

plt.tight_layout()
plt.show()

上述代码演示了传递函数的串联、并联和反馈连接。通过比较不同连接方式下的传递函数和阶跃响应，可以直观地了解各种连接方式对系统性能的影响。

2-3 控制系统的结构图与信号流图

控制系统的结构图和信号流图是描述系统各组成部分之间信号传递关系的图形化工具。它们可以帮助我们直观地理解系统的结构和工作原理，并简化系统传递函数的计算。

控制系统结构图

控制系统结构图是由传递函数方块、信号线、比较点和分支点组成的图形。下面通过一个简单的反馈控制系统来说明结构图的绘制和化简：

图 2-3 反馈控制系统结构图

信号流图

信号流图是由节点和支路组成的图形，用于表示系统中各变量之间的关系。下面通过一个例子来说明如何从结构图绘制信号流图，并使用梅森公式计算系统传递函数：

图 2-4 反馈控制系统信号流图

下面通过 Python 代码实现结构图化简和信号流图分析：

import numpy as np
from control import tf, feedback

# 定义系统各部分传递函数
G_c = tf([2], [1, 0.5])  # 控制器传递函数
G_a = tf([1], [1, 1])    # 执行器传递函数
G_p = tf([10], [1, 2, 0])  # 被控对象传递函数
H = tf([1], [1])       # 测量装置传递函数

# 计算前向通路传递函数
G_forward = G_c * G_a * G_p
print("前向通路传递函数:")
print(G_forward)

# 计算反馈回路传递函数
G_loop = G_forward * H
print("\n反馈回路传递函数:")
print(G_loop)

# 计算闭环传递函数
G_closed = feedback(G_forward, H)
print("\n闭环传递函数:")
print(G_closed)

# 使用梅森公式验证
# 系统有1条前向通路，增益为P1 = G_c*G_a*G_p
# 有1个单独回路，增益为L1 = -G_c*G_a*G_p*H
# 特征式Δ = 1 - L1 = 1 + G_c*G_a*G_p*H
# 传递函数T = P1*Δ1/Δ，其中Δ1 = 1（前向通路不接触任何回路）

P1 = G_forward
L1 = -G_loop
Delta = 1 + L1
T_mason = P1 / Delta

print("\n使用梅森公式计算的传递函数:")
print(T_mason)

# 验证两种方法结果是否相同
print("\n两种方法计算结果是否相同:")
print(np.allclose(G_closed.num[0][0], T_mason.num[0][0]) and 
      np.allclose(G_closed.den[0][0], T_mason.den[0][0]))

上述代码实现了结构图化简和信号流图分析的过程。通过比较直接使用 feedback 函数和使用梅森公式计算的结果，可以验证两种方法的一致性。

结构图等效变换规则

控制系统结构图的等效变换规则包括：

串联变换：G1 (s) 和 G2 (s) 串联后的传递函数为 G1 (s) G2 (s)
并联变换：G1 (s) 和 G2 (s) 并联后的传递函数为 G1 (s)+G2 (s)
反馈变换：负反馈连接后的传递函数为 G (s)/(1+G (s) H (s))
比较点移动：前移需除以支路传递函数，后移需乘以支路传递函数
分支点移动：前移需乘以支路传递函数，后移需除以支路传递函数

下面通过代码演示这些变换规则的应用：

import numpy as np
from control import tf, series, parallel, feedback

# 定义子系统
G1 = tf([1], [1, 1])  # G1(s) = 1/(s+1)
G2 = tf([2], [1, 2])  # G2(s) = 2/(s+2)
G3 = tf([3], [1, 3])  # G3(s) = 3/(s+3)
H = tf([1], [1])     # H(s) = 1

# 1. 串联变换
G_series = series(G1, G2)
print("串联变换结果:")
print(G_series)

# 2. 并联变换
G_parallel = parallel(G1, G2)
print("\n并联变换结果:")
print(G_parallel)

# 3. 反馈变换
G_feedback = feedback(G1, H)
print("\n反馈变换结果:")
print(G_feedback)

# 4. 复杂系统的结构图化简
# 考虑一个系统：R -> [+] -> G1 -> [+] -> G2 -> C
#               |        ^
#               |        |
#               v        |
#               G3       |
#               |        |
#               v        |
#               [-] ------

# 方法1：直接使用feedback和series
G_temp = series(G1, G2)
G_loop = series(G3, G2)
G_system1 = feedback(G_temp, G_loop)

# 方法2：使用梅森公式
# 前向通路：P1 = G1*G2
# 回路：L1 = -G1*G2*G3
# 特征式：Δ = 1 - L1 = 1 + G1*G2*G3
# 传递函数：T = P1/Δ = G1*G2/(1 + G1*G2*G3)
P1 = series(G1, G2)
L1 = -series(G1, G2, G3)
Delta = 1 - L1
G_system2 = P1 / Delta

print("\n复杂系统化简结果:")
print("方法1结果:")
print(G_system1)
print("\n方法2结果:")
print(G_system2)

# 验证两种方法结果是否相同
print("\n两种方法计算结果是否相同:")
print(np.allclose(G_system1.num[0][0], G_system2.num[0][0]) and 
      np.allclose(G_system1.den[0][0], G_system2.den[0][0]))

上述代码演示了控制系统结构图的各种等效变换规则。通过比较不同方法计算的结果，可以验证变换规则的正确性。

2-4 控制系统建模实例

直流电动机转速控制系统建模

直流电动机是工业控制中常用的执行元件，下面建立其转速控制系统的数学模型：

图 2-5 直流电动机转速控制系统结构图

下面通过 Python 代码建立直流电动机的数学模型并分析其动态特性：

import numpy as np
import matplotlib.pyplot as plt
from control import tf, step_response, bode_plot

# 电动机参数
R = 1.0  # 电枢电阻(Ω)
L = 0.1  # 电枢电感(H)
Kt = 0.5  # 转矩常数(N·m/A)
Ke = 0.5  # 电动势常数(V·s/rad)
J = 0.01  # 转动惯量(kg·m^2)
B = 0.001  # 阻尼系数(N·m·s/rad)

# 建立传递函数模型
# 1. 电枢电路传递函数: I(s)/[V(s)-E(s)] = 1/(L*s + R)
num_armature = [1]
den_armature = [L, R]
G_armature = tf(num_armature, den_armature)

# 2. 机械系统传递函数: ω(s)/T(s) = 1/(J*s + B)
num_mech = [1]
den_mech = [J, B]
G_mech = tf(num_mech, den_mech)

# 3. 转矩与电流关系: T(s) = Kt*I(s)
G_torque = tf([Kt], [1])

# 4. 反电动势与转速关系: E(s) = Ke*ω(s)
G_emf = tf([Ke], [1])

# 5. 开环传递函数: ω(s)/V(s)
G_open = (G_armature * G_torque * G_mech) / (1 + G_armature * G_torque * G_mech * G_emf)

print("直流电动机开环传递函数:")
print(G_open)

# 分析系统特性
from control import damp, pole, zero

print("\n系统特性:")
print(f"极点: {pole(G_open)}")
print(f"阻尼比和自然频率: {damp(G_open)}")

# 绘制阶跃响应
plt.figure(figsize=(12, 10))

plt.subplot(2, 2, 1)
t, y = step_response(G_open)
plt.plot(t, y)
plt.title('直流电动机开环阶跃响应')
plt.xlabel('时间(秒)')
plt.ylabel('转速(rad/s)')
plt.grid(True)

# 绘制伯德图
plt.subplot(2, 2, 2)
bode_plot(G_open, dB=True, deg=True)
plt.tight_layout()

# 设计闭环控制系统
Kp = 10.0  # 比例控制器增益
G_controller = tf([Kp], [1])

# 闭环传递函数
G_closed = feedback(G_controller * G_open, 1)

print("\n直流电动机闭环传递函数:")
print(G_closed)

# 绘制闭环阶跃响应
plt.subplot(2, 2, 3)
t, y = step_response(G_closed)
plt.plot(t, y)
plt.title('直流电动机闭环阶跃响应')
plt.xlabel('时间(秒)')
plt.ylabel('转速(rad/s)')
plt.grid(True)

# 分析闭环系统特性
print("\n闭环系统特性:")
print(f"极点: {pole(G_closed)}")
print(f"阻尼比和自然频率: {damp(G_closed)}")

plt.tight_layout()
plt.show()

上述代码建立了直流电动机转速控制系统的数学模型，包括电枢电路、机械系统和反馈环节。通过分析开环和闭环系统的传递函数和动态特性，可以了解系统的稳定性和响应性能。

液位控制系统建模

液位控制系统是工业过程控制中的常见系统，下面建立其数学模型：

图 2-6 液位控制系统结构图

下面通过 Python 代码建立液位控制系统的数学模型并分析其特性：

import numpy as np
import matplotlib.pyplot as plt
from control import tf, step_response

# 系统参数
A = 0.5  # 水箱横截面积(m^2)
R = 2.0  # 出水阀门阻力系数(s/m)
K = 1.0  # 进水阀门增益

# 建立传递函数模型
# 液位h对输入流量Qi的传递函数: H(s)/Qi(s) = 1/(A*s + 1/R)
num = [1/A]
den = [1, 1/(A*R)]
G = tf(num, den)

print("液位控制系统传递函数:")
print(G)

# 分析系统特性
from control import damp, pole, zero

print("\n系统特性:")
print(f"极点: {pole(G)}")
print(f"阻尼比和自然频率: {damp(G)}")

# 绘制阶跃响应
plt.figure(figsize=(10, 6))

# 不同输入流量下的阶跃响应
for Qi in [1.0, 2.0, 3.0]:
    t, y = step_response(Qi * G)
    plt.plot(t, y, label=f'输入流量 = {Qi} m^3/s')

plt.xlabel('时间(秒)')
plt.ylabel('液位(m)')
plt.title('液位控制系统阶跃响应')
plt.legend()
plt.grid(True)
plt.show()

# 设计闭环控制系统
Kp = 5.0  # 比例控制器增益
Ki = 1.0  # 积分控制器增益
Kd = 0.1  # 微分控制器增益

# PID控制器传递函数
num_pid = [Kd, Kp, Ki]
den_pid = [1, 0]
G_pid = tf(num_pid, den_pid)

# 闭环传递函数
G_closed = feedback(G_pid * G, 1)

print("\n液位闭环控制系统传递函数:")
print(G_closed)

# 绘制闭环阶跃响应
plt.figure(figsize=(10, 6))
t, y = step_response(G_closed)
plt.plot(t, y)
plt.xlabel('时间(秒)')
plt.ylabel('液位(m)')
plt.title('液位闭环控制系统阶跃响应')
plt.grid(True)
plt.show()

# 分析闭环系统特性
print("\n闭环系统特性:")
print(f"极点: {pole(G_closed)}")
print(f"阻尼比和自然频率: {damp(G_closed)}")

上述代码建立了液位控制系统的数学模型，并设计了 PID 控制器实现闭环控制。通过分析系统的传递函数和阶跃响应，可以了解系统的动态特性和控制效果。

习题

建立如图 2-7 所示 RLC 电路的微分方程数学模型，并求其传递函数。

图 2-7 RLC 电路

已知系统的微分方程为：

d²y(t)/dt² + 3dy(t)/dt + 2y(t) = 5u(t)

求系统的传递函数，并绘制其阶跃响应曲线。

化简如图 2-8 所示的系统结构图，并求其传递函数。

图 2-8 系统结构图

用梅森公式求如图 2-9 所示信号流图的传递函数。

图 2-9 信号流图

建立如图 2-10 所示机械系统的数学模型，包括微分方程和传递函数。

图 2-10 机械系统

已知某系统的传递函数为：

G(s) = (s + 2) / (s² + 4s + 5)

求系统的单位阶跃响应，并分析系统的稳定性和动态性能。

设计一个 PID 控制器，使习题 6 中的系统满足以下性能指标：

超调量 ≤ 10%
调整时间 ≤ 2 秒
稳态误差为零

建立一个简单的温度控制系统的数学模型，包括传感器、控制器、加热器和被控对象（如一个水箱），并分析其动态特性。

已知系统的结构图如图 2-11 所示，求输入 R (s) 和扰动 N (s) 分别作用时系统的传递函数，并分析系统对扰动的抑制能力。

图 2-11 系统结构图

建立一个汽车巡航控制系统的数学模型，分析其稳定性和响应性能，并设计一个合适的控制器。

以上习题涵盖了本章的主要知识点，通过练习可以加深对控制系统数学模型的理解和掌握。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-06-29，如有侵权请联系 cloudcommunity@tencent.com 删除

性能

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度