C实现模糊控制算法

合集下载

模糊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控制方法来设计温控系统的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语言程序代码。

c#实现模糊PID控制算法

c#实现模糊PID控制算法跑起来的效果看每个类的test⽅法，⾃⼰调⽤来测试⽬的是看看哪个算法好⽤，移植的时候⽐较单纯没有研究懂算法，代码结构也没改动，只是移植到C#⽅便查看代码和测试，⼤家要拷贝也很⽅便，把整个类拷贝到.cs⽂件即可这段算法在实际值低于⽬标值是⼯作正常，超过后会有问题，不知道如何调教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;Kd = Kd0;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){case 0: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;case 1: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;case 2: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;case 3: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;case 4: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);}//实现模糊控制public double realize(double t, double a){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;delta_Kd = Ku_d * delta_Kd;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++){this.WriteLine(Kd_rule_matrix[i, 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}");//if (i>19)//{// target = 300;//}}//fuzzypid.showInfo();}}}以上就是c# 实现模糊PID控制算法的详细内容，更多关于c# 模糊PID控制算法的资料请关注其它相关⽂章！。

模式识别大作业模糊C均值算法实现

}
//根据隶属度矩阵计算聚类中心
p=MatrixMul(u,k,row,data,row,col); for(i=0;i<150;i++) { double si=0; for(j=0;j<4;j++) { si+=u[i][j]; } for(t=0;t<4;t++) { center[i][t]=p[i][t]/si; } }
I i { j | xi m (js ) 0, j 1, 2, , K }
② 计算 xi 的新隶属度。如果 Ii 为空集, 则按式(8-63)计算隶属度; 否则, 并取 j (xi ) 1 j 1 (s) (s+1) (5) 选取一个适当的矩阵范数, 如果‖U －U ‖<ε, 则停止迭代, 否则 s=s+1, 返回(3)。当模糊 C 均值算法收敛时, 就得到了各类的聚类中心和各个样本属于各类的隶属度, 也就完成了模糊聚类。进一步, 可以将模糊聚类结果去模糊化, 把模糊聚类变为确定性分类。

xi m l
2 1 ( b 1)

( i 1, 2, , N;
j 1, 2, , C)
模糊 C 均值算法采用迭代方法求解式(8-62)和式(8-63), 其步骤如下: (1) 设定聚类数目 C、参数 b 和一个适当的小数ε>0, 通常取 1<b≤5。 (0) (2) 设置初始模糊分类矩阵 U , 令 s=0。 (s) (s) (3) 根据式(8-62)计算 U 的聚类中心{m j, j=1, 2, …, C}。 (s) (s+1) (4) 按下面的方法更新 U 为 U : ① 计算 Ii 和 I i ，其中

模糊逻辑系统的C 语言实现方法

模糊逻辑系统的C语言实现方法贺维，江汉红，王海峰，张朝亮（武汉海军工程大学湖北武汉 430033）摘要：本文首先介绍了三种专门用于模糊逻辑控制系统设计的软件系统。

详细地介绍了利用软件进行模糊逻辑控制系统设计的基本原理以及模糊控制器的软件程序设计方法。

实验表明，模糊逻辑系统的C语言实现方法是完全可行的，并且能够大大减少工作量。

关键词：模糊逻辑C语言C Language Realize Method of Fuzzy Logic SystemHE-wei JIANG Han-hong WANG Hai-feng ZHANG Chao-liang(Naval University of Engineering, Wuhan 430033, China)Abstract: This paper presents three special software systems for the the design of hardware circuit of Fuzzy Logic control system. The paper introduced the composing and working principle in detail . The way of designing and programming of Fuzzy Logic control system is also presented in detail in the paper. In the end the results of experiment shows that C Language realize method is completely viable,and can reduce lots of workload.Key words: Fuzzy Control C Language1.引言对于模糊控制的实现是模糊控制在实际应用中的一个重要环节。

模糊控制c++代码

