温控系统c语言源代码,模糊PID控制温控系统设计C语言程序代码

以下是一个基于模糊PID控制的温控系统的C语言源代码示例：

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

#define TEMP_SET_POINT 60.0       // 温度设定值
#define TEMP_TOLERANCE 2.0        // 温度容差
#define MAX_POWER 100.0           // 最大加热功率
#define MIN_POWER 0.0             // 最小加热功率
#define SAMPLE_TIME 0.1           // 采样时间

// 模糊控制参数
#define NB 7                      // 模糊集合数量
#define NM 7
#define NS 7
#define ZE 7
#define PS 7
#define PM 7
#define PB 7
#define DE 0.1                    // 均匀分割间隔
#define e_c PS                   // e_c: e的上限
#define e_s NS                   // e的下限
#define delta_u_c PM             // delta_u的上限
#define delta_u_s NM             // delta_u的下限

// 模糊集合隶属度函数
double NB_func(double e) { return 1.0 / (1.0 + exp(-NB * (e - PB))); }
double NM_func(double e) { return 1.0 / (1.0 + exp(-NM * (e - PM))); }
double NS_func(double e) { return 1.0 / (1.0 + exp(-NS * (e - ZE))); }
double ZE_func(double e) { return 1.0 / (1.0 + exp(-ZE * (e - ZE))); }
double PS_func(double e) { return 1.0 / (1.0 + exp(-PS * (e - ZE))); }
double PM_func(double e) { return 1.0 / (1.0 + exp(-PM * (e - NM))); }
double PB_func(double e) { return 1.0 / (1.0 + exp(-PB * (e - NB))); }

// 模糊控制规则库
double delta_u_table[7][7] = {
    {PB, PM, PM, ZE, NS, NS, NS},
    {PB, PM, PM, NS, NS, NS, NS},
    {PM, PM, ZE, NS, NS, NS, NM},
    {PM, PS, ZE, NS, NS, NM, NM},
    {PS, ZE, NS, NS, NM, NM, NB},
    {ZE, ZE, NS, NM, NM, NB, NB},
    {ZE, PS, PM, NM, NB, NB, NB}
};

// 模糊控制
double fuzzy_control(double e, double delta_e) {
    double delta_u = 0.0;
    int i, j;
    double e_array[7], delta_e_array[7];
    double u_array[7] = {MIN_POWER, MIN_POWER, MIN_POWER, MIN_POWER, MIN_POWER, MIN_POWER, MIN_POWER};
    double sum_e = 0.0, sum_delta_e = 0.0, sum_u = 0.0, sum_w = 0.0, w = 0.0;

    // 计算e、delta_e的隶属度
    e_array[0] = NB_func(e);
    e_array[1] = NM_func(e);
    e_array[2] = NS_func(e);
    e_array[3] = ZE_func(e);
    e_array[4] = PS_func(e);
    e_array[5] = PM_func(e);
    e_array[6] = PB_func(e);

    delta_e_array[0] = NB_func(delta_e);
    delta_e_array[1] = NM_func(delta_e);
    delta_e_array[2] = NS_func(delta_e);
    delta_e_array[3] = ZE_func(delta_e);
    delta_e_array[4] = PS_func(delta_e);
    delta_e_array[5] = PM_func(delta_e);
    delta_e_array[6] = PB_func(delta_e);

    // 计算u的隶属度
    for (i = 0; i < 7; i++) {
        for (j = 0; j < 7; j++) {
            w = e_array[i] * delta_e_array[j];
            u_array[(int)round(delta_u_table[i][j])] = fmax(u_array[(int)round(delta_u_table[i][j])], w);
        }
    }

    // 计算delta_u
    for (i = 0; i < 7; i++) {
        delta_u += u_array[i] * (i * DE + delta_u_s);
        sum_w += u_array[i];
    }
    delta_u /= sum_w;

    return delta_u;
}

int main() {
    double temp = 20.0;           // 初始温度为20度
    double last_temp = 20.0;      // 上次温度
    double e = 0.0, delta_e = 0.0;
    double power = 0.0;
    double time = 0.0;
    double Kp = 0.2, Ki = 0.1, Kd = 0.05;  // PID控制参数
    double last_error = 0.0, error = 0.0, error_integral = 0.0, error_derivative = 0.0;

    while (fabs(temp - TEMP_SET_POINT) > TEMP_TOLERANCE) {
        // 计算误差和误差变化率
        last_error = error;
        error = TEMP_SET_POINT - temp;
        error_integral += error * SAMPLE_TIME;
        error_derivative = (error - last_error) / SAMPLE_TIME;
        // 计算模糊PID控制输出
        delta_e = Kp * error + Ki * error_integral + Kd * error_derivative;
        power = fuzzy_control(error, delta_e);
        // 限制输出范围
        power = fmin(power, MAX_POWER);
        power = fmax(power, MIN_POWER);
        // 模拟温度变化
        temp += power / 10.0 * SAMPLE_TIME;
        // 输出结果
        printf("Time: %.1f s, Temperature: %.1f C, Power: %.1f %%\n", time, temp, power);
        // 更新时间
        time += SAMPLE_TIME;
    }

    printf("Temperature control finished.\n");
    return 0;
}

这个代码示例中，模糊PID控制使用了7个模糊集合，每个模糊集合都有一个隶属度函数，模糊控制规则库使用了一个7x7的表格，其中每个元素表示 delta_u（控制量）的隶属度，表格中的行和列分别代表误差e和误差变化率delta_e的模糊集合。在模糊控制中，通过计算e和delta_e的隶属度以及控制量的隶属度，可以得到一个delta_u的模糊值，最终通过求加权平均值得到delta_u的模糊输出，然后根据模糊输出和PID控制算法计算出实际控制量，并对其进行限制输出范围。