《自动控制原理 》- 第 1 章 自动控制的基本原理与方式

1-1 自动控制的基本原理与方式

        自动控制是指在没有人直接参与的情况下，利用外加的设备或装置，使机器、设备或生产过程的某个工作状态或参数按照预定的规律运行。自动控制的核心原理是反馈控制，即通过将系统的输出量回送到输入端，与输入量进行比较，利用偏差信号产生控制作用，使被控量趋于要求值。

开环控制系统与闭环控制系统

开环控制系统原理

        开环控制系统是指输出量与输入量之间没有反向联系，只靠输入量对输出量单向控制的系统。其结构简单，但抗干扰能力差，控制精度不高。

图 1-1 开环控制系统结构流程图

闭环控制系统原理

        闭环控制系统是指输出量与输入量之间有反向联系，靠输入量与主反馈信号之间的偏差对输出量进行控制的系统。闭环控制系统通过负反馈实现按偏差控制，具有纠正偏差的能力，抗扰性好，控制精度高。

图 1-2 闭环控制系统结构流程图

反馈控制原理 Python 实现

 用Python 代码模拟一个简单的温度控制系统，比较开环和闭环控制的效果：

import numpy as np
import matplotlib.pyplot as plt

# 系统参数
ambient_temp = 25  # 环境温度(°C)
system_gain = 0.8  # 系统增益
time_constant = 10  # 时间常数(秒)
disturbance = 5  # 扰动温度(°C)

# 时间序列
time = np.arange(0, 100, 0.1)

# 开环控制系统模拟
def open_loop_control(setpoint, disturbance):
    """开环控制系统温度模拟"""
    output = np.zeros_like(time)
    output[0] = ambient_temp
    
    for i in range(1, len(time)):
        # 开环控制：直接根据设定值计算输出，无反馈
        control_signal = setpoint
        # 一阶系统动态响应
        output[i] = output[i-1] + (system_gain * control_signal - 
                                  (output[i-1] - ambient_temp) / time_constant) * 0.1
        # 加入扰动
        if time[i] > 50:
            output[i] += disturbance
    return output

# 闭环控制系统模拟
def closed_loop_control(setpoint, disturbance):
    """闭环控制系统温度模拟"""
    output = np.zeros_like(time)
    output[0] = ambient_temp
    error = setpoint - output[0]
    kp = 1.2  # 比例控制增益
    
    for i in range(1, len(time)):
        # 闭环控制：根据误差计算控制信号
        error = setpoint - output[i-1]
        control_signal = kp * error
        # 一阶系统动态响应
        output[i] = output[i-1] + (system_gain * control_signal - 
                                  (output[i-1] - ambient_temp) / time_constant) * 0.1
        # 加入扰动
        if time[i] > 50:
            output[i] += disturbance
    return output

# 设定值
setpoint = 60  # 目标温度(°C)

# 运行模拟
open_loop_output = open_loop_control(setpoint, disturbance)
closed_loop_output = closed_loop_control(setpoint, disturbance)

# 绘制结果
plt.figure(figsize=(10, 6))
plt.plot(time, open_loop_output, 'r-', label='开环控制')
plt.plot(time, closed_loop_output, 'b-', label='闭环控制')
plt.axhline(y=setpoint, color='g', linestyle='--', label='设定值')
plt.axhline(y=ambient_temp, color='k', linestyle=':', label='环境温度')
plt.axvline(x=50, color='m', linestyle='--', label='扰动加入')
plt.xlabel('时间(秒)')
plt.ylabel('温度(°C)')
plt.title('开环与闭环控制系统温度响应对比')
plt.legend()
plt.grid(True)
plt.show()

# 计算稳态误差
open_loop_steady_state = open_loop_output[-1]
closed_loop_steady_state = closed_loop_output[-1]
open_loop_error = setpoint - open_loop_steady_state
closed_loop_error = setpoint - closed_loop_steady_state

print(f"开环控制稳态温度: {open_loop_steady_state:.2f}°C, 稳态误差: {open_loop_error:.2f}°C")
print(f"闭环控制稳态温度: {closed_loop_steady_state:.2f}°C, 稳态误差: {closed_loop_error:.2f}°C")

        上述代码模拟了一个简单的温度控制系统，比较了开环和闭环控制在面对扰动时的表现。从结果可以看出，闭环控制系统能够有效减小稳态误差，抵抗扰动的影响。

1-2 自动控制系统示例

电机转速控制系统

        电机转速控制是自动控制领域的经典示例，下面我们通过 Python 代码模拟一个直流电机转速控制系统，分别实现开环控制和闭环控制，并比较两者的性能。

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

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