模糊控制c++代码以下是一个简单的模糊控制 C++代码示例，用于演示基本的模糊控制系统：```cpp#include <iostream>#include <vector>using namespace std;// 模糊控制系统的输入变量struct FuzzyInput {double temperature;double humidity;};// 模糊控制系统的输出变量struct FuzzyOutput {double fanSpeed;};// 定义模糊集合及其隶属度函数struct FuzzySet {string name;vector<double> membershipFunctions;};// 模糊规则struct FuzzyRule {string ifClause;string thenClause;};// 初始化模糊集合FuzzySet cold = {"cold", {0.0, 0.0, 5.0, 10.0}};FuzzySet cool = {"cool", {0.0, 5.0, 10.0, 15.0}};FuzzySet warm = {"warm", {5.0, 10.0, 15.0, 20.0}};FuzzySet hot = {"hot", {10.0, 15.0, 20.0, 25.0}};// 初始化模糊规则FuzzyRule rule1 = {"if temperature is cold and humidity is low", "then fanSpeed is low"};FuzzyRule rule2 = {"if temperature is cool and humidity is low", "then fanSpeed is medium"};FuzzyRule rule3 = {"if temperature is warm and humidity is low", "then fanSpeed is high"};FuzzyRule rule4 = {"if temperature is hot and humidity is low", "then fanSpeed is very high"};FuzzyRule rule5 = {"if temperature is cold and humidity is high", "then fanSpeed is medium"};FuzzyRule rule6 = {"if temperature is cool and humidity is high", "then fanSpeed is high"};FuzzyRule rule7 = {"if temperature is warm and humidity is high", "then fanSpeed is very high"};FuzzyRule rule8 = {"if temperature is hot and humidity is high", "then fanSpeed is very high"};// 模糊推理引擎void fuzzyInference(FuzzyInput input, vector<FuzzyRule> rules, FuzzyOutput& output) {// 计算输入变量的模糊隶属度double temperatureMembership =隶属度计算(input.temperature, cold.membershipFunctions, cool.membershipFunctions, warm.membershipFunctions, hot.membershipFunctions);double humidityMembership =隶属度计算(input.humidity, cold.membershipFunctions, cool.membershipFunctions, warm.membershipFunctions, hot.membershipFunctions);// 遍历每条规则并进行推理for (FuzzyRule rule : rules) {string ifClause = rule.ifClause;string thenClause = rule.thenClause;// 提取规则的条件部分string temperature = ifClause.substr(0, ifClause.find("and"));string humidity = ifClause.substr(ifClause.find("and") + 3);// 计算条件部分的满足度double temperatureSatisfaction = temperatureMembership[std::stoi(temperature)];double humiditySatisfaction = humidityMembership[std::stoi(humidity)];// 计算规则的总满足度double satisfaction = temperatureSatisfaction * humiditySatisfaction;// 提取规则的结论部分string fanSpeed = thenClause;// 更新输出变量的模糊隶属度output.fanSpeed[std::stoi(fanSpeed)] = satisfaction;}}// 隶属度计算函数double 隶属度计算(double x, vector<double> membershipFunctions, vector<double> membershipFunctions, vector<double> membershipFunctions, vector<double> membershipFunctions) {// 检查输入是否在模糊集合的定义域内if (x < membershipFunctions[0] || x > membershipFunctions[3]) {return 0.0;}// 计算模糊隶属度double membership = 0.0;for (int i = 0; i < 4; i++) {if (membershipFunctions[i] <= x && x < membershipFunctions[i + 1]) { membership = membershipFunctions[i + 1] - x;membership /= (membershipFunctions[i + 1] - membershipFunctions[i]);break;}}return membership;}int main() {FuzzyInput input = {22.0, 60.0};FuzzyOutput output;// 定义模糊规则vector<FuzzyRule> rules = {rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8};// 进行模糊推理fuzzyInference(input, rules, output);// 输出模糊推理结果cout << "Fan Speed: " << output.fanSpeed << endl;return 0;}```上述代码是一个简单的模糊控制系统，用于根据输入的温度和湿度来控制风扇的速度。

