遗传算法优化 PID 控制器的 C 语言实现 - 杨月昌的硬件开发技术博客

1. 为什么使用遗传算法整定 PID？#

在复杂的非线性、大滞后硬件系统中，传统的齐格勒-尼科尔斯（Z-N）法往往难以获取理想的参数。遗传算法（Genetic Algorithm）通过模拟“物竞天择”的生物进化过程，能够有效跳出局部最优，自动搜索出使系统性能指标最优的全局解。

核心进化逻辑：#

个体编码：将 (Kp, Ki, Kd) 三个参数视为个体的染色体，通常采用实数编码。
适应度评估：这是算法的“灵魂”，决定了什么是“好”的 PID 参数组合。
算子操作：
- 选择（Selection）：保留优良基因。
- 交叉（Crossover）：融合父母代优势，探索新搜索区域。
- 变异（Mutation）：引入随机扰动，维持种群多样性，防止早熟收敛。

2. 适应度函数设计：引入 ITAE 指标#

在原始博文中，适应度仅根据绝对误差计算。在工业控制领域，我们推荐采用 ITAE（时间乘绝对误差积分） 指标。ITAE 对系统后期的残余误差惩罚更重，有助于获得更好的快速性、无超调和平稳性。

对应的适应度函数可设计为： [ fitness = \frac{1}{ITAE + \epsilon} ] 其中 ( ITAE = \int_0^{t_{sim}} t |e(t)| , dt )，(\epsilon) 是一个很小的正数（如 0.0001），用于防止除以零。

3. C 语言代码实现#

以下是优化后的 C 代码，增强了结构体、边界约束、交叉/变异算子的完整性和精英保留策略。

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <math.h>
4
#include <time.h>
5

6
#define POP_SIZE 100        // 种群规模，可根据嵌入式资源调整
7
#define MAX_GEN 200         // 最大迭代代数
8
#define MUTATION_RATE 0.05  // 变异率建议 0.01~0.1
9
#define CROSS_RATE 0.8      // 交叉率
10

11
typedef struct {
12
    float Kp, Ki, Kd;
13
    float fitness;
14
} Individual;
15

16
// 随机数生成：[min, max]
17
float rand_range(float min, float max) {
18
    return min + ((float)rand() / RAND_MAX) * (max - min);
19
}
20

21
// 参数钳位，防止出现物理上不可实现的负值
22
void clamp_params(Individual *ind) {
23
    if (ind->Kp < 0.0f) ind->Kp = 0.0f;
24
    if (ind->Ki < 0.0f) ind->Ki = 0.0f;
25
    if (ind->Kd < 0.0f) ind->Kd = 0.0f;
26
}
27

28
// 核心：模拟系统响应并计算适应度 (基于 ITAE)
29
// 注意：在实际硬件/嵌入式应用中，此函数应替换为真实的系统仿真或实时误差采集
30
// 示例中用简单距离演示，实际项目中必须替换
31
float evaluate_fitness(Individual *ind) {
32
    // TODO: 这里实现实际的系统响应仿真，计算 e(t) = r(t) - y(t)
33
    // 以下为演示逻辑，实际项目中必须替换
34
    float total_error = fabs(ind->Kp - 4.5f) + fabs(ind->Ki - 0.2f) + fabs(ind->Kd - 1.1f);
35
    return 1.0f / (total_error + 0.0001f);
36
}
37

38
// 轮盘赌选择
39
int roulette_wheel_selection(Individual *pop, float total_f) {
40
    float r = rand_range(0, total_f);
41
    float sum = 0;
42
    for (int i = 0; i < POP_SIZE; i++) {
43
        sum += pop[i].fitness;
44
        if (sum >= r) return i;
45
    }
46
    return POP_SIZE - 1;
47
}
48

