模糊PID控制的C程序

#include <cvirte.h>#include <userint.h>#include "succus.h"#include <rs232.h>#include <ansi_c.h>#include <formatio.h>#include <math.h>#include <string.h>#define parameterPID 0.1 //PID常数#define maxcontroldata 10 //最大控制量#define parameterfuzzy 12 //模糊控制常数#define Pe1 4 //隶属度范围#define Pe2 8#define Psess1 2#define Psess2 4#define parainput 100 //输入常数static int panelHandle;static int L_PIDstart; //运行标签static int L_fuzzystart;static float P_control; //获得参数static float I_control;static float D_control;static int whatmode;static float model_K; //模型参数static float model_T;static float model_t;static float cycle; //设定周期static float savedata[3]; //储存偏差量static float savecontrol[20]; //存储控制量static float result[2]; //存储仿真结果static float getsum;static char senddata[22]; //通信协议static char recievedata[18];static char nak[6];static char ack[6];int main (int argc, char *argv[]){if (InitCVIRTE (0, argv, 0) == 0)return -1; /* out of memory */if ((panelHandle = LoadPanel (0, "succus.uir", PANEL)) < 0)return -1;OpenComConfig (2, "", 9600, 0, 8, 1, 512, 512); //打开串口senddata[0] = 5; //构造协议senddata[1] = '0';senddata[2] = 'A';senddata[3] = 'F';senddata[4] = 'F';senddata[5] = 'W';senddata[6] = 'W';senddata[7] = '0';senddata[8] = 'D';senddata[9] = '5';senddata[10] = '0';senddata[11] = '6';senddata[12] = '4';senddata[13] = '0';senddata[14] = '1';senddata[21] = 0;recievedata[0] = 5;recievedata[1] = '0';recievedata[2] = 'A';recievedata[3] = 'F';recievedata[4] = 'F';recievedata[5] = 'W';recievedata[6] = 'R';recievedata[7] = '0';recievedata[8] = 'D';recievedata[9] = '5';recievedata[10] = '0';recievedata[11] = '0';recievedata[12] = '0';recievedata[13] = '0';recievedata[14] = '1';recievedata[15] = '4';recievedata[16] = '0';recievedata[17] = 0;nak[0] = 21;nak[1] = '0';nak[2] = 'A';nak[3] = 'F';nak[4] = 'F';nak[5] = 0;ack[0] = 6;ack[1] = '0';ack[2] = 'A';ack[3] = 'F';ack[4] = 'F';ack[5] = 0;FlushInQ (2);FlushOutQ (2);DisplayPanel (panelHandle);RunUserInterface ();CloseCom (2);DiscardPanel (panelHandle);return 0;}int CVICALLBACK autosetPIDCallback (int panel, int control, int event,void *callbackData, int eventData1, int eventData2){switch (event){case EVENT_COMMIT:SetCtrlVal (panelHandle, PANEL_PARAMETER_P, 20.0);SetCtrlVal (panelHandle, PANEL_PARAMETER_I, 0.0);SetCtrlVal (panelHandle, PANEL_PARAMETER_D, 0.0);break;}return 0;}int CVICALLBACK fuzzycontrolCallback (int panel, int control, int event,void *callbackData, int eventData1, int eventData2){switch (event){case EVENT_COMMIT:L_fuzzystart = 1;GetCtrlVal (panelHandle, PANEL_WORKMODE, &whatmode); //获得工作状态if(whatmode == 0){GetCtrlVal (panelHandle, PANEL_EMLUATOR_K, &model_K); //模型GetCtrlVal (panelHandle, PANEL_EMLUATOR_T, &model_T);GetCtrlVal (panelHandle, PANEL_EMLUATOR_t, &model_t);}GetCtrlVal (panelHandle, PANEL_SAMPLINGTIME, &cycle);SetCtrlAttribute (panelHandle, PANEL_TIMER, ATTR_INTERVAL, cycle);SetCtrlAttribute (panelHandle, PANEL_TIMER, ATTR_ENABLED, 1); //获得抽样时间。

模糊PID控制温控系统设计C语言程序代码介绍本文介绍了使用模糊PID控制方法来设计温控系统的C语言程序代码。

本温控系统使用传感器读取室内温度，然后根据读取的数值对应调整冷风机的风速和加热器的加热时间，从而控制室内温度达到一个设定值。

系统设计本温控系统采用模糊PID控制方法，具体实现流程如下：1.根据设定温度和当前室内温度计算出误差值2.使用模糊控制方法将误差值转化为温度调节量3.根据模糊控制输出的温度调节量计算出PID控制器的输出4.根据PID控制器的输出调节冷风机的风速和加热器的加热时间系统设计中需要使用的传感器，冷风机和加热器的具体型号及参数需要根据实际情况进行选择。

此处不做详细说明。

程序代码实现以下代码实现了上述系统设计，包括模糊控制和PID控制。

