【C语言实现PID控制器】

六月悉茗

已于 2024-06-14 09:14:51 修改

阅读量1.7k

点赞数 35

分类专栏： C语言学习报告文章标签： c语言算法

于 2024-06-13 14:41:26 首次发布

本文链接：https://blog.csdn.net/shuting7/article/details/139651805

版权

C语言学习报告专栏收录该内容

88 篇文章 2 订阅

订阅专栏

PID 控制器

PID（比例-积分-微分）控制器的公式用于计算控制信号，基于当前误差、误差的积分以及误差的微分。PID控制器的标准公式如下：

$K_pe(t) + K_i\int_0^te(\tau)d\tau+K_d\frac{de(t)}{dt}$
其中：

$u (t)$ 是控制信号。
$e (t)$ 是当前误差，即设定点（目标值）与实际值（测量值）之间的差。
$K_p$ 是比例增益。
$K_i$ 是积分增益。
$K_d$ 是微分增益。

离散形式下，PID控制器的公式可以表示为：
$K_pe[n] + K_i \sum_{i=0}^ne[i] \Delta t +K_d \frac{e[n]-e[n-1]}{ \Delta t}$
其中：

$u [n]$ 是第 $n$ 个采样时刻的控制信号。
$e [n]$ 是第 $n$ 个采样时刻的误差。
$\Delta t$ 是采样周期。

PID控制器的C语言实现

根据上述公式，可以用C语言实现一个离散PID控制器。以下是实现过程：

变量定义和初始化

#include <stdio.h>

// PID控制器参数
float Kp = 1.0; // 比例增益
float Ki = 0.1; // 积分增益
float Kd = 0.05; // 微分增益

// PID控制器状态
float integral = 0.0; // 误差的积分
float previous_error = 0.0; // 上一次的误差

PID 控制器函数

实现一个函数来计算控制信号：

float PID_Controller(float setpoint, float measured_value, float dt) {
    // 计算误差
    float error = setpoint - measured_value;

    // 计算误差的积分
    integral += error * dt;

    // 计算误差的微分
    float derivative = (error - previous_error) / dt;

    // 计算控制信号
    float control_signal = Kp * error + Ki * integral + Kd * derivative;

    // 更新上一次的误差
    previous_error = error;

    return control_signal;
}

主循环

在循环中使用PID控制器函数来更新控制信号：

int main() {
    float setpoint = 1.0; // 目标设定点
    float measured_value = 0.0; // 测量的过程变量
    float control_signal = 0.0; // 控制信号
    float dt = 0.1; // 时间步长（秒）

    // 模拟循环
    for (int i = 0; i < 100; i++) {
        // 模拟过程（这是一个示例，需要替换为你的过程模型）
        measured_value += control_signal * dt;

        // 使用 PID 控制器计算控制信号
        control_signal = PID_Controller(setpoint, measured_value, dt);

        // 打印结果
        printf("时间: %.2f, 设定点: %.2f, 测量值: %.2f, 控制信号: %.2f\n", i * dt, setpoint, measured_value, control_signal);
    }

    return 0;
}

考虑事项：

参数调节：需要针对具体系统调节 $K_p$ 、 $K_i$ 和 $K_d$ 增益以获得期望的性能。
积分饱和：实际应用中，可能需要添加逻辑防止积分项过大（积分饱和）。

这是一个基础的PID控制器示例，可以根据需要添加更多功能，如积分抗饱和机制、更高级的数值积分方法等。

动态调整 PID 控制器的参数（ $K_p$ 、 $K_i$ 和 $K_d$ ）

示例1

这种方法被称为自适应控制或增量控制。以下是一个示例，展示了如何根据测量结果动态调整 PID 控制器的增益。

#include <stdio.h>

// PID 控制器参数
float Kp = 1.0; // 初始比例增益
float Ki = 0.1; // 初始积分增益
float Kd = 0.05; // 初始微分增益

// PID 控制器状态
float integral = 0.0; // 误差的积分
float previous_error = 0.0; // 上一次的误差

// 更新 PID 参数的函数
void Update_PID_Gains(float error) {
    // 这里是一个简单的示例，可以根据误差调整增益
    if (error > 0.5) {
        Kp += 0.1;
        Ki += 0.01;
        Kd += 0.005;
    } else if (error < -0.5) {
        Kp -= 0.1;
        Ki -= 0.01;
        Kd -= 0.005;
    }
    
    // 防止增益变为负值
    if (Kp < 0) Kp = 0;
    if (Ki < 0) Ki = 0;
    if (Kd < 0) Kd = 0;
}

// PID 控制器函数
float PID_Controller(float setpoint, float measured_value, float dt) {
    // 计算误差
    float error = setpoint - measured_value;

    // 计算误差的积分
    integral += error * dt;

    // 计算误差的微分
    float derivative = (error - previous_error) / dt;

    // 计算控制信号
    float control_signal = Kp * error + Ki * integral + Kd * derivative;

    // 更新上一次的误差
    previous_error = error;

    // 更新 PID 增益
    Update_PID_Gains(error);

    return control_signal;
}

int main() {
    float setpoint = 1.0; // 目标设定点
    float measured_value = 0.0; // 测量的过程变量
    float control_signal = 0.0; // 控制信号
    float dt = 0.1; // 时间步长（秒）

    // 模拟循环
    for (int i = 0; i < 100; i++) {
        // 模拟过程（这是一个示例，需要替换为你的过程模型）
        measured_value += control_signal * dt;

        // 使用 PID 控制器计算控制信号
        control_signal = PID_Controller(setpoint, measured_value, dt);

        // 打印结果
        printf("时间: %.2f, 设定点: %.2f, 测量值: %.2f, 控制信号: %.2f, Kp: %.2f, Ki: %.2f, Kd: %.2f\n", i * dt, setpoint, measured_value, control_signal, Kp, Ki, Kd);
    }

    return 0;
}