步进电机模糊pid算法基本原理,c语言实现

步进电机模糊pid算法基本原理,c语言实现模糊PID（Proportional-Integral-Derivative）控制算法结合了模糊逻辑和传统PID控制算法，旨在提高系统的鲁棒性和稳定性。

步进电机作为一种常见的执行器，可以通过模糊PID算法实现精确的位置控制。

以下是模糊PID算法的基本原理以及C语言实现的简要步骤：模糊PID算法基本原理：1.模糊化输入和输出：将系统的输入（误差）和输出（控制量）进行模糊化，将其转换为模糊集合。

2.模糊规则库：建立模糊规则库，其中包含了一系列模糊规则，用于描述输入与输出之间的关系。

这些规则可以根据经验知识或系统模型来确定。

3.模糊推理：通过模糊规则库对模糊化的输入进行推理，得到模糊输出。

通常采用最大最小原则或加权平均等方法进行推理。

4.去模糊化：将模糊输出转换为确定性的控制量，即进行去模糊化操作。

常用的方法包括最大隶属度法、加权平均法等。

5.PID调节器：利用模糊输出和经典PID控制算法相结合，调节系统的控制量，使系统达到期望的运行状态。

C语言实现步骤：1.模糊化输入和输出：定义输入误差和输出控制量的模糊集合，并实现模糊化函数。

2.模糊规则库：定义一系列模糊规则，描述输入和输出之间的关系。

3.模糊推理：根据输入误差和模糊规则库进行推理，得到模糊输出。

4.去模糊化：实现去模糊化函数，将模糊输出转换为确定性的控制量。

5.PID调节器：结合经典PID控制算法，根据模糊输出和去模糊化后的控制量进行调节。

以下是一个简单的C语言实现示例：// 模糊化函数float fuzzyfication(float error) {// 省略具体实现，根据误差值计算归属度return fuzzy_value;}// 模糊规则库float fuzzy_rule(float error) {// 省略具体实现，定义模糊规则return fuzzy_output;}// 去模糊化函数float defuzzyfication(float fuzzy_output) {// 省略具体实现，根据模糊输出计算确定性的控制量return control_output;}int main() {float error = 0.0; // 输入误差float fuzzy_input = fuzzyfication(error); // 模糊化输入float fuzzy_output = fuzzy_rule(fuzzy_input); // 模糊推理float control_output = defuzzyfication(fuzzy_output); // 去模糊化输出// 利用确定性的控制量进行PID调节// 省略PID控制算法的实现// 控制步进电机运动return 0;}在实际应用中，模糊PID算法需要根据具体的系统和需求进行调试和优化，以实现良好的控制效果。

控制系统中的模糊控制算法设计与实现

控制系统中的模糊控制算法设计与实现现代控制系统在实际应用中，往往面临着多变、复杂、非线性的控制问题。

传统的多变量控制方法往往无法有效应对这些问题，因此，模糊控制算法作为一种强大的控制手段逐渐受到广泛关注和应用。

本文将从控制系统中的模糊控制算法的设计和实现两个方面进行介绍，以帮助读者更好地了解和掌握这一领域的知识。

一、模糊控制算法的设计1. 模糊控制系统的基本原理模糊控制系统是一种基于模糊逻辑的控制系统，其基本思想是通过将输入和输出变量模糊化，利用一系列模糊规则来实现对系统的控制。

模糊控制系统主要由模糊化、规则库、模糊推理和解模糊四个基本部分组成，其中规则库是模糊控制系统的核心部分，包含了一系列的模糊规则，用于描述输入和输出变量之间的关系。

2. 模糊控制算法的设计步骤（1）确定输入和输出变量：首先需要明确系统中的输入和输出变量，例如温度、压力等。

（2）模糊化：将确定的输入和输出变量进行模糊化，即将其转换为模糊集合。