// 温控系统C语言程序代码#include<stdio.h>#include<stdlib.h>// 模糊控制double GetTemperatureByFuzzy(double error){double delta = 0.5; // 设定的温度调节步长double result = 0;if (error <= -5){result = 1;}else if (error > -5 && error < 0){result = (error + 5) / 5.0;}else if (error >= 0 && error < 5){result = (5 - error) / 5.0;}else{result = 0;}return result * delta;}// PID控制double GetTemperatureByPID(double error, double lastError, double integ ral){double Kp = 0.5; // 比例系数double Ki = 0.01; // 积分系数double Kd = 0.1; // 微分系数double deltaT = 0.1; // 采样时间double derivate = (error - lastError) / deltaT;double result = Kp * error + Ki * integral + Kd * derivate;return result;}// 主函数int main(){double setTemp = 25; // 设定温度double curTemp = 24; // 当前温度，需要从传感器读取double lastError = 0; // 上一次的误差值double integral = 0; // 积分项while (1){double error = setTemp - curTemp; // 计算当前误差值double fuzzyTemp = GetTemperatureByFuzzy(error); // 模糊控制integral += error; // 更新积分项double pidTemp = GetTemperatureByPID(error, lastError, integra l); // PID控制lastError = error; // 更新上一次误差值// 根据pidTemp和fuzzyTemp调节冷风机的风速和加热器的加热时间，省略// 读取传感器更新当前温度，省略// curTemp = GetCurTemp();// 采样时间，省略// sleep(1);}}本文介绍了使用模糊PID控制方法来设计温控系统的C语言程序代码。

// *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J*模糊PID控制温控系统仿真设计C程序代码/ *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* *J* /#include<reg52.h>#define uchar unsigned char#define uint unsigned int#define PULSE 200#define number 0.035sbit SDO = P2 A0。

sbit SDI = P2A1。

sbit CS = P2A2。

sbit CLK = P2A3。

sbit EOC = P2 A4。

sbit RS = P2A5。

sbit RW = P2A6。

sbit EN = P2 A7。

sbit KEY1= P3A0。

simulink模糊pid控制模型转c语言代码-回复Simulink模糊PID控制模型转C语言代码Simulink是MATLAB软件中一款用于进行动态系统建模和仿真的工具。

它通过图形化界面提供了易于使用的建模环境，使得用户能够快速构建和测试各种控制系统。

然而，有时我们可能需要将Simulink模型转换为C语言代码，以便在嵌入式系统或其他平台上实现实时控制。

在本篇文章中，我们将介绍如何将Simulink模糊PID控制模型转换为C语言代码。

第一步：理解模糊PID控制器原理在进行代码转换之前，我们先来了解一下模糊PID控制器的原理。

PID 控制器是一种经典的控制器，由比例项、积分项和微分项组成。

它通过对系统实际输出与期望输出的差异进行反馈控制，从而调整系统输入，使得输出接近期望值。

模糊PID控制器与传统PID控制器的主要区别在于它使用了模糊逻辑来处理不确定性和模糊性。

模糊逻辑是一种基于模糊集合理论的控制方法，它可以模拟人的思维方式，通过模糊化的输入和输出变量进行推理和决策。

第二步：在Simulink中设计模糊PID控制模型在Simulink中设计模糊PID控制模型是实现模糊PID控制器代码转换的前提。

我们可以使用Fuzzy Logic Toolbox提供的工具来创建和调整模糊逻辑系统。

首先，我们需要创建输入和输出变量。

输入变量通常是系统的误差（Current Error）和误差的变化率（Error Rate），输出变量一般为控制量（Control Signal）。

然后，我们可以根据实际情况定义模糊集合和模糊规则，以及选择适当的模糊控制器类型（如模糊反向推理控制器或模糊自适应控制器）。

完成模糊PID控制模型设计后，我们可以在Simulink中进行仿真和调试，确保模型能够正确地实现期望的控制效果。

第三步：使用MATLAB Coder将Simulink模型转换为C语言代码实现模糊PID控制模型的C语言代码转换，我们可以使用MATLAB Coder。

模糊PID控制算法的C#实现跑起来的效果看每个类的test⽅法，⾃⼰调⽤来测试⽬的是看看哪个算法好⽤，移植的时候⽐较单纯没有研究懂算法，代码结构也没改动，只是移植到C#⽅便查看代码和测试，⼤家要拷贝也很⽅便，把整个类拷贝到.cs⽂件即可第⼀段算法来⾃模糊PID控制算法的C++实现：blog。

csdn。