# 系统动态方程 - 开环
def open_loop_system(t, x, u):
    """开环系统状态方程: x = [i, ω]"""
    i, omega = x
    didt = (-R/L)*i - (K/L)*omega + u/L
    domegadot = (K/J)*i - (B/J)*omega
    return [didt, domegadot]

# 系统动态方程 - 闭环
def closed_loop_system(t, x, u, setpoint, kp, ki):
    """闭环系统状态方程: x = [i, ω, error_integral]"""
    i, omega, error_int = x
    error = setpoint - omega
    # PID控制
    control_signal = kp * error + ki * error_int
    didt = (-R/L)*i - (K/L)*omega + control_signal/L
    domegadot = (K/J)*i - (B/J)*omega
    derror_int = error
    return [didt, domegadot, derror_int]

# 模拟开环控制
def simulate_open_loop(setpoint, disturbance=0, u=10):
    """模拟开环控制"""
    # 初始状态: 电流i=0, 转速omega=0
    t_span = (0, 5)
    t_eval = np.linspace(0, 5, 500)
    y0 = [0, 0]
    
    # 加入扰动函数
    def disturbance_func(t):
        if t > 2:
            return disturbance
        return 0
    
    # 求解微分方程
    sol = solve_ivp(
        lambda t, x: open_loop_system(t, x, u + disturbance_func(t)),
        t_span, y0, t_eval=t_eval, method='RK45'
    )
    
    return sol.t, sol.y[1]  # 返回时间和转速

# 模拟闭环控制
def simulate_closed_loop(setpoint, disturbance=0, kp=5, ki=0.1):
    """模拟闭环控制"""
    # 初始状态: 电流i=0, 转速omega=0, 误差积分=0
    t_span = (0, 5)
    t_eval = np.linspace(0, 5, 500)
    y0 = [0, 0, 0]
    
    # 加入扰动函数
    def disturbance_func(t):
        if t > 2:
            return disturbance
        return 0
    
    # 求解微分方程
    sol = solve_ivp(
        lambda t, x: closed_loop_system(t, x, disturbance_func(t), setpoint, kp, ki),
        t_span, y0, t_eval=t_eval, method='RK45'
    )
    
    return sol.t, sol.y[1]  # 返回时间和转速

# 设定参数
setpoint = 100  # 目标转速(rad/s)
disturbance = 5  # 扰动转矩(N·m)

# 运行模拟
t_open, omega_open = simulate_open_loop(setpoint, disturbance)
t_closed, omega_closed = simulate_closed_loop(setpoint, disturbance)

# 绘制结果
plt.figure(figsize=(12, 6))

plt.subplot(1, 2, 1)
plt.plot(t_open, omega_open, 'r-', label='开环控制转速')
plt.axhline(y=setpoint, color='g', linestyle='--', label='目标转速')
plt.axvline(x=2, color='m', linestyle='--', label='扰动加入')
plt.xlabel('时间(秒)')
plt.ylabel('转速(rad/s)')
plt.title('开环控制系统电机转速响应')
plt.legend()
plt.grid(True)

plt.subplot(1, 2, 2)
plt.plot(t_closed, omega_closed, 'b-', label='闭环控制转速')
plt.axhline(y=setpoint, color='g', linestyle='--', label='目标转速')
plt.axvline(x=2, color='m', linestyle='--', label='扰动加入')
plt.xlabel('时间(秒)')
plt.ylabel('转速(rad/s)')
plt.title('闭环控制系统电机转速响应')
plt.legend()
plt.grid(True)

plt.tight_layout()
plt.show()

# 计算性能指标
def calculate_performance(t, omega, setpoint):
    """计算系统性能指标"""
    # 稳态转速
    steady_state = omega[-1]
    # 稳态误差
    steady_error = setpoint - steady_state
    # 上升时间(达到90%设定值的时间)
    idx = np.where(omega >= 0.9 * setpoint)[0]
    rise_time = t[idx[0]] if len(idx) > 0 else None
    # 超调量
    overshoot = np.max(omega) - setpoint if np.max(omega) > setpoint else 0
    
    return {
        '稳态转速': steady_state,
        '稳态误差': steady_error,
        '上升时间': rise_time,
        '超调量': overshoot
    }

# 计算并打印性能指标
print("开环控制系统性能指标:")
print(calculate_performance(t_open, omega_open, setpoint))