（3）建立模糊规则库：根据实际问题和经验知识，建立一系列模糊规则。

模糊规则关联了输入和输出变量的模糊集合之间的关系。

（4）模糊推理：根据当前的输入变量和模糊规则库，利用模糊推理方法求解输出变量的模糊集合。

（5）解模糊：将求解得到的模糊集合转换为实际的输出值，常用的方法包括最大值法、加权平均法等。

3. 模糊控制算法的设计技巧（1）合理选择输入和输出变量的模糊集合：根据系统的实际需求和属性，选择合适的隶属函数，以便更好地描述系统的特性。

（2）精心设计模糊规则库：模糊规则库的设计是模糊控制算法的关键，应根据实际问题与经验知识进行合理的规则构建。

可以利用专家经验、试验数据或者模拟仿真等方法进行规则的获取和优化。

（3）选用合适的解模糊方法：解模糊是模糊控制算法中的一项重要步骤，选择合适的解模糊方法可以提高控制系统的性能。

常用的解模糊方法有最大值法、加权平均法、中心平均法等，应根据系统的需求进行选择。

模糊逻辑系统的C语言实现方法

详细地介绍了利用软件进行模糊逻辑控制系统设计的基本原理以及模糊控制器的软件程序设计方法。

实验表明，模糊逻辑系统的C语言实现方法是完全可行的，并且能够大大减少工作量。

模糊PID C语言程序

C语言PID演示程序#include <string.h>#include<stdio.h>typedef struct PID{double Command; //输入指令double Proportion; //比例系数double Integral; //积分系数double Derivative; //微分系数double preErr; //前一拍误差double sumErr; //误差累积}PID;double PIDCale(PID *p,double feedback){double dErr,Err;Err=p->Command-feedback; //当前误差p->sumErr+=Err; //误差累加dErr=Err-p->preErr; //误差微分p->preErr=Err;return(p->Proportion*Err //比例项+p->Derivative*dErr //微分项+p->Integral*p->sumErr); //积分项}void PIDInit(PID *p){memset(p,0,sizeof(PID)); //初始化}typedef struct motor{double lastY;double preY;double lastU;double preU;}motor;void motorInit(motor *m){memset(m,0,sizeof(motor));}double motorCal(motor *m,double u)doubley=1.9753*m->lastY-0.9753*m->preY+0.00003284*u+0.00006568*m->lastU+0.0000 3284*m->preU;//二阶系统m->preY=m->lastY;m->lastY=y;m->preU=m->lastU;m->lastU=u;return y;}void main(){FILE *fp=fopen("data.txt","w+");PID sPID;motor m_motor;int k=0;double u;double y=0;PIDInit(&sPID);sPID.Proportion=2;sPID.Derivative=1;sPID.Integral=0.00001;mand=10;motorInit(&m_motor);while(k<=1000){•fprintf(fp,"%d 设定值=%f 被控量=%f 偏差=%f 控制量=%f\n",k,mand,y,mand-y,u);u=PIDCale(&sPID,y);y=motorCal(&m_motor,u);k++;}printf("%f\n",y);fclose(fp);}增量式PID控制C语言代码增量式PID控制C语言代码////////////////////////////////////////////////////////////////// 定义PID参数结构体///////////////////////////////////////////////////////////////typedef struct PID { //结构体定义int SetPoint //设定值int Proportion; // Proportion 比例系数int Integral; // Integral 积分系数int Derivative; // Derivative 微分系数int LastError; // Error[-1] 前一拍误差int PreError; // Error[-2] 前两拍误差} PID;main(){PID vPID; //定义结构变量名PIDInit ( &vPID ); //Initialize StructurevPID.Proportion = 10; //Set PID CoefficientsvPID.Integral = 10; // Set PID IntegralvPID.Derivative = 10; // Set PID DerivativevPID. SetPoint = //根据实际情况设定while(1){Verror=Measure(); //得到AD的输出值Error =vPID. SetPoint- Verror; //与设定值比较，得到误差值tempi=PIDCal(&vPID, Error;laser.Value+=tempi; // Value与Num[2]为共同体，共同体名laserLASERH=laser.Num[0];LASERL=laser.Num[1];}}/////////////////////////////////////////////////////////////////////////Title:PID参数初始化//Description: Proportion="0"// Integral=0// LastError=0//Input: PID的P、I控制常数和之前的误差量（PID *pp）//Return://////////////////////////////////////////////////////////////////////void PIDInit (PID *pp) //PID参数初始化，都置0 {memset ( pp,0,sizeof(PID));//memset()的函数，它可以一字节一字节地把整个数组设置为一个指定的值。