49
// 算法主循环
50
void run_ga() {
51
    Individual population[POP_SIZE];
52
    Individual next_gen[POP_SIZE];
53

54
    srand(time(NULL));  // 初始化随机种子
55

56
    // 1. 初始化种群
57
    for (int i = 0; i < POP_SIZE; i++) {
58
        population[i].Kp = rand_range(0.1f, 20.0f);  // 给予合理初始范围
59
        population[i].Ki = rand_range(0.0f, 10.0f);
60
        population[i].Kd = rand_range(0.0f, 5.0f);
61
        clamp_params(&population[i]);
62
    }
63

64
    for (int gen = 0; gen < MAX_GEN; gen++) {
65
        float total_f = 0.0f;
66
        int best_idx = 0;
67

68
        // 2. 适应度评估
69
        for (int i = 0; i < POP_SIZE; i++) {
70
            population[i].fitness = evaluate_fitness(&population[i]);
71
            total_f += population[i].fitness;
72
            if (population[i].fitness > population[best_idx].fitness) {
73
                best_idx = i;
74
            }
75
        }
76

77
        if (gen % 20 == 0 || gen == MAX_GEN - 1) {
78
            Individual *best = &population[best_idx];
79
            printf("Gen %d: Best [P=%.3f I=%.3f D=%.3f] Fit=%.4f\n",
80
                   gen, best->Kp, best->Ki, best->Kd, best->fitness);
81
        }
82

83
        // 3. 精英保留策略
84
        next_gen[0] = population[best_idx];
85

86
        // 4. 产生下一代
87
        for (int i = 1; i < POP_SIZE; i += 2) {
88
            int p1 = roulette_wheel_selection(population, total_f);
89
            int p2 = roulette_wheel_selection(population, total_f);
90

91
            Individual child1 = population[p1];
92
            Individual child2 = population[p2];
93

94
            // 算术交叉
95
            if (rand_range(0, 1) < CROSS_RATE) {
96
                float alpha = rand_range(0, 1);
97
                child1.Kp = alpha * population[p1].Kp + (1 - alpha) * population[p2].Kp;
98
                child1.Ki = alpha * population[p1].Ki + (1 - alpha) * population[p2].Ki;
99
                child1.Kd = alpha * population[p1].Kd + (1 - alpha) * population[p2].Kd;
100

101
                child2.Kp = alpha * population[p2].Kp + (1 - alpha) * population[p1].Kp;
102
                child2.Ki = alpha * population[p2].Ki + (1 - alpha) * population[p1].Ki;
103
                child2.Kd = alpha * population[p2].Kd + (1 - alpha) * population[p1].Kd;
104
            }
105

106
            // 变异
107
            if (rand_range(0, 1) < MUTATION_RATE) {
108
                child1.Kp += rand_range(-1.0f, 1.0f);
109
                child1.Ki += rand_range(-0.5f, 0.5f);
110
                child1.Kd += rand_range(-0.3f, 0.3f);
111
            }
112
            if (rand_range(0, 1) < MUTATION_RATE) {
113
                child2.Kp += rand_range(-1.0f, 1.0f);
114
                child2.Ki += rand_range(-0.5f, 0.5f);
115
                child2.Kd += rand_range(-0.3f, 0.3f);
116
            }
117

118
            clamp_params(&child1);
119
            clamp_params(&child2);
120

121
            next_gen[i] = child1;
122
            if (i + 1 < POP_SIZE) next_gen[i + 1] = child2;
123
        }
124

125
        // 复制下一代到当前种群
126
        for (int i = 0; i < POP_SIZE; i++) {
127
            population[i] = next_gen[i];
128
        }
129
    }
130
}
131

132
int main() {
133
    run_ga();
134
    return 0;
135
}

4. 关键设计细节优化#

4.1 交叉算子的改进#

原博文中交叉实现不完整。在硬件参数整定中，推荐使用算术交叉（Arithmetic Crossover）。这种方法生成的子代参数自然处于父母参数之间，能较好地保持在合理搜索空间内。

4.2 避免“早熟”与收敛性#

参数边界约束：通过钳位函数确保 Kp, Ki, Kd 不出现负值。
精英保留策略（Elitism）：始终将当代最优个体直接复制到下一代，防止算法退化。
种群多样性：合理设置变异率，并在嵌入式系统中可考虑自适应变异。
计算资源考虑：在资源受限的MCU上，可适当减小 POP_SIZE 和 MAX_GEN，或采用定点数运算。

5. 结论#

遗传算法为 PID 参数整定提供了一种鲁棒、高效的“自适应”解决方案。通过在嵌入式系统中用 C 语言实现该算法，可以让硬件设备具备真正的自整定（Auto-Tuning） 能力，大幅降低人工调试成本，提升控制性能。