print("\n闭环控制系统性能指标:")
print(calculate_performance(t_closed, omega_closed, setpoint))

        上述代码模拟了一个直流电机转速控制系统，分别实现了开环控制和闭环控制，并在 2 秒时加入扰动转矩。通过比较可以看出，闭环控制系统在面对扰动时能够更快地恢复到目标转速，并且稳态误差更小。

系统方块图

图 1-3 电机转速闭环控制系统方块图

1-3 自动控制系统的分类

自动控制系统可以从不同角度进行分类，下面通过思维导图展示主要的分类方式：

图 1-4 自动控制系统分类思维导图

按控制方式分类

1. 开环控制系统

• 结构简单、经济
• 调试方便
• 抗干扰能力差，控制精度不高

2. 反馈控制系统（闭环控制系统）

• 具有纠正偏差的能力
• 抗扰性好，控制精度高
• 结构复杂，价格高

3. 复合控制系统

• 开环与闭环控制的结合
• 具有更高的控制精度

按系统特性分类

1. 线性系统与非线性系统

• 线性系统：满足叠加原理
• 非线性系统：不满足叠加原理，存在非线性元件

2. 连续控制系统与离散控制系统

• 连续控制系统：系统中各处的信号均为连续时间信号
• 离散控制系统：系统中一处或多处的信号为离散时间信号

3. 定常系统与时变系统

• 定常系统：系统参数不随时间变化
• 时变系统：系统参数随时间变化

按给定值变化规律分类

1. 恒值控制系统

• 输入量是恒定的常值
• 任务：在各种扰动作用下使输出量保持在恒定希望值附近
• 示例：恒温、恒压控制系统

2. 随动系统（跟踪系统）

• 输入量是事先不知道的任意时间函数
• 任务：使输出量迅速而准确地跟随输入量的变化
• 示例：雷达自动跟踪系统

3. 程序控制系统

• 输入量按照给定的程序变化
• 任务：使输出量按预先给定的程序指令动作
• 示例：数控车床、机器人控制系统

1-4 对自动控制系统的基本要求

对自动控制系统的基本要求可以概括为三个字：稳、快、准，即稳定性、快速性和准确性。

1. 稳定性

        稳定性是指系统重新恢复平衡状态的能力，是对控制系统的最基本要求。一个稳定的系统在受到扰动后，经过一段时间的过渡过程，能够回到或接近原来的平衡状态。

2. 快速性

        快速性是指过渡过程进行时间的长短。快速性好的系统能够在较短的时间内完成过渡过程，减少系统的响应时间。

3. 准确性

        准确性是指过渡过程结束后的稳态误差，反映了系统的控制精度。准确性好的系统能够使输出量尽可能接近期望值。

用Python 代码模拟不同阻尼比的二阶系统阶跃响应，展示稳定性、快速性和准确性的变化：

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

# 定义二阶系统传递函数
def second_order_system(wn, zeta):
    """
    创建二阶系统传递函数
    wn: 自然频率
    zeta: 阻尼比
    """
    num = [wn**2]
    den = [1, 2*zeta*wn, wn**2]
    return tf(num, den)

# 系统参数
wn = 10  # 自然频率
zeta_values = [0.2, 0.5, 1.0, 1.5]  # 不同阻尼比

# 绘制不同阻尼比的阶跃响应
plt.figure(figsize=(12, 8))

for zeta in zeta_values:
    sys = second_order_system(wn, zeta)
    t, y = step_response(sys, T=np.linspace(0, 2, 1000))
    
    # 计算性能指标
    steady_state = y[-1]
    steady_error = 1 - steady_state
    # 上升时间(达到90%的时间)
    idx = np.where(y >= 0.9)[0]
    rise_time = t[idx[0]] if len(idx) > 0 else None
    # 超调量
    overshoot = np.max(y) - 1 if np.max(y) > 1 else 0
    # 调整时间(2%误差带)
    idx = np.where(np.abs(y - 1) < 0.02)[0]
    settling_time = t[idx[-1]] if len(idx) > 0 else None
    
    plt.plot(t, y, label=f'ζ={zeta}, 超调量={overshoot*100:.1f}%, 调整时间={settling_time:.2f}s')

plt.axhline(y=1, color='k', linestyle='--', label='期望值')
plt.axhline(y=1.02, color='g', linestyle=':', alpha=0.5)
plt.axhline(y=0.98, color='g', linestyle=':', alpha=0.5, label='2%误差带')
plt.xlabel('时间(秒)')
plt.ylabel('系统输出')
plt.title('不同阻尼比二阶系统阶跃响应')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()

