Bandwidth, robustness, and higher-order observers 带宽、鲁棒性与高阶观测器

Project 2: bandwidth, decoupling, parameter mismatch, and disturbance observer Project 2：带宽、解耦、参数失配与基础扰动观测器

From frequency domain to time domain: bandwidth, decoupling, and robustness 从频域到时域：带宽、解耦与鲁棒性

A well-tuned controller is not just "fast." It must balance speed, stability, and robustness to model uncertainty. This project asks you to quantify these tradeoffs through simulation. 一个调好的控制器不只是"快"。它必须在速度、稳定性和对模型不确定性的鲁棒性之间取得平衡。本项目要求你通过仿真量化这些权衡。

Code entry points and setup references代码入口与环境参考

git clone https://github.com/horychen/ee275.git
cd ee275/simulation
python tutorials_ep6_svpwm.py

Variables you should know至少要熟悉这些变量

Base configuration dictionary基础配置字典

Use this as your starting point. The key fields you will modify are highlighted in comments.以此为出发点。你需要修改的关键字段在注释中标出。

d = {
    'CL_TS': 1e-4,
    'VL_EXE_PER_CL_EXE': 5,
    'MACHINE_SIMULATIONs_PER_SAMPLING_PERIOD': 1,
    'TIME_SLICE': 0.2,
    'NUMBER_OF_SLICES': 6,
    'init_npp': 22,
    'init_IN': 1.3*6/1.414,
    'init_R': 0.035,                # <-- Part 3: change this for mismatch
    'init_Ld': 0.036e-3,            # <-- Part 3: change this for mismatch
    'init_Lq': 0.036e-3,            # <-- Part 3: change this for mismatch
    'init_KE': 0.0125,
    'init_Rreq': 0.0,
    'init_Js': 0.44e-4,             # <-- Part 3: change this for mismatch
    'DC_BUS_VOLTAGE': 5,
    'user_system_input_code':
        "if ii < 1: CTRL.cmd_idq[0] = 0.0; CTRL.cmd_rpm = 50\n"
        "elif ii < 5: ACM.TLoad = 0.2\n"
        "elif ii < 100: CTRL.cmd_rpm = -50",
    'CTRL.bool_apply_speed_closed_loop_control': True,
    'CTRL.bool_apply_decoupling_voltages_to_current_regulation': False,  # <-- Part 2
    'CTRL.bool_apply_sweeping_frequency_excitation': False,
    'CTRL.bool_overwrite_speed_commands': True,
    'CTRL.bool_zero_id_control': True,
    'FOC_delta': 15,                 # <-- Part 1: damping factor
    'FOC_desired_VLBW_HZ': 120,     # <-- Part 1: sweep this
    'FOC_CL_KI_factor_when__bool_apply_decoupling_voltages_to_current_regulation__is_False': 10,
    'CL_SERIES_KP': None,           # None = auto-tune
    'CL_SERIES_KI': None,
    'VL_SERIES_KP': None,
    'VL_SERIES_KI': None,
    'VL_LIMIT_OVERLOAD_FACTOR': 3.0,
    'disp.Kp': 0, 'disp.Ki': 0, 'disp.Kd': 0,
    'disp.tau': 0, 'disp.OutLimit': 0, 'disp.IntLimit': 0,
}

How does bandwidth affect time-domain performance? 带宽如何影响时域性能？

Background: PI auto-tuning背景：PI 自动整定

When CL_SERIES_KP is None, the Simulation_Benchmark class calls tuner.tunner_wrapper(d), which iterates to find current-loop and speed-loop PI gains that achieve the desired bandwidths. The key formulas are: 当 CL_SERIES_KP 为 None 时，Simulation_Benchmark 类会调用 tuner.tunner_wrapper(d)，通过迭代找到满足期望带宽的电流环和速度环 PI 参数。核心公式：

where $\delta$ is FOC_delta (a damping-like factor) and $\omega_{ci}$ is the current-loop bandwidth in rad/s. 其中 $\delta$ 即 FOC_delta（类似阻尼比的参数），$\omega_{ci}$ 为电流环带宽（rad/s）。

Step response metrics阶跃响应指标

Code skeleton代码骨架

import copy
from tutorials_ep6_svpwm import Simulation_Benchmark

bandwidths = [20, 40, 60, 80, 100, 120]
results = {'rise_time': [], 'overshoot': [], 'ss_error': []}