C语言实现模糊控制算法

if(XU[0]<=YU[0])//规则前提的可信度取小运算
ZU[0]=XU[0]; else
标题文本预设
ZU[0]=YU[0];
if(XU[1]<=YU[0])//规则前提的可信度取小运算
ZU[1]=XU[1];
else
ZU[1]=YU[0];
if(XU[0]<=YU[1])//规则前提的可信度取小运算
C语言实现模糊控制算法
C语言实现模糊控制算法--以洗衣机的模糊控制为例
模糊控制器结构
选用两输入单输出模糊控制器。控制器的输入为衣物的泥污和油污，输出
为洗涤时间。
标题文本预设
此部分内容作为文字排版占位显示
定义输入、输出模糊集
（建议使用主题字体）
泥污的模糊集表示为：SD(泥污少)、MD(泥污中)、LD(泥污多)；油污的模糊集表示为：NG(油污少)、MG(油污中)、LG(油污多)；洗涤时间的模糊集为: VS(很短)、S(短)、M(中)、L(长)、VL(很长)。
此部分内容作为文字排版占位显示（建议使用主题字体）
C语言实现模糊控制算法--以洗衣机的模糊控制为例
重心法反模糊
for(i=0;i<4;i++) ZUmax[i]=ZU[i];
for(j=0;j<3;j++)//冒泡法排序从小到大排 for(i=0;i<3-j;i++) if(ZUmax[i]>=ZUmax[i+1]) { Zij=ZUmax[i]; ZUmax[i]=ZUmax[i+1]; ZUmax[i+1]=Zij; }
油污Y
MG
0
min(3/5,μM(z)) min(1/5,μL(z))

simulink模糊pid控制模型转c语言代码 -回复

simulink模糊pid控制模型转c语言代码-回复"Simulink模糊PID控制模型转C语言代码"在控制系统中，PID（比例-积分-微分）控制器被广泛应用于实现对系统的稳定和精确控制。

然而，当面对非线性、不确定性或者复杂度较高的系统时，传统的PID控制往往无法满足需求。

这时，模糊控制成为一种有效的替代方法。

模糊PID控制结合了传统的PID控制和模糊控制的优点，是在复杂系统控制中常用的一种方法。

本文将介绍如何将Simulink模糊PID控制模型转化为C语言代码的步骤。

第一步：设计模糊PID控制模型在Simulink环境下，设计一个模糊PID控制模型。

首先，根据系统特性选择合适的输入和输出变量，如温度和控制信号。

然后，选择适当的模糊集合和隶属函数。

根据系统的动态响应，确定合适的模糊规则，并使用模糊推理机制进行系统的控制。

最后，评估和调整模型以满足系统的需求。

第二步：构建模糊PID控制器的C语言数据结构根据设计的模糊PID控制模型，构建对应的C语言数据结构。

首先，定义输入和输出变量的数据类型和范围。

然后，定义模糊控制器的数据结构，包括模糊集合、隶属函数和模糊规则等。

最后，定义需要使用的参数，如模糊PID控制器的增益和偏差。

第三步：实现模糊控制算法在C语言中，实现模糊控制算法。

首先，读取输入变量的传感器数据，如温度值。

然后，将传感器数据映射到相应的模糊集合上，并计算隶属度。

