聊聊［PID］

原创已于 2025-10-13 13:13:54 修改 · 1k 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#python #开发语言

于 2025-10-13 08:45:00 首次发布

PID Control Overview

A PID controller (Proportional-Integral-Derivative controller) is a feedback control mechanism widely used in industrial control systems. It continuously calculates an error value as the difference between a desired setpoint and a measured process variable, then applies corrective action based on proportional, integral, and derivative terms.

PID Components

Proportional (P):

Adjusts the output in proportion to the current error.
Formula:
$$ P = K_p \cdot e(t) $$
Where ( K_p ) is the proportional gain, and ( e(t) ) is the error at time ( t ).

Integral (I):

Eliminates steady-state error by integrating past errors.
Formula:
$$ I = K_i \cdot \int_0^t e(\tau) d\tau $$
Where ( K_i ) is the integral gain.

Derivative (D):

Predicts future error trends based on the rate of change.
Formula:
$$ D = K_d \cdot \frac{de(t)}{dt} $$
Where ( K_d ) is the derivative gain.

Combined PID Output

The total control output ( u(t) ) is the sum of the three terms:
$$ u(t) = K_p e(t) + K_i \int_0^t e(\tau) d\tau + K_d \frac{de(t)}{dt} $$

Applications

Temperature control in HVAC systems.
Motor speed regulation.
Robotics and autonomous vehicles.

Tuning Methods

Manual Tuning: Adjust ( K_p ), ( K_i ), and ( K_d ) empirically.
Ziegler-Nichols: A systematic method to determine gains.
Software Tools: Use MATLAB or Python libraries for optimization.

Example Code (Python)

import numpy as np

class PIDController:
    def __init__(self, Kp, Ki, Kd):
        self.Kp = Kp
        self.Ki = Ki
        self.Kd = Kd
        self.prev_error = 0
        self.integral = 0

    def compute(self, setpoint, measured_value, dt):
        error = setpoint - measured_value
        self.integral += error * dt
        derivative = (error - self.prev_error) / dt
        output = self.Kp * error + self.Ki * self.integral + self.Kd * derivative
        self.prev_error = error
        return output

Key Considerations

Stability: Poorly tuned gains can cause oscillations or instability.
Noise Sensitivity: Derivative term may amplify high-frequency noise.
Real-World Limits: Actuator saturation should be accounted for.

PID控制器的C代码实现

PID（比例-积分-微分）控制器是一种常见的反馈控制算法，广泛应用于工业控制系统中。以下是一个简单的PID控制器实现代码：

#include <stdio.h>
#include <time.h>

typedef struct {
    double Kp;          // 比例增益
    double Ki;          // 积分增益
    double Kd;          // 微分增益
    double setpoint;    // 目标值
    double integral;    // 积分项累计
    double prev_error;  // 上一次误差
    clock_t prev_time;  // 上一次时间
} PIDController;

// 初始化PID控制器
void PID_Init(PIDController* pid, double Kp, double Ki, double Kd, double setpoint) {
    pid->Kp = Kp;
    pid->Ki = Ki;
    pid->Kd = Kd;
    pid->setpoint = setpoint;
    pid->integral = 0.0;
    pid->prev_error = 0.0;
    pid->prev_time = clock();
}

// 计算PID输出
double PID_Compute(PIDController* pid, double input) {
    // 计算时间差（秒）
    clock_t now = clock();
    double dt = (double)(now - pid->prev_time) / CLOCKS_PER_SEC;
    
    // 避免除以零
    if (dt <= 0) dt = 1e-6;
    
    // 计算误差
    double error = pid->setpoint - input;
    
    // 比例项
    double P = pid->Kp * error;
    
    // 积分项（抗饱和处理）
    pid->integral += error * dt;
    double I = pid->Ki * pid->integral;
    
    // 微分项
    double derivative = (error - pid->prev_error) / dt;
    double D = pid->Kd * derivative;
    
    // 计算输出
    double output = P + I + D;
    
    // 保存状态
    pid->prev_error = error;
    pid->prev_time = now;
    
    return output;
}

// 示例使用
int main() {
    PIDController pid;
    PID_Init(&pid, 1.0, 0.1, 0.01, 100.0); // 设置PID参数和目标值
    
    double process_value = 0.0; // 模拟过程变量
    
    for (int i = 0; i < 100; i++) {
        double output = PID_Compute(&pid, process_value);
        process_value += output * 0.1; // 简单模拟系统响应
        
        printf("Setpoint: %.2f, PV: %.2f, Output: %.2f\n", 
               pid.setpoint, process_value, output);
    }
    
    return 0;
}