【C语言实现PID控制器】

PID 控制器

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

u ( t ) = K p e ( t ) + K i ∫ 0 t e ( τ ) d τ + K d d e ( t ) d t u(t) = K_pe(t) + K_i\int_0^te(\tau)d\tau+K_d\frac{de(t)}{dt} u(t)=Kp​e(t)+Ki​∫0t​e(τ)dτ+Kd​dtde(t)​
其中：

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

离散形式下，PID控制器的公式可以表示为：
u [ n ] = K p e [ n ] + K i ∑ i = 0 n e [ i ] Δ t + K d e [ n ] − e [ n − 1 ] Δ t u[n] = K_pe[n] + K_i \sum_{i=0}^ne \Delta t +K_d \frac{e[n]-e[n-1]}{ \Delta t} u[n]=Kp​e[n]+Ki​i=0∑n​eΔt+Kd​Δte[n]−e[n−1]​
其中：

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

PID控制器的C语言实现

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

变量定义和初始化

1. #include <stdio.h>
3. // PID控制器参数
4. float Kp = 1.0; // 比例增益
5. float Ki = 0.1; // 积分增益
6. float Kd = 0.05; // 微分增益
8. // PID控制器状态
9. float integral = 0.0; // 误差的积分
10. float previous_error = 0.0; // 上一次的误差

复制代码

PID 控制器函数

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

1. float PID_Controller(float setpoint, float measured_value, float dt) {
2. // 计算误差
3. float error = setpoint - measured_value;
5. // 计算误差的积分
6. integral += error * dt;
8. // 计算误差的微分
9. float derivative = (error - previous_error) / dt;
11. // 计算控制信号
12. float control_signal = Kp * error + Ki * integral + Kd * derivative;
14. // 更新上一次的误差
15. previous_error = error;
17. return control_signal;
18. }

复制代码

主循环

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

1. int main() {
2. float setpoint = 1.0; // 目标设定点
3. float measured_value = 0.0; // 测量的过程变量
4. float control_signal = 0.0; // 控制信号
5. float dt = 0.1; // 时间步长（秒）
7. // 模拟循环
8. for (int i = 0; i < 100; i++) {
9. // 模拟过程（这是一个示例，需要替换为你的过程模型）
10. measured_value += control_signal * dt;
12. // 使用 PID 控制器计算控制信号
13. control_signal = PID_Controller(setpoint, measured_value, dt);
15. // 打印结果
16. printf("时间: %.2f, 设定点: %.2f, 测量值: %.2f, 控制信号: %.2f\n", i * dt, setpoint, measured_value, control_signal);
17. }
19. return 0;
20. }

复制代码

考虑事项：

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

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

动态调整 PID 控制器的参数（ K p K_p Kp​、 K i K_i Ki​ 和 K d K_d Kd​ ）

示例1

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

1. #include <stdio.h>
3. // PID 控制器参数
4. float Kp = 1.0; // 初始比例增益
5. float Ki = 0.1; // 初始积分增益
6. float Kd = 0.05; // 初始微分增益
8. // PID 控制器状态
9. float integral = 0.0; // 误差的积分
10. float previous_error = 0.0; // 上一次的误差
12. // 更新 PID 参数的函数
13. void Update_PID_Gains(float error) {
14. // 这里是一个简单的示例，可以根据误差调整增益
15. if (error > 0.5) {
16. Kp += 0.1;
17. Ki += 0.01;
18. Kd += 0.005;
19. } else if (error < -0.5) {
20. Kp -= 0.1;
21. Ki -= 0.01;
22. Kd -= 0.005;
23. }
25. // 防止增益变为负值
26. if (Kp < 0) Kp = 0;
27. if (Ki < 0) Ki = 0;
28. if (Kd < 0) Kd = 0;
29. }
31. // PID 控制器函数
32. float PID_Controller(float setpoint, float measured_value, float dt) {
33. // 计算误差
34. float error = setpoint - measured_value;
36. // 计算误差的积分
37. integral += error * dt;
39. // 计算误差的微分
40. float derivative = (error - previous_error) / dt;
42. // 计算控制信号
43. float control_signal = Kp * error + Ki * integral + Kd * derivative;
45. // 更新上一次的误差
46. previous_error = error;
48. // 更新 PID 增益
49. Update_PID_Gains(error);
51. return control_signal;
52. }
54. int main() {
55. float setpoint = 1.0; // 目标设定点
56. float measured_value = 0.0; // 测量的过程变量
57. float control_signal = 0.0; // 控制信号
58. float dt = 0.1; // 时间步长（秒）
60. // 模拟循环
61. for (int i = 0; i < 100; i++) {
62. // 模拟过程（这是一个示例，需要替换为你的过程模型）
63. measured_value += control_signal * dt;
65. // 使用 PID 控制器计算控制信号
66. control_signal = PID_Controller(setpoint, measured_value, dt);
68. // 打印结果
69. printf("时间: %.2f, 设定点: %.2f, 测量值: %.2f, 控制信号: %.2f, Kp: %.2f, Ki: %.2f, Kd: %.2f\n", i * dt, setpoint, measured_value, control_signal, Kp, Ki, Kd);
70. }
72. return 0;
73. }

复制代码

示例2