for bw in bandwidths:
    d_run = copy.deepcopy(d)      # use a fresh copy each time
    d_run['FOC_desired_VLBW_HZ'] = bw
    d_run['CL_SERIES_KP'] = None  # force re-tune
    d_run['CL_SERIES_KI'] = None
    d_run['VL_SERIES_KP'] = None
    d_run['VL_SERIES_KI'] = None

    sim = Simulation_Benchmark(d_run)
    speed = sim.gdd['CTRL.omega_r_mech']
    time  = sim.global_machine_times

    # TODO: extract rise time, overshoot, steady-state error
    # Hint: find the step region, identify y_ss, then compute metrics
    # results['rise_time'].append(tr)
    # results['overshoot'].append(os_pct)
    # results['ss_error'].append(ess)

What does feedforward decoupling do, and what are its side effects? 前馈解耦的作用与副作用

Physics: cross-coupling in the dq frame物理：dq 坐标系中的交叉耦合

The dq-frame voltage equations of a PMSM are: PMSM 的 dq 坐标系电压方程为：

The underbraced terms act as disturbances to the PI current regulators. Feedforward decoupling adds compensation voltages to cancel them: 下划线部分是对 PI 电流调节器的扰动。前馈解耦通过补偿电压来抵消它们：

This corresponds to lines 696–699 in tutorials_ep6_svpwm.py. 这对应 tutorials_ep6_svpwm.py 的第 696–699 行。

Code: toggle decoupling代码：切换解耦

# Experiment A: Decoupling OFF
d_off = copy.deepcopy(d)
d_off['CTRL.bool_apply_decoupling_voltages_to_current_regulation'] = False
sim_off = Simulation_Benchmark(d_off)

# Experiment B: Decoupling ON
d_on = copy.deepcopy(d)
d_on['CTRL.bool_apply_decoupling_voltages_to_current_regulation'] = True
sim_on = Simulation_Benchmark(d_on)

What happens when the controller's model does not match reality? 当控制器的模型与实际不匹配时会发生什么？

The idea思路