# 打印性能指标表格
print("不同阻尼比二阶系统性能指标对比:")
print("-" * 70)
print(f"{'阻尼比ζ':<10}{'超调量(%)':<15}{'上升时间(s)':<15}{'调整时间(s)':<15}{'稳态误差':<15}")
print("-" * 70)

for zeta in zeta_values:
    sys = second_order_system(wn, zeta)
    t, y = step_response(sys, T=np.linspace(0, 2, 1000))
    
    steady_state = y[-1]
    steady_error = 1 - steady_state
    idx_rise = np.where(y >= 0.9)[0]
    rise_time = t[idx_rise[0]] if len(idx_rise) > 0 else None
    overshoot = np.max(y) - 1 if np.max(y) > 1 else 0
    idx_settle = np.where(np.abs(y - 1) < 0.02)[0]
    settling_time = t[idx_settle[-1]] if len(idx_settle) > 0 else None
    
    print(f"{zeta:<10.1f}{overshoot*100:<15.1f}{rise_time:<15.2f}{settling_time:<15.2f}{steady_error:<15.6f}")

        上述代码模拟了不同阻尼比的二阶系统阶跃响应，通过改变阻尼比 ζ 的值，我们可以观察到系统性能的变化：

• 当 ζ<1 时，系统为欠阻尼，响应有超调，但上升时间短
• 当 ζ=1 时，系统为临界阻尼，无超调，响应速度较快
• 当 ζ>1 时，系统为过阻尼，无超调，但响应速度较慢

1-5 自动控制系统的分析与设计工具

经典控制理论工具

        经典控制理论主要以传递函数为数学工具，研究单输入单输出 (SISO)、线性定常系统的分析和设计。主要分析工具包括：

图 1-5 经典控制理论分析工具思维导图

时域分析工具示例

用 Python 的 control 库进行时域分析，包括传递函数定义、阶跃响应分析和性能指标计算：

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

# 定义系统传递函数 - 二阶系统
wn = 5  # 自然频率
zeta = 0.5  # 阻尼比
num = [wn**2]
den = [1, 2*zeta*wn, wn**2]
sys = tf(num, den)

print("系统传递函数:")
print(sys)

# 计算阶跃响应
t, y = step_response(sys, T=np.linspace(0, 5, 1000))

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

plt.subplot(2, 2, 1)
plt.plot(t, y)
plt.axhline(y=1, color='r', linestyle='--', label='期望值')
plt.xlabel('时间(秒)')
plt.ylabel('系统输出')
plt.title('二阶系统阶跃响应')
plt.legend()
plt.grid(True)

# 计算性能指标
from control.matlab import stepinfo  # 需要安装control库的matlab兼容性函数

info = stepinfo(sys)
print("\n阶跃响应性能指标:")
print(f"上升时间: {info['RiseTime']:.4f} 秒")
print(f"峰值时间: {info['PeakTime']:.4f} 秒")
print(f"超调量: {info['Overshoot']:.2f} %")
print(f"调整时间: {info['SettlingTime']:.4f} 秒")
print(f"稳态值: {info['SteadyStateValue']:.4f}")
print(f"稳态误差: {1 - info['SteadyStateValue']:.4f}")

# 绘制零极点图
plt.subplot(2, 2, 2)
pzmap(sys)
plt.title('系统零极点图')
plt.grid(True)

# 绘制根轨迹图
plt.subplot(2, 2, 3)
rlocus(sys)
plt.title('系统根轨迹图')
plt.grid(True)

# 伯德图
plt.subplot(2, 2, 4)
mag, phase, omega = sys.bode()
plt.subplot(2, 1, 1)
plt.semilogx(omega, mag)  # 绘制幅值图
plt.title('伯德图')
plt.ylabel('幅值(dB)')
plt.grid(True)
plt.subplot(2, 1, 2)
plt.semilogx(omega, phase)  # 绘制相位图
plt.xlabel('频率(rad/s)')
plt.ylabel('相位(度)')
plt.grid(True)

plt.tight_layout()
plt.show()

上述代码展示了经典控制理论中常用的分析工具：

• 传递函数定义
• 阶跃响应分析及性能指标计算
• 零极点图绘制
• 根轨迹图绘制
• 伯德图绘制

        通过这些工具，我们可以全面分析控制系统的性能，并为系统设计提供依据。在实际应用中，这些工具通常需要结合使用，以获得对系统的全面理解。

        自动控制原理是一门理论与实践相结合的学科，通过理论分析和计算机仿真相结合的方式，我们可以更好地理解和设计控制系统，使其满足实际应用的需求。