接下来，使用模糊推理机制基于模糊规则来确定输出变量的控制信号。

最后，使用PID控制算法对控制信号进行修正，以实现系统的稳定和精确控制。

第四步：测试和优化C语言代码在C语言环境下，对已实现的模糊PID控制算法进行测试和优化。

首先，使用模拟数据或者仿真实验验证C语言代码的正确性和准确性。

然后，根据需要对代码进行调整和优化，以满足系统的性能要求。

最后，使用实际系统进行验证和性能测试，对模糊PID控制算法进行进一步改进和优化。

模糊PID控制温控系统设计方案C语言程序代码

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

sbit SDI = P2^1。

sbit CS = P2^2。

sbit CLK = P2^3 。

sbit EOC = P2^4。

sbit RS = P2^5。

sbit RW = P2^6。

sbit EN = P2^7。

sbit KEY1= P3^0 。

sbit KEY2= P3^1 。

sbit KEY3= P3^2 。

sbit KEY4= P3^3 。

sbit KEY5= P3^4 。

sbit IN1 = P3^5。

sbit IN2 = P3^6。

sbit ENA = P3^7。

uchar flag。

uchar flag_start。

float S_temp=60.0。

float P_temp=20.0。

float Kp 。

float Ki 。

float Kd 。

float Err=0.0。

float Last_Err=0.0。

float D_Err=0.0 。

float Sum_Err=0.0。

float U=0.0。

