遗传算法（Genetic Algorithm, GA）是一种基于自然选择和遗传机制的优化算法，广泛应用于复杂的参数优化问题。对于PID控制器，遗传算法可以用于自动调节比例（Kp）、积分（Ki）和微分（Kd）系数，以达到最佳控制效果。遗传算法通过模拟自然进化过程，包括选择、交叉、变异等操作，不断优化PID参数，最终得到适合给定系统的最优PID参数。

在本实现中，我们将通过遗传算法来优化PID控制器的三个参数。遗传算法的核心流程包括：

1. 初始化种群：生成一组随机的PID参数作为种群。
2. 适应度评估：根据某个性能指标（例如系统误差或控制精度）计算适应度函数，评估每个个体的好坏。
3. 选择操作：根据适应度选择优良的个体进行繁殖。
4. 交叉操作：模拟基因的交叉操作，生成新一代个体。
5. 变异操作：对部分个体进行随机变异，以增加多样性，防止早熟。
6. 迭代更新：通过多代的迭代优化PID参数。

以下是实现遗传算法优化PID控制器的C语言代码：

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

#define POP_SIZE 50  // 种群大小
#define MAX_GEN 100  // 最大代数
#define MUTATION_RATE 0.1 // 变异率
#define CROSSOVER_RATE 0.7 // 交叉率

typedef struct {
    float Kp;  // 比例系数
    float Ki;  // 积分系数
    float Kd;  // 微分系数
} PIDParams;

// 随机数生成器
float random_float(float min, float max) {
    return min + (rand() / (RAND_MAX / (max - min)));
}

// 计算PID控制器的适应度
float fitness(PIDParams pid, float setpoint) {
    // 假设误差随着PID参数的变化而变化（这里可以根据实际需求调整）
    float error = fabs(setpoint - (pid.Kp + pid.Ki + pid.Kd)); // 简单的误差模型
    return 1.0 / (1.0 + error);  // 适应度越高，误差越小
}

// 初始化种群
void init_population(PIDParams population[POP_SIZE], float Kp_min, float Kp_max, 
                     float Ki_min, float Ki_max, float Kd_min, float Kd_max) {
    for (int i = 0; i < POP_SIZE; i++) {
        population[i].Kp = random_float(Kp_min, Kp_max);
        population[i].Ki = random_float(Ki_min, Ki_max);
        population[i].Kd = random_float(Kd_min, Kd_max);
    }
}

// 选择操作（轮盘赌选择法）
int selection(PIDParams population[POP_SIZE], float setpoint) {
    float total_fitness = 0.0;
    float fitness_sum[POP_SIZE];
    float rand_value;
    int selected = 0;

    // 计算总适应度
    for (int i = 0; i < POP_SIZE; i++) {
        total_fitness += fitness(population[i], setpoint);
    }

    // 累积适应度
    fitness_sum[0] = fitness(population[0], setpoint) / total_fitness;
    for (int i = 1; i < POP_SIZE; i++) {
        fitness_sum[i] = fitness_sum[i - 1] + fitness(population[i], setpoint) / total_fitness;
    }

    // 随机选择
    rand_value = (float)rand() / RAND_MAX;
    for (int i = 0; i < POP_SIZE; i++) {
        if (rand_value < fitness_sum[i]) {
            selected = i;
            break;
        }
    }

    return selected;
}

// 交叉操作（单点交叉）
void crossover(PIDParams parent1, PIDParams parent2, PIDParams *offspring1, PIDParams *offspring2) {
    if ((float)rand() / RAND_MAX < CROSSOVER_RATE) {
        // 交叉点选择
        float crossover_point = (float)rand() / RAND_MAX;

        offspring1->Kp = crossover_point * parent1.Kp + (1 - crossover_point) * parent2.Kp;
        offspring1->Ki = crossover_point * parent1.Ki + (1 - crossover_point) * parent2.Ki;
        offspring1->Kd = crossover_point * parent1.Kd + (1 - crossover_point) * parent2.Kd;

        offspring2->Kp = (1 - crossover_point) * parent1.Kp + crossover_point * parent2.Kp;
        offspring2->Ki = (1 - crossover_point) * parent1.Ki + crossover_point * parent2.Ki;
        offspring2->Kd = (1 - crossover_point) * parent1.Kd + crossover_point * parent2.Kd;
    } else {
        // 无交叉，直接复制父代
        *offspring1 = parent1;
        *offspring2 = parent2;
    }
}

// 变异操作（随机变异）
void mutation(PIDParams *individual, float Kp_min, float Kp_max, 
              float Ki_min, float Ki_max, float Kd_min, float Kd_max) {
    if ((float)rand() / RAND_MAX < MUTATION_RATE) {
        individual->Kp = random_float(Kp_min, Kp_max);
        individual->Ki = random_float(Ki_min, Ki_max);
        individual->Kd = random_float(Kd_min, Kd_max);
    }
}

// 遗传算法优化PID
void genetic_algorithm(PIDParams population[POP_SIZE], float setpoint, 
                       float Kp_min, float Kp_max, float Ki_min, float Ki_max, 
                       float Kd_min, float Kd_max) {
    PIDParams new_population[POP_SIZE];
    int selected1, selected2;
    PIDParams offspring1, offspring2;

    for (int generation = 0; generation < MAX_GEN; generation++) {
        for (int i = 0; i < POP_SIZE / 2; i++) {
            selected1 = selection(population, setpoint);
            selected2 = selection(population, setpoint);

            crossover(population[selected1], population[selected2], &offspring1, &offspring2);

            // 变异操作
            mutation(&offspring1, Kp_min, Kp_max, Ki_min, Ki_max, Kd_min, Kd_max);
            mutation(&offspring2, Kp_min, Kp_max, Ki_min, Ki_max, Kd_min, Kd_max);

            // 将交叉和变异后的个体加入新种群
            new_population[2 * i] = offspring1;
            new_population[2 * i + 1] = offspring2;
        }

        // 替换种群
        for (int i = 0; i < POP_SIZE; i++) {
            population[i] = new_population[i];
        }

        // 打印当前最优解
        float best_fitness = 0;
        int best_index = 0;
        for (int i = 0; i < POP_SIZE; i++) {
            float current_fitness = fitness(population[i], setpoint);
            if (current_fitness > best_fitness) {
                best_fitness = current_fitness;
                best_index = i;
            }
        }
        printf("Generation %d - Best Fitness: %f, Kp: %f, Ki: %f, Kd: %f\n",
               generation, best_fitness, population[best_index].Kp, 
               population[best_index].Ki, population[best_index].Kd);
    }
}

int main() {
    srand(time(NULL));

    // 初始化PID参数范围
    float Kp_min = 0.0, Kp_max = 10.0;
    float Ki_min = 0.0, Ki_max = 10.0;
    float Kd_min = 0.0, Kd_max = 10.0;

    // 初始化种群
    PIDParams population[POP_SIZE];
    init_population(population, Kp_min, Kp_max, Ki_min, Ki_max, Kd_min, Kd_max);

    // 设定目标值（例如：目标位置或温度等）
    float setpoint = 100.0;

    // 运行遗传算法
    genetic_algorithm(population, setpoint, Kp_min, Kp_max, Ki_min, Ki_max, Kd_min, Kd_max);

    return 0;
}