net/shuoyueqishilove/article/details/78236541这段算法在实际值低于⽬标值是⼯作正常，超过后会有问题，不知道如何调教using System;using System.Collections.Generic;using System.Diagnostics;using System.Linq;using System.Text;using System.Threading.Tasks;namespace FuzzyPID{class FuzzyPID{public const int N = 7;double target; //系统的控制⽬标double actual; //采样获得的实际值double e; //误差double e_pre_1; //上⼀次的误差double e_pre_2; //上上次的误差double de; //误差的变化率double emax; //误差基本论域上限double demax; //误差辩化率基本论域的上限double delta_Kp_max; //delta_kp输出的上限double delta_Ki_max; //delta_ki输出上限double delta_Kd_max; //delta_kd输出上限double Ke; //Ke=n/emax,量化论域为[-3,-2,-1,0,1,2,3]double Kde; //Kde=n/demax,量化论域为[-3,-2,-1,0,1,2,3]double Ku_p; //Ku_p=Kpmax/n,量化论域为[-3,-2,-1,0,1,2,3]double Ku_i; //Ku_i=Kimax/n,量化论域为[-3,-2,-1,0,1,2,3]double Ku_d; //Ku_d=Kdmax/n,量化论域为[-3,-2,-1,0,1,2,3]int[,] Kp_rule_matrix = new int[N, N];//Kp模糊规则矩阵int[,] Ki_rule_matrix = new int[N, N];//Ki模糊规则矩阵int[,] Kd_rule_matrix = new int[N, N];//Kd模糊规则矩阵string mf_t_e; //e的⾪属度函数类型string mf_t_de; //de的⾪属度函数类型string mf_t_Kp; //kp的⾪属度函数类型string mf_t_Ki; //ki的⾪属度函数类型string mf_t_Kd; //kd的⾪属度函数类型double[] e_mf_paras; //误差的⾪属度函数的参数double[] de_mf_paras;//误差的偏差⾪属度函数的参数double[] Kp_mf_paras; //kp的⾪属度函数的参数double[] Ki_mf_paras; //ki的⾪属度函数的参数double[] Kd_mf_paras; //kd的⾪属度函数的参数double Kp;double Ki;double Kd;double A;double B;double C;public FuzzyPID(double e_max, double de_max, double kp_max, double ki_max, double kd_max, double Kp0, double Ki0, double Kd0){emax = e_max;demax = de_max;delta_Kp_max = kp_max;delta_Ki_max = ki_max;delta_Kd_max = kd_max;e = target - actual;de = e - e_pre_1;Ke = (N / 2) / emax;Kde = (N / 2) / demax;Ku_p = delta_Kp_max / (N / 2);Ku_i = delta_Ki_max / (N / 2);Ku_d = delta_Kd_max / (N / 2);Kp = Kp0;Ki = Ki0;A = Kp + Ki + Kd;B = -2 * Kd - Kp;C = Kd;}//三⾓⾪属度函数double trimf(double x, double a, double b, double c){double u;if (x >= a && x <= b)u = (x - a) / (b - a);else if (x > b && x <= c)u = (c - x) / (c - b);elseu = 0;return u;}//正态⾪属度函数double gaussmf(double x, double ave, double sigma){double u;if (sigma < 0){throw new Exception("In gaussmf, sigma must larger than 0");}u = Math.Exp(-Math.Pow(((x - ave) / sigma), 2));return u;}//梯形⾪属度函数double trapmf(double x, double a, double b, double c, double d){double u;if (x >= a && x < b)u = (x - a) / (b - a);else if (x >= b && x < c)u = 1;else if (x >= c && x <= d)u = (d - x) / (d - c);elseu = 0;return u;}//设置模糊规则Matrixpublic void setRuleMatrix(int[,] kp_m, int[,] ki_m, int[,] kd_m){for (int i = 0; i < N; i++)for (int j = 0; j < N; j++){Kp_rule_matrix[i, j] = kp_m[i, j];Ki_rule_matrix[i, j] = ki_m[i, j];Kd_rule_matrix[i, j] = kd_m[i, j];}}//设置模糊⾪属度函数的⼦函数void setMf_sub(string type, double[] paras, int n){int N_mf_e = 0, N_mf_de = 0, N_mf_Kp = 0, N_mf_Ki = 0, N_mf_Kd = 0;switch (n){case0:if (type == "trimf" || type == "gaussmf" || type == "trapmf")mf_t_e = type;elsethrow new Exception("Type of membership function must be \"trimf\" or \"gaussmf\" or \"trapmf\"");if (mf_t_e == "trimf")N_mf_e = 3;else if (mf_t_e == "gaussmf")N_mf_e = 2;else if (mf_t_e == "trapmf")N_mf_e = 4;e_mf_paras = new double[N * N_mf_e];for (int i = 0; i < N * N_mf_e; i++)e_mf_paras[i] = paras[i];break;if (type == "trimf" || type == "gaussmf" || type == "trapmf")mf_t_de = type;elsethrow new Exception("Type of membership function must be \"trimf\" or \"gaussmf\" or \"trapmf\"");if (mf_t_de == "trimf")N_mf_de = 3;else if (mf_t_de == "gaussmf")N_mf_de = 2;else if (mf_t_de == "trapmf")N_mf_de = 4;de_mf_paras = new double[N * N_mf_de];for (int i = 0; i < N * N_mf_de; i++)de_mf_paras[i] = paras[i];break;case2:if (type == "trimf" || type == "gaussmf" || type == "trapmf")mf_t_Kp = type;elsethrow new Exception("Type of membership function must be \"trimf\" or \"gaussmf\" or \"trapmf\"");if (mf_t_Kp == "trimf")N_mf_Kp = 3;else if (mf_t_Kp == "gaussmf")N_mf_Kp = 2;else if (mf_t_Kp == "trapmf")N_mf_Kp = 4;Kp_mf_paras = new double[N * N_mf_Kp];for (int i = 0; i < N * N_mf_Kp; i++)Kp_mf_paras[i] = paras[i];break;case3:if (type == "trimf" || type == "gaussmf" || type == "trapmf")mf_t_Ki = type;elsethrow new Exception("Type of membership function must be \"trimf\" or \"gaussmf\" or \"trapmf\"");if (mf_t_Ki == "trimf")N_mf_Ki = 3;else if (mf_t_Ki == "gaussmf")N_mf_Ki = 2;else if (mf_t_Ki == "trapmf")N_mf_Ki = 4;Ki_mf_paras = new double[N * N_mf_Ki];for (int i = 0; i < N * N_mf_Ki; i++)Ki_mf_paras[i] = paras[i];break;case4:if (type == "trimf" || type == "gaussmf" || type == "trapmf")mf_t_Kd = type;elsethrow new Exception("Type of membership function must be \"trimf\" or \"gaussmf\" or \"trapmf\"");if (mf_t_Kd == "trimf")N_mf_Kd = 3;else if (mf_t_Kd == "gaussmf")N_mf_Kd = 2;else if (mf_t_Kd == "trapmf")N_mf_Kd = 4;Kd_mf_paras = new double[N * N_mf_Kd];for (int i = 0; i < N * N_mf_Kd; i++)Kd_mf_paras[i] = paras[i];break;default: break;}}//设置模糊⾪属度函数的类型和参数public void setMf(string mf_type_e, double[] e_mf,string mf_type_de, double[] de_mf,string mf_type_Kp, double[] Kp_mf,string mf_type_Ki, double[] Ki_mf,string mf_type_Kd, double[] Kd_mf){setMf_sub(mf_type_e, e_mf, 0);setMf_sub(mf_type_de, de_mf, 1);setMf_sub(mf_type_Kp, Kp_mf, 2);setMf_sub(mf_type_Ki, Ki_mf, 3);setMf_sub(mf_type_Kd, Kd_mf, 4);}//实现模糊控制{double[] u_e = new double[N],u_de = new double[N],u_u = new double[N];int[] u_e_index = new int[3], u_de_index = new int[3];//假设⼀个输⼊最多激活3个模糊⼦集double delta_Kp, delta_Ki, delta_Kd;double delta_u;target = t;actual = a;e = target - actual;de = e - e_pre_1;e = Ke * e;de = Kde * de;/* 将误差e模糊化*/int j = 0;for (int i = 0; i < N; i++){if (mf_t_e == "trimf")u_e[i] = trimf(e, e_mf_paras[i * 3], e_mf_paras[i * 3 + 1], e_mf_paras[i * 3 + 2]);//e模糊化，计算它的⾪属度else if (mf_t_e == "gaussmf")u_e[i] = gaussmf(e, e_mf_paras[i * 2], e_mf_paras[i * 2 + 1]);//e模糊化，计算它的⾪属度else if (mf_t_e == "trapmf")u_e[i] = trapmf(e, e_mf_paras[i * 4], e_mf_paras[i * 4 + 1], e_mf_paras[i * 4 + 2], e_mf_paras[i * 4 + 3]);//e模糊化，计算它的⾪属度if (u_e[i] != 0)u_e_index[j++] = i; //存储被激活的模糊⼦集的下标，可以减⼩计算量}for (; j < 3; j++) u_e_index[j] = 0; //富余的空间填0/*将误差变化率de模糊化*/j = 0;for (int i = 0; i < N; i++){if (mf_t_de == "trimf")u_de[i] = trimf(de, de_mf_paras[i * 3], de_mf_paras[i * 3 + 1], de_mf_paras[i * 3 + 2]);//de模糊化，计算它的⾪属度else if (mf_t_de == "gaussmf")u_de[i] = gaussmf(de, de_mf_paras[i * 2], de_mf_paras[i * 2 + 1]);//de模糊化，计算它的⾪属度else if (mf_t_de == "trapmf")u_de[i] = trapmf(de, de_mf_paras[i * 4], de_mf_paras[i * 4 + 1], de_mf_paras[i * 4 + 2], de_mf_paras[i * 4 + 3]);//de模糊化，计算它的⾪属度if (u_de[i] != 0)u_de_index[j++] = i; //存储被激活的模糊⼦集的下标，可以减⼩计算量}for (; j < 3; j++) u_de_index[j] = 0; //富余的空间填0double den = 0, num = 0;/*计算delta_Kp和Kp*/for (int m = 0; m < 3; m++)for (int n = 0; n < 3; n++){num += u_e[u_e_index[m]] * u_de[u_de_index[n]] * Kp_rule_matrix[u_e_index[m], u_de_index[n]];den += u_e[u_e_index[m]] * u_de[u_de_index[n]];}delta_Kp = num / den;delta_Kp = Ku_p * delta_Kp;if (delta_Kp >= delta_Kp_max) delta_Kp = delta_Kp_max;else if (delta_Kp <= -delta_Kp_max) delta_Kp = -delta_Kp_max;Kp += delta_Kp;if (Kp < 0) Kp = 0;/*计算delta_Ki和Ki*/den = 0; num = 0;for (int m = 0; m < 3; m++)for (int n = 0; n < 3; n++){num += u_e[u_e_index[m]] * u_de[u_de_index[n]] * Ki_rule_matrix[u_e_index[m], u_de_index[n]];den += u_e[u_e_index[m]] * u_de[u_de_index[n]];}delta_Ki = num / den;delta_Ki = Ku_i * delta_Ki;if (delta_Ki >= delta_Ki_max) delta_Ki = delta_Ki_max;else if (delta_Ki <= -delta_Ki_max) delta_Ki = -delta_Ki_max;Ki += delta_Ki;if (Ki < 0) Ki = 0;/*计算delta_Kd和Kd*/den = 0; num = 0;for (int m = 0; m < 3; m++)for (int n = 0; n < 3; n++){num += u_e[u_e_index[m]] * u_de[u_de_index[n]] * Kd_rule_matrix[u_e_index[m], u_de_index[n]];den += u_e[u_e_index[m]] * u_de[u_de_index[n]];}delta_Kd = num / den;if (delta_Kd >= delta_Kd_max) delta_Kd = delta_Kd_max;else if (delta_Kd <= -delta_Kd_max) delta_Kd = -delta_Kd_max;Kd += delta_Kd;if (Kd < 0) Kd = 0;A = Kp + Ki + Kd;B = -2 * Kd - Kp;C = Kd;delta_u = A * e + B * e_pre_1 + C * e_pre_2;delta_u = delta_u / Ke;if (delta_u >= 0.95 * target) delta_u = 0.95 * target;else if (delta_u <= -0.95 * target) delta_u = -0.95 * target;e_pre_2 = e_pre_1;e_pre_1 = e;return delta_u;}void showMf(string type, double[] mf_paras){int tab = 0;if (type == "trimf")tab = 2;else if (type == "gaussmf")tab = 1;else if (type == "trapmf")tab = 3;this.WriteLine($"函数类型：{mf_t_e}");this.WriteLine("函数参数列表：");double[] p = mf_paras;for (int i = 0; i < N * (tab + 1); i++){this.Write(p[i] + "");if (i % (tab + 1) == tab)this.Write("\r\n");}}public void showInfo(){this.WriteLine("Info of this fuzzy controller is as following:");this.WriteLine($"基本论域e：[{-emax},{emax}]");this.WriteLine($"基本论域de：[{-demax},{demax}]");this.WriteLine($"基本论域delta_Kp：[{-delta_Kp_max},{delta_Kp_max}]");this.WriteLine($"基本论域delta_Ki：[{-delta_Ki_max},{delta_Ki_max}]");this.WriteLine($"基本论域delta_Kd：[{-delta_Kd_max},{delta_Kd_max}]");this.WriteLine("误差e的模糊⾪属度函数参数：");showMf(mf_t_e, e_mf_paras);this.WriteLine("误差变化率de的模糊⾪属度函数参数：");showMf(mf_t_de, de_mf_paras);this.WriteLine("delta_Kp的模糊⾪属度函数参数：");showMf(mf_t_Kp, Kp_mf_paras);this.WriteLine("delta_Ki的模糊⾪属度函数参数：");showMf(mf_t_Ki, Ki_mf_paras);this.WriteLine("delta_Kd的模糊⾪属度函数参数：");showMf(mf_t_Kd, Kd_mf_paras);this.WriteLine("模糊规则表：");this.WriteLine("delta_Kp的模糊规则矩阵");for (int i = 0; i < N; i++){for (int j = 0; j < N; j++){this.Write(Kp_rule_matrix[i, j]);}this.Write("\r\n");}this.WriteLine("delta_Ki的模糊规则矩阵"); ;for (int i = 0; i < N; i++){for (int j = 0; j < N; j++){this.WriteLine(Ki_rule_matrix[i, j]);}WriteEnd();}this.WriteLine("delta_Kd的模糊规则矩阵"); ;for (int i = 0; i < N; i++){for (int j = 0; j < N; j++){WriteEnd();}this.WriteLine($"误差的量化⽐例因⼦Ke={Ke}");this.WriteLine($"误差变化率的量化⽐例因⼦Kde={Kde}");this.WriteLine($"输出的量化⽐例因⼦Ku_p={Ku_p}");this.WriteLine($"输出的量化⽐例因⼦Ku_i={Ku_i}");this.WriteLine($"输出的量化⽐例因⼦Ku_d={Ku_d}");this.WriteLine($"设定⽬标target={target}");this.WriteLine($"误差e={e}");this.WriteLine($"Kp={Kp}");this.WriteLine($"Ki={Ki}");this.WriteLine($"Kd={Kd}");WriteEnd();}public void Write(object str){Console.Write(str);}public void WriteLine(object str){Console.WriteLine(str);}public void WriteEnd(){Console.Write("\r\n");}public static void test(){int NB = -3;int NM = -2;int NS = -1;int ZO = 0;int PS = 1;int PM = 2;int PB = 3;double target = 300;double actual = 400;double u = 0;int[,] deltaKpMatrix = new int[7, 7] {{PB,PB,PM,PM,PS,ZO,ZO},{PB,PB,PM,PS,PS,ZO,NS},{PM,PM,PM,PS,ZO,NS,NS},{PM,PM,PS,ZO,NS,NM,NM},{PS,PS,ZO,NS,NS,NM,NM},{PS,ZO,NS,NM,NM,NM,NB},{ZO,ZO,NM,NM,NM,NB,NB}};int[,] deltaKiMatrix = new int[7, 7]{{NB,NB,NM,NM,NS,ZO,ZO},{NB,NB,NM,NS,NS,ZO,ZO},{NB,NM,NS,NS,ZO,PS,PS},{NM,NM,NS,ZO,PS,PM,PM},{NM,NS,ZO,PS,PS,PM,PB},{ZO,ZO,PS,PS,PM,PB,PB},{ZO,ZO,PS,PM,PM,PB,PB}};int[,] deltaKdMatrix = new int[7, 7]{{PS,NS,NB,NB,NB,NM,PS},{PS,NS,NB,NM,NM,NS,ZO},{ZO,NS,NM,NM,NS,NS,ZO},{ZO,NS,NS,NS,NS,NS,ZO},{ZO,ZO,ZO,ZO,ZO,ZO,ZO},{PB,NS,PS,PS,PS,PS,PB},{PB,PM,PM,PM,PS,PS,PB}};double[] e_mf_paras = { -3, -3, -2, -3, -2, -1, -2, -1, 0, -1, 0, 1, 0, 1, 2, 1, 2, 3, 2, 3, 3 };double[] de_mf_paras = { -3, -3, -2, -3, -2, -1, -2, -1, 0, -1, 0, 1, 0, 1, 2, 1, 2, 3, 2, 3, 3 };double[] Kp_mf_paras = { -3, -3, -2, -3, -2, -1, -2, -1, 0, -1, 0, 1, 0, 1, 2, 1, 2, 3, 2, 3, 3 };double[] Ki_mf_paras = { -3, -3, -2, -3, -2, -1, -2, -1, 0, -1, 0, 1, 0, 1, 2, 1, 2, 3, 2, 3, 3 };double[] Kd_mf_paras = { -3, -3, -2, -3, -2, -1, -2, -1, 0, -1, 0, 1, 0, 1, 2, 1, 2, 3, 2, 3, 3 };var fuzzypid = new FuzzyPID(1500, 1000, 0.3, 0.9, 0.6, 0.01, 0.04, 0.01);fuzzypid.setMf("trimf", e_mf_paras, "trimf", de_mf_paras, "trimf", Kp_mf_paras, "trimf", Ki_mf_paras, "trimf", Kd_mf_paras); fuzzypid.setRuleMatrix(deltaKpMatrix, deltaKiMatrix, deltaKdMatrix);for (int i = 0; i < 50; i++){u = fuzzypid.realize(target, actual);actual += u;Console.WriteLine($"{i} {target} {u} {actual}");// target = 300;//}}//fuzzypid.showInfo();}}}第⼆段来⾃模糊PID控制温控系统设计⽅案C语⾔程序代码： wenku。

由于项目需要，需要模糊控制算法，之前此类知识为0，经过半个多月的研究，终于有的小进展。

开始想从强大的互联网上搜点c代码来研究下，结果搜遍所有搜索引擎都搜不到，以下本人从修改的模糊控制代码，经过自己修改后可在vc6.0，运行！输入e表示输出误差，ec表示误差变化率，经过测试具有很好的控制效果，对于非线性系统和数学模型难以建立的系统来说有更好的控制效果！现将其公开供大家学习研究！#include <stdio.h>#include"math.h"#define PMAX 100#define PMIN -100#define DMAX 100#define DMIN -100#define FMAX 100 /*语言值的满幅值*/int PFF[4]={0,12,24,48};/*输入量D语言值特征点*/int DFF[4]={0,16,32,64};/*输出量U语言值特征点*/int UFF[7]={0,15,30,45,60,75,90};/*采用了调整因子的规则表,大误差时偏重误差,小误差时偏重误差变化*//*a0=0.3,a1=0.55,a2=0.74,a3=0.89 */int rule[7][7]={//误差变化率-3,-2,-1, 0, 1, 2, 3 // 误差{-6,-6,-6,-5,-5,-5,-4,}, // -3{-5,-4,-4,-3,-2,-2,-1,}, // -2{-4,-3,-2,-1, 0, 1, 2,}, // -1{-4,-3,-1, 0, 1, 3, 4,}, // 0{-2,-1, 0, 1, 2, 3, 4,}, // 1{ 1, 2, 2, 3, 4, 4, 5,}, // 2{ 4, 5, 5, 5, 6, 6, 6}}; // 3/**********************************************************/int Fuzzy(int P,int D) /*模糊运算引擎*/{int U; /*偏差,偏差微分以及输出值的精确量*/unsigned int PF[2],DF[2],UF[4]; /*偏差,偏差微分以及输出值的隶属度*/ int Pn,Dn,Un[4];long temp1,temp2;/*隶属度的确定*//*根据PD的指定语言值获得有效隶属度*/if(P>-PFF[3] && P<PFF[3]){if(P<=-PFF[2]){Pn=-2;PF[0]=FMAX*((float)(-PFF[2]-P)/(PFF[3]-PFF[2]));}else if(P<=-PFF[1]){Pn=-1;PF[0]=FMAX*((float)(-PFF[1]-P)/(PFF[2]-PFF[1]));}else if(P<=PFF[0]){Pn=0;PF[0]=FMAX*((float)(-PFF[0]-P)/(PFF[1]-PFF[0]));}else if(P<=PFF[1]){Pn=1; PF[0]=FMAX*((float)(PFF[1]-P)/(PFF[1]-PFF[0]));}else if(P<=PFF[2]){Pn=2; PF[0]=FMAX*((float)(PFF[2]-P)/(PFF[2]-PFF[1]));}else if(P<=PFF[3]){Pn=3; PF[0]=FMAX*((float)(PFF[3]-P)/(PFF[3]-PFF[2]));}}else if(P<=-PFF[3]){Pn=-2; PF[0]=FMAX;}else if(P>=PFF[3]){Pn=3; PF[0]=0;}PF[1]=FMAX-PF[0];if(D>-DFF[3] && D<DFF[3]){if(D<=-DFF[2]){Dn=-2;DF[0]=FMAX*((float)(-DFF[2]-D)/(DFF[3]-DFF[2])); }else if(D<=-DFF[1]){Dn=-1;DF[0]=FMAX*((float)(-DFF[1]-D)/(DFF[2]-DFF[1]));}else if(D<=DFF[0]){Dn=0;DF[0]=FMAX*((float)(-DFF[0]-D)/(DFF[1]-DFF[0]));}else if(D<=DFF[1]){Dn=1;DF[0]=FMAX*((float)(DFF[1]-D)/(DFF[1]-DFF[0]));}else if(D<=DFF[2]){Dn=2; DF[0]=FMAX*((float)(DFF[2]-D)/(DFF[2]-DFF[1])); }else if(D<=DFF[3]){Dn=3; DF[0]=FMAX*((float)(DFF[3]-D)/(DFF[3]-DFF[2])); }}else if(D<=-DFF[3]){Dn=-2;DF[0]=FMAX;else if(D>=DFF[3]){Dn=3;DF[0]=0;}DF[1]=FMAX-DF[0];/*使用误差围优化后的规则表rule[7][7]*//*输出值使用13个隶属函数,中心值由UFF[7]指定*/ /*一般都是四个规则有效*/Un[0]=rule[Pn-1+3][Dn-1+3];Un[1]=rule[Pn+3][Dn-1+3];Un[2]=rule[Pn-1+3][Dn+3];Un[3]=rule[Pn+3][Dn+3];if(PF[0]<=DF[0])UF[0]=PF[0];elseUF[0]=DF[0];if(PF[1]<=DF[0])UF[1]=PF[1];elseUF[1]=DF[0];if(PF[0]<=DF[1])UF[2]=PF[0];elseUF[2]=DF[1];if(PF[1]<=DF[1])UF[3]=PF[1];elseUF[3]=DF[1];/*同隶属函数输出语言值求大*/if(Un[0]==Un[1]){if(UF[0]>UF[1])UF[1]=0;elseUF[0]=0;if(Un[0]==Un[2]){if(UF[0]>UF[2])UF[2]=0;elseUF[0]=0;}if(Un[0]==Un[3]){if(UF[0]>UF[3])UF[3]=0;elseUF[0]=0;}if(Un[1]==Un[2]){if(UF[1]>UF[2])UF[2]=0;elseUF[1]=0;}if(Un[1]==Un[3]){if(UF[1]>UF[3])UF[3]=0;elseUF[1]=0;}if(Un[2]==Un[3]){if(UF[2]>UF[3])UF[3]=0;elseUF[2]=0;}/*重心法反模糊*//*Un[]原值为输出隶属函数标号，转换为隶属函数值*/ if(Un[0]>=0)Un[0]=UFF[Un[0]];elseUn[0]=-UFF[-Un[0]];if(Un[1]>=0)Un[1]=UFF[Un[1]];elseUn[1]=-UFF[-Un[1]];if(Un[2]>=0)Un[2]=UFF[Un[2]];elseUn[2]=-UFF[-Un[2]];if(Un[3]>=0)Un[3]=UFF[Un[3]];elseUn[3]=-UFF[-Un[3]];temp1=UF[0]*Un[0]+UF[1]*Un[1]+UF[2]*Un[2]+UF[3]*Un[3]; temp2=UF[0]+UF[1]+UF[2]+UF[3];U=temp1/temp2;return U;}void main(){int a=0,e,ec;/*int nowpoint,p1,p2=1;FILE *in,*out;in=fopen("in.txt","r");out=fopen("out.txt","w");*///while(!feof(in))while(1){//fscanf(in,"%d",&nowpoint);//p1=nowpoint;//e=0-nowpoint;//ec= p1-p2;printf("请输入e:");scanf("%d",&e);printf("请输入ec:");scanf("%d",&ec);a=Fuzzy(e,ec);//fprintf(out,"%d ",a);//printf("%d: ",p1);printf("e: %d ec: %d ",e,ec);printf("a: %d \n",a); //p2=p1;}//fclose(in);//fclose(out);}。

PID控制算法的C语言实现一 PID算法原理最近两天在考虑一般控制算法的C语言实现问题，发现网络上尚没有一套完整的比较体系的讲解。

于是总结了几天，整理一套思路分享给大家。

在工业应用中PID及其衍生算法是应用最广泛的算法之一，是当之无愧的万能算法，如果能够熟练掌握PID算法的设计与实现过程，对于一般的研发人员来讲，应该是足够应对一般研发问题了，而难能可贵的是，在我所接触的控制算法当中，PID控制算法又是最简单，最能体现反馈思想的控制算法，可谓经典中的经典。

经典的未必是复杂的，经典的东西常常是简单的，而且是最简单的，想想牛顿的力学三大定律吧，想想爱因斯坦的质能方程吧，何等的简单！简单的不是原始的，简单的也不是落后的，简单到了美的程度。

先看看PID算法的一般形式：PID的流程简单到了不能再简单的程度，通过误差信号控制被控量，而控制器本身就是比例、积分、微分三个环节的加和。

这里我们规定（在t时刻）：1.输入量为rin(t);2.输出量为rout(t);3.偏差量为err(t)=rin(t)-rout(t);pid的控制规律为理解一下这个公式，主要从下面几个问题着手，为了便于理解，把控制环境具体一下：1.规定这个流程是用来为直流电机调速的;2.输入量rin(t)为电机转速预定值;3.输出量rout(t)为电机转速实际值;4.执行器为直流电机;5.传感器为光电码盘，假设码盘为10线;6.直流电机采用PWM调速转速用单位转/min表示;不难看出以下结论：1.输入量rin（t）为电机转速预定值（转/min）;2. 输出量rout(t)为电机转速实际值（转/min）;3.偏差量为预定值和实际值之差（转/min）;那么以下几个问题需要弄清楚：1.通过PID环节之后的U(t)是什么值呢？2.控制执行器（直流电机）转动转速应该为电压值（也就是PWM占空比）。

3.那么U(t)与PWM之间存在怎样的联系呢？/user1/3407/archives/2006/33541.html（见附录1）这篇文章上给出了一种方法，即，每个电压对应一个转速，电压和转速之间呈现线性关系。

simulink模糊pid控制模型转c语言代码1.引言1.1 概述在Simulink模糊PID控制模型转换为C语言代码的过程中，我们首先要了解模糊PID控制模型的基本原理和作用。

模糊PID控制模型是一种基于模糊逻辑的控制模型，它能够处理非线性、模糊和不确定的系统，并且具有良好的控制性能。

本文的目的是将Simulink中的模糊PID控制模型转换为可在嵌入式系统中运行的C语言代码。

通过这个转换过程，我们可以将Simulink模型直接应用于实际的嵌入式系统中，从而实现对系统的精确控制。

在转换过程中，我们将介绍Simulink模糊PID控制模型的基本结构和参数设置，以及针对模型的特定需求进行的模糊逻辑设计。

然后，我们将详细讲解如何将Simulink模型转换为可执行的C语言代码，包括代码的结构和实现方法。

转换完成后，我们将对转换结果进行评估和展望，分析代码在嵌入式系统中的实际应用情况，并提出改进和优化的建议。

通过本文的阅读，读者将能够了解Simulink模糊PID控制模型转换为C语言代码的全过程，并具备实际应用的能力。

同时，本文也为相关领域的研究和开发人员提供了一个参考和指导，帮助他们更好地利用Simulink进行系统控制。

1.2文章结构文章结构部分的内容应包括本文的组织架构和各个章节的简要介绍。

文章的组织架构如下所示：引言部分简要介绍了本文的主题和目的，包括Simulink模糊PID控制模型转C语言代码的方法和过程。

正文部分包括了Simulink模糊PID控制模型以及将其转换为C语言代码的方法。

在第2.1节中，我们将介绍Simulink模糊PID控制模型的基本概念和原理，并对其进行详细说明。

在第2.2节中，我们将介绍将Simulink模糊PID控制模型转换为C语言代码的方法和步骤，包括代码生成和优化技巧。

结论部分将对Simulink模糊PID控制模型转C语言代码的过程进行总结，并对转换结果进行评估和展望。

模糊PID控制温控系统设计C语言程序代码请注意，由于1200字的限制，下面的代码只是模糊PID控制温控系统的一个简单示例。

如果您需要更详细和完整的代码，请提供更多的细节和规格要求。

```c#include <stdio.h>//PID参数float kp = 0.5; // 比例系数float ki = 0.2; // 积分系数float kd = 0.1; // 微分系数//PID变量float integral = 0; // 积分累计float previous_error = 0; // 上一次的误差//温度传感器读取函数，返回当前温度float read_temperatur//实现温度传感器读取的代码逻辑//返回当前温度值//控制器输出函数，将控制信号发送给执行机构void control_output(float control_signal)//实现将控制信号发送给执行机构的代码逻辑int mai//设置设定温度float setpoint = 25.0;//主循环while (1)//获取当前温度float current_temperature = read_temperature(;//计算误差float error = setpoint - current_temperature;//计算PID控制信号float p_term = kp * error;integral += ki * error;float d_term = kd * (error - previous_error);float control_signal = p_term + integral + d_term; //更新上一次的误差previous_error = error;//输出控制信号control_output(control_signal);}return 0;```上述代码中，我们首先定义了PID参数和变量，以及温度传感器读取函数和控制器输出函数。

PID控制算法的C语言实现一 PID算法原理最近两天在考虑一般控制算法的C语言实现问题,发现网络上尚没有一套完整的比较体系的讲解。

于是总结了几天,整理一套思路分享给大家。

在工业应用中PID及其衍生算法是应用最广泛的算法之一,是当之无愧的万能算法,如果能够熟练掌握PID算法的设计与实现过程,对于一般的研发人员来讲,应该是足够应对一般研发问题了,而难能可贵的是,在我所接触的控制算法当中,PID控制算法又是最简单,最能体现反馈思想的控制算法,可谓经典中的经典。

经典的未必是复杂的,经典的东西常常是简单的,而且是最简单的,想想牛顿的力学三大定律吧,想想爱因斯坦的质能方程吧,何等的简单简单的不是原始的,简单的也不是落后的,简单到了美的程度。

先看看PID算法的一般形式：PID的流程简单到了不能再简单的程度,通过误差信号控制被控量,而控制器本身就是比例、积分、微分三个环节的加和。

这里我们规定在t时刻：1.输入量为rin t ;2.输出量为rout t ;3.偏差量为err t =rin t -rout t ;pid的控制规律为理解一下这个公式,主要从下面几个问题着手,为了便于理解,把控制环境具体一下：1.规定这个流程是用来为直流电机调速的;2.输入量rin t 为电机转速预定值;3.输出量rout t 为电机转速实际值;4.执行器为直流电机;5.传感器为光电码盘,假设码盘为10线;6.直流电机采用PWM调速转速用单位转/min表示;不难看出以下结论：1.输入量rin t 为电机转速预定值转/min ;2. 输出量rout t 为电机转速实际值转/min ;3.偏差量为预定值和实际值之差转/min ;那么以下几个问题需要弄清楚：1.通过PID环节之后的U t 是什么值呢2.控制执行器直流电机转动转速应该为电压值也就是PWM占空比。

3.那么U t 与PWM之间存在怎样的联系呢见附录1 这篇文章上给出了一种方法,即,每个电压对应一个转速,电压和转速之间呈现线性关系。