/******************************函数功能：延时******************************/void delay_ms(uchar z){uchar i。

uchar j。

模糊逻辑控制的C语言实现

1 . 1 输入变量的模糊化将输人精确量变化为由隶属度函数表示的模糊集
合。隶属度函数可以是任何函数，只要其值域在0 到 1
之间即可。常用的隶
表1 隶属度函数数值表
属度函数有：高斯型、下标论域值大中小零
梯形、三角形、钟形等， 0 -6 1 0 0
0
本文采用了高斯型隶 1 -5.933 33 1 0 0
关键词:模糊逻辑控制；VC+ + ;实现
中图分类号:TP273
文献标识码:A
doi：10.3969/j.issn.1665-2272.2017.11.056
0 引言模糊逻辑控制是智能控制的一种，以模糊集合论、
模糊语言变量和模糊逻辑推理为基础。其算法的基本运算单元是模糊集合，模糊集合与普通集合定义基本相同，但是其不具备普通集合的确定性，也就是说，一个元素是否属于模糊集合不是用要么是该集合元素，要么不是该集合元素表示，而是用属于该集合的程度表示，最大值为1袁表示完全属于该集合，最小值为0袁表示不属于该集合，在 0 到 1 之间可以任意取值，表示在多大程度上属于该模糊集合。 1 模糊推理原理
后得到的隶属度值，其输出是整个前件的隶属度，模糊
逻辑算子可取模糊算子中的任意一个，常用的“与”算
子有:m in(最小)和 Prod(代数积)。常用的“或”算子有院
max(最大)和 probor(概率或)。本论文米用了最大和最
小算子。
1.猿蕴含运算(规则库）

C#对图片进行马赛克处理可控制模糊程度的实现代码

C#对图⽚进⾏马赛克处理可控制模糊程度的实现代码具体代码如下所⽰：using System.Drawing;using System.Drawing.Imaging;using System.Web.Mvc;namespace MVC2017_Sample.Controllers{public class DefaultController : Controller{public ActionResult Index(){//原图Image img = Image.FromFile("c:\\1.jpg");Bitmap map = new Bitmap(img);//马赛克处理后的图⽚ Image img2 = AdjustTobMosaic(map, 20);img2.Save("c:\\1_bak.jpg", ImageFormat.Jpeg);return View();}/// <summary>/// 马赛克处理/// </summary>/// <param name="bitmap"></param>/// <param name="effectWidth"> 影响范围每⼀个格⼦数 </param>/// <returns></returns>public Bitmap AdjustTobMosaic(System.Drawing.Bitmap bitmap, int effectWidth){// 差异最多的就是以照⼀定范围取样玩之后直接去下⼀个范围for (int heightOfffset = 0; heightOfffset < bitmap.Height; heightOfffset += effectWidth){for (int widthOffset = 0; widthOffset < bitmap.Width; widthOffset += effectWidth){int avgR = 0, avgG = 0, avgB = 0;int blurPixelCount = 0;for (int x = widthOffset; (x < widthOffset + effectWidth && x < bitmap.Width); x++){for (int y = heightOfffset; (y < heightOfffset + effectWidth && y < bitmap.Height); y++){System.Drawing.Color pixel = bitmap.GetPixel(x, y);avgR += pixel.R;avgG += pixel.G;avgB += pixel.B;blurPixelCount++;}}// 计算范围平均avgR = avgR / blurPixelCount;avgG = avgG / blurPixelCount;avgB = avgB / blurPixelCount;// 所有范围内都设定此值for (int x = widthOffset; (x < widthOffset + effectWidth && x < bitmap.Width); x++){for (int y = heightOfffset; (y < heightOfffset + effectWidth && y < bitmap.Height); y++){System.Drawing.Color newColor = System.Drawing.Color.FromArgb(avgR, avgG, avgB);bitmap.SetPixel(x, y, newColor);}}}}return bitmap;}}}总结以上所述是⼩编给⼤家介绍的C#对图⽚进⾏马赛克处理可控制模糊程度的实现代码，希望对⼤家有所帮助，如果⼤家有任何疑问请给我留⾔，⼩编会及时回复⼤家的。

模糊算法的研究和C语言实现--包宇骅

模糊算法的研究和C语言实现-模糊算法是通过对现实对象的分析，处理数据并构建模糊型数学模型。

用隶属关系将数据元素集合灵活成模糊集合，确定隶属函数，进行模糊统计多依据经验和人的心理过程，它往往是通过心理测量来进行的，它研究的是事物本身的模糊性。

近年来，智能控制理论和方法的研究受到国内外众多专家和学者的高度重视，并取得了许多成功的实例。

目前，对于工业过程控制，实用的智能控制方法主要有两种：专家式控制和模糊控制，它们的特点是基于“专家”经验设计控制器，而无需考虑工业对象具体物理模型，尤其是后一种方法，由于它利用了模糊推理，已形成了一套较为规范的设计程序，且成功实例较多，故目前模糊控制算法的研究较为活跃。

模糊控制的特点①适用于不易获得精确数学模型的被控对象；②是一种语言变量控制器；③从属于智能控制的范畴。

该系统尤其适于非线性，时变，滞后系统的控制；④抗干扰能力强，响应速度快，并对系统参数的变化有较强的鲁棒性。

模糊控制的原理把由各种传感器测出的精确量转换成为适于模糊运算的模糊量,然后将这些量在模糊控制器中加以运算, 最后再将运算结果中的模糊量转换为精确量, 以便对各执行器进行具体的操作控制，在模糊控制中, 存在着一个模糊量和精确量之间相互转化的问题。

s:系统的设定值；x1, x2:模糊控制的输入(精确量)；X1 , X2:模糊量化处理后的模糊量；U:经过模糊控制规则和近似推理后得出的模糊控制量；u:经模糊判决后得到的控制量(精确量)；y:对象的输出。

也可以表示成：工作步骤：输入量模糊化、建立模糊规则、进行模糊推理、输出量反模糊。

模糊控制的优点：传统的自动控制控制器的综合设计都要建立在被控对象准确的数学模型(即传递函数模型或状态空间模型)的基础上，但是在实际中，很多系统的影响因素很多，油气混合过程、缸内燃烧过程等) ，很难找出精确的数学模型。

这种情况下，模糊控制的诞生就显得意义重大。

因为模糊控制不用建立数学模型不需要预先知道过程精确的数学模型。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

由于项目需要，需要模糊控制算法，之前此类知识为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);}。