示例2

#include <stdio.h>  
  
// PID结构体  
typedef struct {  
    double setpoint;          // 设定点  
    double kp;                // 比例系数  
    double ki;                // 积分系数  
    double kd;                // 微分系数  
    double previous_error;    // 上一次的误差  
    double integral;          // 积分项  
} PID;  
  
// PID初始化函数  
void PID_Init(PID* pid, double setpoint, double kp, double ki, double kd) {  
    pid->setpoint = setpoint;  
    pid->kp = kp;  
    pid->ki = ki;  
    pid->kd = kd;  
    pid->previous_error = 0.0;  
    pid->integral = 0.0;  
}  
  
// PID计算函数  
double PID_Compute(PID* pid, double input) {  
    double error = pid->setpoint - input; // 计算误差  
  
    // P = kp * error  
    double p = pid->kp * error;  
  
    // I = ki * integral  
    pid->integral += error;  
    double i = pid->ki * pid->integral;  
  
    // D = kd * (error - previous_error) / dt  
    // 假设dt为1（即每次调用间隔为1个时间单位），所以简化为：  
    double d = pid->kd * (error - pid->previous_error);  
  
    // 更新误差以供下一次使用  
    pid->previous_error = error;  
  
    // 返回PID输出  
    return p + i + d;  
}  
  
 
// 假设的性能评估函数  
// 在实际应用中，这通常基于系统的实际性能  
double evaluate_performance(double output, double setpoint) {  
    // 返回一个评估值，例如基于误差的绝对值或其他指标  
    double error = setpoint - output;  
    return fabs(error); // 绝对误差作为示例  
}  
  
// 根据规则调整PID参数  
void adjust_pid_parameters(PID* pid, double input, double output, double setpoint) {  
    double error = setpoint - output;  
    double derivative = error - pid->previous_error; // 假设dt为1  
  
    // 评估当前性能  
    double performance = evaluate_performance(output, setpoint);  
  
    // 假设的调整规则（根据实际需求调整）  
    if (performance > 10.0) { // 假设的性能阈值  
        // 如果性能不佳，增加Kp  
        pid->kp *= 1.1;  
        // 也可以考虑减少Ki和Kd，以避免积分饱和和微分噪声  
        // pid->ki *= 0.9;  
        // pid->kd *= 0.9;  
    } else if (pid->integral > 100.0) { // 假设的积分阈值  
        // 如果积分项过大，减少Ki  
        pid->ki *= 0.9;  
    }  
    // 可以添加更多规则来调整Kd等  
  
    // 更新误差以供下一次使用  
    pid->previous_error = error;  
}  
  
int main() {  
    PID pid;  
    PID_Init(&pid, 100.0, 1.0, 0.1, 0.01); // 初始化PID  
  
    double input = 0.0; // 假设的当前输入值  
    double output;  
  
    // 示例：模拟PID控制过程（假设输入值在某个过程中变化）  
    for (int i = 0; i < 100; i++) {  
        // 假设输入值在某个过程中逐渐接近设定点  
        input = i;  
  
        // 计算PID输出  
        output = PID_Compute(&pid, input);  
  
        // 在这里，你可以将output应用于系统，例如控制电机的速度或位置  
  
        // 评估当前性能并调整PID参数  
        adjust_pid_parameters(&pid, input, output, pid.setpoint);  
  
        // 打印调试信息  
        printf("Input: %f, Output: %f, Setpoint: %f, Error: %f\n", input, output, pid.setpoint, pid.setpoint - output);  
    }  
  
    return 0;  
}

示例3

#include <stdio.h>
#include <math.h>

typedef struct {
    double Kp;    // 比例增益
    double Ki;    // 积分增益
    double Kd;    // 微分增益
    double setPoint; // 设定值
    double output; // 控制器输出
    double lastError; // 上一次的误差
    double integral; // 误差积分
} PIDController;

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->output = 0.0;
    pid->lastError = 0.0;
    pid->integral = 0.0;
}

void PID_Update(PIDController *pid, double measuredValue, double dt) {
    double error = pid->setPoint - measuredValue;
    pid->integral += error * dt;
    double derivative = (error - pid->lastError) / dt;
    pid->output = pid->Kp * error + pid->Ki * pid->integral + pid->Kd * derivative;
    pid->lastError = error;
}

// 简单的自适应规则，根据误差调整Kp, Ki, Kd
void Adapt_PID(PIDController *pid, double error, double dt) {
    // 这里只是一个示例，实际的自适应规则可能更复杂
    if (fabs(error) > 1.0) {
        pid->Kp *= 1.1; // 如果误差较大，增加Kp
        pid->Ki *= 1.1; // 增加Ki
        pid->Kd *= 0.9; // 减少Kd
    } else {
        pid->Kp *= 0.9; // 如果误差较小，减少Kp
        pid->Ki *= 0.9; // 减少Ki
        pid->Kd *= 1.1; // 增加Kd
    }
}

int main() {
    PIDController pid;
    PID_Init(&pid, 1.0, 0.1, 0.05, 100.0);
    double measuredValue = 0.0;
    double dt = 0.01;

    for (int i = 0; i < 1000; i++) {
        measuredValue = 100.0 * sin(0.1 * i * dt);
        PID_Update(&pid, measuredValue, dt);
        Adapt_PID(&pid, pid.setPoint - measuredValue, dt); // 根据误差自适应调整参数
        printf("Measured Value: %f, PID Output: %f, Kp: %f, Ki: %f, Kd: %f\n",
               measuredValue, pid.output, pid.Kp, pid.Ki, pid.Kd);
    }

    return 0;
}