In Simulation_Benchmark, both CTRL (controller) and ACM (plant) are initialized from the same d dictionary. The feedforward decoupling uses CTRL.Lq and CTRL.KA to compute the compensation voltages. If these values are wrong (i.e., they don't match the actual plant), the feedforward injects errors instead of cancelling disturbances. 在 Simulation_Benchmark 中，CTRL（控制器）和 ACM（被控对象）都从同一个 d 字典初始化。前馈解耦使用 CTRL.Lq 和 CTRL.KA 来计算补偿电压。如果这些值是错误的（即与实际被控对象不匹配），前馈就会注入误差而非抵消扰动。

Code: parameter mismatch experiment代码：参数失配实验

import copy

# Step 1: Tune with correct parameters
d_baseline = copy.deepcopy(d)
d_baseline['CL_SERIES_KP'] = None  # auto-tune
sim_matched = Simulation_Benchmark(d_baseline)

# Step 2: Save tuned gains
saved_gains = {
    'CL_SERIES_KP': d_baseline['CL_SERIES_KP'],
    'CL_SERIES_KI': d_baseline['CL_SERIES_KI'],
    'VL_SERIES_KP': d_baseline['VL_SERIES_KP'],
    'VL_SERIES_KI': d_baseline['VL_SERIES_KI'],
}

# Step 3: Run with parameter mismatch
d_mismatch = copy.deepcopy(d)
d_mismatch.update(saved_gains)  # use pre-tuned gains, skip re-tuning
d_mismatch['init_R']  = d['init_R']  * 1.5   # +50% resistance (thermal)
d_mismatch['init_Ld'] = d['init_Ld'] * 0.7   # -30% inductance (saturation)
d_mismatch['init_Lq'] = d['init_Lq'] * 0.7
d_mismatch['init_Js'] = d['init_Js'] * 2.0   # +100% inertia (load)

sim_mismatched = Simulation_Benchmark(d_mismatch)

Predict disturbances and actively compensate 预测扰动并主动补偿

The speed observer in the code (DYNAMICS_SpeedObserver, line 417) estimates not only rotor speed but also a disturbance state xS[2], which represents the total disturbance — including load torque and modeling errors. When the disturbance feedforward is enabled, this estimate is actively fed forward to the speed controller, compensating for disturbances before the PI regulator has to react. 代码中的速度观测器（DYNAMICS_SpeedObserver，第 417 行）不仅估计转子速度，还估计扰动状态 xS[2]，它代表总扰动——包括负载转矩和建模误差。启用扰动前馈时，该估计值会主动前馈给速度控制器，在 PI 调节器反应之前就补偿扰动。

Observer dynamics观测器动态

where $e_\theta = \theta_d - \hat{\theta}_d$ is the position estimation error and $\ell_1, \ell_2, \ell_3$ are observer gains (configured via omega_ob). 其中 $e_\theta = \theta_d - \hat{\theta}_d$ 是位置估计误差，$\ell_1, \ell_2, \ell_3$ 是观测器增益（通过 omega_ob 配置）。

How to enable如何启用

# After creating Simulation_Benchmark with bool_start_simulation=False,
# modify CTRL before running:
CTRL.index_separate_speed_estimation = 1      # use observer for speed
CTRL.use_disturbance_feedforward_rejection = 1 # feed xS[2] forward
# Mode 2: CTRL.use_disturbance_feedforward_rejection = 2
#   adds correction: xS[2] + ell2 * output_error (faster but noisier)

Required content of the Markdown reportMarkdown 报告要求

Project 3: 4th-order observer, disturbance feedforward, and time-varying load analysis Project 3：四阶观测器、扰动前馈与时变负载分析

From constant disturbance to time-varying disturbance 从恒定扰动到时变扰动

The mechanical equation机械方程

Define the total disturbance $d_{to}$ as everything the controller does not model: 定义总扰动 $d_{to}$ 为控制器未建模的所有内容：

An observer that estimates $d_{to}$ can feed it forward to cancel the disturbance before the PI regulator reacts. The question is: how well can the observer track $d_{to}$ when it changes over time? 估计 $d_{to}$ 的观测器可以将其前馈，在 PI 调节器反应之前就抵消扰动。问题是：当 $d_{to}$ 随时间变化时，观测器能跟踪得多好？

3rd-order observer: assumes constant disturbance三阶观测器：假设扰动恒定

States: $[\hat{\theta}_d,\ \hat{\omega}_r,\ \hat{d}_{to}]$. The internal model assumes $\dot{d}_{to} = 0$.状态：$[\hat{\theta}_d,\ \hat{\omega}_r,\ \hat{d}_{to}]$。内部模型假设 $\dot{d}_{to} = 0$。

Gains placed at $(s + \omega_{ob})^3$:增益配置在 $(s + \omega_{ob})^3$：

4th-order observer: models ramp disturbance四阶观测器：建模斜坡扰动

States: $[\hat{\theta}_d,\ \hat{\omega}_r,\ \hat{d}_{to},\ \hat{p}_{to}]$. The internal model assumes $\dot{d}_{to} = p_{to}$, $\dot{p}_{to} = 0$.状态：$[\hat{\theta}_d,\ \hat{\omega}_r,\ \hat{d}_{to},\ \hat{p}_{to}]$。内部模型假设 $\dot{d}_{to} = p_{to}$，$\dot{p}_{to} = 0$。

Gains placed at $(s + \omega_{ob})^4$:增益配置在 $(s + \omega_{ob})^4$：

Where to find and modify the observer观测器代码位置与修改点

1. Observer gains initialization1. 观测器增益初始化

In The_Motor_Controller.__init__ (around line 165), the observer gains are selected by an if/elif/else chain. Currently the 3rd-order branch is active:在 The_Motor_Controller.__init__（约第 165 行），观测器增益通过 if/elif/else 链选择。当前三阶分支生效：

omega_ob = 100  # [rad/s]
if False:    # 2nd-order speed observer
    ...
elif False:  # 2nd-order position observer
    ...
elif True:   # 3rd-order  <--- CURRENTLY ACTIVE
    self.ell1 = 3 * omega_ob
    self.ell2 = 3 * omega_ob**2
    self.ell3 = omega_ob**3 * init_Js/init_npp
else:        # 4th-order  <--- YOU NEED TO ACTIVATE THIS
    self.ell1 = 4 * omega_ob
    self.ell2 = 6 * omega_ob**2
    self.ell3 = 4 * omega_ob**3 * init_Js/init_npp
    self.ell4 = omega_ob**4

2. Observer dynamics (already supports 4th-order)2. 观测器动态方程（已支持四阶）

def DYNAMICS_SpeedObserver(x, CTRL):
    fx = np.zeros(6)
    output_error = angle_diff(CTRL.theta_d, x[0])
    fx[0] = CTRL.ell1*output_error + x[1]           # theta
    fx[1] = CTRL.ell2*output_error + (CTRL.Tem + x[2]) * CTRL.npp/CTRL.Js  # omega
    fx[2] = CTRL.ell3*output_error + x[3]           # d_to
    fx[3] = CTRL.ell4*output_error + 0.0             # p_to (rate)
    return fx

When ell4 = 0 (3rd-order), x[3] stays zero. When ell4 > 0 (4th-order), x[3] estimates the rate of disturbance change.当 ell4 = 0（三阶）时，x[3] 保持为零。当 ell4 > 0（四阶）时，x[3] 估计扰动变化率。

3. The missing link: feedforward is not wired in!3. 缺失的环节：前馈未接入！

In FOC() (line 638), the speed controller output goes directly to cmd_idq[1]:在 FOC()（第 638 行），速度控制器输出直接赋给 cmd_idq[1]：

# Current code (line 638-639):
if CTRL.bool_apply_speed_closed_loop_control == True:
    CTRL.cmd_idq[1] = reg_speed.Out    # feedforward NOT added!

The observer computes total_disrubance_feedforward (line 757-761) but it is never used. You must wire it in.观测器计算了 total_disrubance_feedforward（第 757-761 行），但从未使用。你需要将其接入。

4. Watch data for plotting4. 画图用的观测数据

sim.gdd['CTRL.xS[2]']       # estimated disturbance (d_to)
sim.gdd['CTRL.xS[3]']       # estimated rate (p_to)
sim.gdd['ACM.TLoad']         # actual load torque
sim.gdd['CTRL.omega_r_mech'] # measured speed [rpm]
sim.gdd['CTRL.cmd_rpm']      # speed command [rpm]

Switch from 3rd-order to 4th-order observer 从三阶切换到四阶观测器

You need a way to select observer order from the d configuration dictionary, without hard-coding if True/if False in source code. 你需要一种方法，从 d 配置字典选择观测器阶数，而不是在源代码中硬编码 if True/if False。

Connect the observer output to the speed controller 将观测器输出连接到速度控制器

The observer estimates disturbance $\hat{d}_{to}$ in torque-like units. To use it as a feedforward, convert to $i_q$ current: 观测器估计的扰动 $\hat{d}_{to}$ 单位类似转矩。要用作前馈，需转换为 $i_q$ 电流：

# BEFORE:
CTRL.cmd_idq[1] = reg_speed.Out

# AFTER:
CTRL.cmd_idq[1] = reg_speed.Out
if CTRL.use_disturbance_feedforward_rejection > 0:
    if CTRL.KA > 0:
        CTRL.cmd_idq[1] += CTRL.total_disrubance_feedforward / (1.5 * CTRL.npp * CTRL.KA)

Prove the 4th-order observer can track ramp disturbance 证明四阶观测器能跟踪斜坡扰动

Ramp load torque setup斜坡负载转矩设置

# In user_system_input_code:
"CTRL.cmd_rpm = 50\n"
"if ii >= 2: ACM.TLoad = 0.05 * (ii - 2) * d['TIME_SLICE']"

This creates a linearly increasing load starting at time slice 2. Adjust the slope (0.05) so the motor doesn't stall.这将从时间片 2 开始创建线性增加的负载。调整斜率（0.05）使电机不会堵转。

What to plot for each scenario每个场景需要画什么

• Subplot 1: Speed command CTRL.cmd_rpm vs actual speed CTRL.omega_r_mech [rpm]子图 1：速度给定 CTRL.cmd_rpm vs 实际速度 CTRL.omega_r_mech [rpm]
• Subplot 2: Actual load ACM.TLoad vs estimated disturbance CTRL.xS[2] (note: opposite sign)子图 2：实际负载 ACM.TLoad vs 估计扰动 CTRL.xS[2]（注意：符号相反）
• Subplot 3: Estimated rate CTRL.xS[3] — should converge to the ramp slope for 4th-order子图 3：估计变化率 CTRL.xS[3]——四阶时应收敛到斜坡斜率

Tracking, disturbance rejection, and noise: the three-way tradeoff 跟踪、抗扰与噪声：三方权衡

A closed-loop system's output can be decomposed into three paths: 闭环系统的输出可以分解为三条通道：

Required content of the Markdown reportMarkdown 报告要求

How to submit 提交方式