1. #include <stdio.h>
3. // PID结构体
4. typedef struct {
5. double setpoint; // 设定点
6. double kp; // 比例系数
7. double ki; // 积分系数
8. double kd; // 微分系数
9. double previous_error; // 上一次的误差
10. double integral; // 积分项
11. } PID;
13. // PID初始化函数
14. void PID_Init(PID* pid, double setpoint, double kp, double ki, double kd) {
15. pid->setpoint = setpoint;
16. pid->kp = kp;
17. pid->ki = ki;
18. pid->kd = kd;
19. pid->previous_error = 0.0;
20. pid->integral = 0.0;
21. }
23. // PID计算函数
24. double PID_Compute(PID* pid, double input) {
25. double error = pid->setpoint - input; // 计算误差
27. // P = kp * error
28. double p = pid->kp * error;
30. // I = ki * integral
31. pid->integral += error;
32. double i = pid->ki * pid->integral;
34. // D = kd * (error - previous_error) / dt
35. // 假设dt为1（即每次调用间隔为1个时间单位），所以简化为：
36. double d = pid->kd * (error - pid->previous_error);
38. // 更新误差以供下一次使用
39. pid->previous_error = error;
41. // 返回PID输出
42. return p + i + d;
43. }
46. // 假设的性能评估函数
47. // 在实际应用中，这通常基于系统的实际性能
48. double evaluate_performance(double output, double setpoint) {
49. // 返回一个评估值，例如基于误差的绝对值或其他指标
50. double error = setpoint - output;
51. return fabs(error); // 绝对误差作为示例
52. }
54. // 根据规则调整PID参数
55. void adjust_pid_parameters(PID* pid, double input, double output, double setpoint) {
56. double error = setpoint - output;
57. double derivative = error - pid->previous_error; // 假设dt为1
59. // 评估当前性能
60. double performance = evaluate_performance(output, setpoint);
62. // 假设的调整规则（根据实际需求调整）
63. if (performance > 10.0) { // 假设的性能阈值
64. // 如果性能不佳，增加Kp
65. pid->kp *= 1.1;
66. // 也可以考虑减少Ki和Kd，以避免积分饱和和微分噪声
67. // pid->ki *= 0.9;
68. // pid->kd *= 0.9;
69. } else if (pid->integral > 100.0) { // 假设的积分阈值
70. // 如果积分项过大，减少Ki
71. pid->ki *= 0.9;
72. }
73. // 可以添加更多规则来调整Kd等
75. // 更新误差以供下一次使用
76. pid->previous_error = error;
77. }
79. int main() {
80. PID pid;
81. PID_Init(&pid, 100.0, 1.0, 0.1, 0.01); // 初始化PID
83. double input = 0.0; // 假设的当前输入值
84. double output;
86. // 示例：模拟PID控制过程（假设输入值在某个过程中变化）
87. for (int i = 0; i < 100; i++) {
88. // 假设输入值在某个过程中逐渐接近设定点
89. input = i;
91. // 计算PID输出
92. output = PID_Compute(&pid, input);
94. // 在这里，你可以将output应用于系统，例如控制电机的速度或位置
96. // 评估当前性能并调整PID参数
97. adjust_pid_parameters(&pid, input, output, pid.setpoint);
99. // 打印调试信息
100. printf("Input: %f, Output: %f, Setpoint: %f, Error: %f\n", input, output, pid.setpoint, pid.setpoint - output);
101. }
103. return 0;
104. }

复制代码

示例3

1. #include <stdio.h>
2. #include <math.h>
4. typedef struct {
5. double Kp; // 比例增益
6. double Ki; // 积分增益
7. double Kd; // 微分增益
8. double setPoint; // 设定值
9. double output; // 控制器输出
10. double lastError; // 上一次的误差
11. double integral; // 误差积分
12. } PIDController;
14. void PID_Init(PIDController *pid, double Kp, double Ki, double Kd, double setPoint) {
15. pid->Kp = Kp;
16. pid->Ki = Ki;
17. pid->Kd = Kd;
18. pid->setPoint = setPoint;
19. pid->output = 0.0;
20. pid->lastError = 0.0;
21. pid->integral = 0.0;
22. }
24. void PID_Update(PIDController *pid, double measuredValue, double dt) {
25. double error = pid->setPoint - measuredValue;
26. pid->integral += error * dt;
27. double derivative = (error - pid->lastError) / dt;
28. pid->output = pid->Kp * error + pid->Ki * pid->integral + pid->Kd * derivative;
29. pid->lastError = error;
30. }
32. // 简单的自适应规则，根据误差调整Kp, Ki, Kd
33. void Adapt_PID(PIDController *pid, double error, double dt) {
34. // 这里只是一个示例，实际的自适应规则可能更复杂
35. if (fabs(error) > 1.0) {
36. pid->Kp *= 1.1; // 如果误差较大，增加Kp
37. pid->Ki *= 1.1; // 增加Ki
38. pid->Kd *= 0.9; // 减少Kd
39. } else {
40. pid->Kp *= 0.9; // 如果误差较小，减少Kp
41. pid->Ki *= 0.9; // 减少Ki
42. pid->Kd *= 1.1; // 增加Kd
43. }
44. }
46. int main() {
47. PIDController pid;
48. PID_Init(&pid, 1.0, 0.1, 0.05, 100.0);
49. double measuredValue = 0.0;
50. double dt = 0.01;
52. for (int i = 0; i < 1000; i++) {
53. measuredValue = 100.0 * sin(0.1 * i * dt);
54. PID_Update(&pid, measuredValue, dt);
55. Adapt_PID(&pid, pid.setPoint - measuredValue, dt); // 根据误差自适应调整参数
56. printf("Measured Value: %f, PID Output: %f, Kp: %f, Ki: %f, Kd: %f\n",
57. measuredValue, pid.output, pid.Kp, pid.Ki, pid.Kd);
58. }
60. return 0;
61. }

复制代码