模糊控制算法c程序

合集下载

模糊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语言实现--包宇骅

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

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

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

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

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

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

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

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

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

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

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

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

模糊PID控制温控系统设计C语言程序代码(文档良心出品)

//隶属于 Kp 的隶属程度
int code KpRule[7][7]=
//Kp 的模糊控制表
{
3,3,3,3,3,3,3,
2,2,2,2,1,2,2,
1,1,1,1,1,1,1,
1,1,0,1,0,1,1,
0,0,1,0,0,1,0,
0,1,0,1,0,0,2,
3,3,3,3,3,3,3
};
/***** 误差 E 隶属函数描述 *****/
if(KEY1==0) {
delay_ms(1); if(KEY1==0) {
S_temp=S_temp+1; if(S_temp>=200)
S_temp=200; while(!KEY1); } } if(KEY2==0) { delay_ms(1); if(KEY2==0) { if(S_temp>0)
delay_us(10); Show_char(1,1,'T'); delay_us(10); Show_char(2,1,':'); delay_us(10); Show_Num(3,1,3,P_temp); delay_us(10); Show_char(10,1,'S'); delay_us(10); Show_char(11,1,'T'); delay_us(10); Show_char(12,1,':'); delay_us(10); Show_Num(13,1,3,S_temp); delay_us(10); Show_char(0,2,'P'); delay_us(10); Show_char(1,2,':'); delay_us(10); Show_Num(2,2,2,Kp); delay_us(10); Show_char(5,2,'I'); delay_us(10); Show_char(6,2,':'); delay_us(10); Show_char(8,2,'.'); delay_us(10); Show_Ki(Ki); delay_us(10); Show_char(12,2,'D'); delay_us(10); Show_char(13,2,':'); delay_us(10); Show_Num(14,2,2,Kd); delay_us(10); }

基于模糊控制的速度跟踪控制问题(C语言以及MATLAB仿真实现)

基于模糊控制的速度控制——地面智能移动车辆速度控制系统问题描述利用模糊控制的方法解决速度跟踪问题，即已知期望速度(desire speed)，控制油门(throttle output)和刹车(brake output)来跟踪该速度。

已知输入：车速和发动机转速（值可观测）。

欲控制刹车和油门电压（同一时刻只有一个量起作用）。

算法思想模糊控制器是一语言控制器，使得操作人员易于使用自然语言进行人机对话。

模糊控制器是一种容易控制、掌握的较理想的非线性控制器，具有较佳的适应性及强健性(Robustness)、较佳的容错性(Fault Tolerance)。

利用控制法则来描述系统变量间的关系。

不用数值而用语言式的模糊变量来描述系统，模糊控制器不必对被控制对象建立完整的数学模式。

Figure 1模糊控制器的结构图模糊控制的优点：(1)模糊控制是一种基于规则的控制，它直接采用语言型控制规则，出发点是现场操作人员的控制经验或相关专家的知识，在设计中不需要建立被控对象的精确的数学模型，因而使得控制机理和策略易于接受与理解，设计简单，便于应用。

(2)由工业过程的定性认识出发，比较容易建立语言控制规则，因而模糊控制对那些数学模型难以获取，动态特性不易掌握或变化非常显著的对象非常适用。

(3)基于模型的控制算法及系统设计方法，由于出发点和性能指标的不同，容易导致较大差异；但一个系统语言控制规则却具有相对的独立性，利用这些控制规律间的模糊连接，容易找到折中的选择，使控制效果优于常规控制器。

(4)模糊控制是基于启发性的知识及语言决策规则设计的，这有利于模拟人工控制的过程和方法，增强控制系统的适应能力，使之具有一定的智能水平。

简化系统设计的复杂性，特别适用于非线性、时变、模型不完全的系统上。

模糊控制的缺点1.模糊控制的设计尚缺乏系统性，这对复杂系统的控制是难以奏效的。

所以如何建立一套系统的模糊控制理论，以解决模糊控制的机理、稳定性分析、系统化设计方法等一系列问题；2.如何获得模糊规则及隶属函数即系统的设计办法，这在目前完全凭经验进行；3.信息简单的模糊处理将导致系统的控制精度降低和动态品质变差。

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

模糊逻辑控制的C语言实现作者：王刚，王海龙，王萍来源：《科技创业月刊》 2017年第11期摘要：在某航天外弹道测量设备中，采用模糊逻辑控制对伺服位置环进行改进，且在MATLAB软件完成了仿真验证，其中模糊逻辑控制部分应用了MATLAB软件提供的现成模块，需要将其转变成C语言实现。

在研究模糊逻辑实现方法的基础上，将模糊逻辑用C语言实现。

关键词：模糊逻辑控制；VC＋＋；实现中图分类号：TP273 文献标识码：A doi：10．3969/j．issn．1665－2272．2017．11．0560 引言模糊逻辑控制是智能控制的一种，以模糊集合论、模糊语言变量和模糊逻辑推理为基础。

其算法的基本运算单元是模糊集合，模糊集合与普通集合定义基本相同，但是其不具备普通集合的确定性，也就是说，一个元素是否属于模糊集合不是用要么是该集合元素，要么不是该集合元素表示，而是用属于该集合的程度表示，最大值为1，表示完全属于该集合，最小值为0，表示不属于该集合，在0到1之间可以任意取值，表示在多大程度上属于该模糊集合。

1 模糊推理原理模糊推理是建立在人的直觉和经验的基础上，对被控对象的控制不是通过精确的数学表达式计算，而是通过专家或熟练操作人员丰富的实践经验和直观感觉来完成。

宏观地讲，所谓模糊推理是指通过模糊逻辑运算将输入映射到输出的过程，且根据模糊推理的输出做出决策，模糊推理原理框图如图1所示。

模糊推理运算过程可以划分为5个部分，分别为：1．1 输入变量的模糊化将输入精确量变化为由隶属度函数表示的模糊集合。

隶属度函数可以是任何函数，只要其值域在0到1之间即可。

常用的隶属度函数有：高斯型、梯形、三角形、钟形等，本文采用了高斯型隶属度函数。

为了简化软件的编写并改善程序运行速度，将隶属度函数值事先用matlab 软件计算，保存成文本文件，在用C语言编程时，首先读取该文件，将其保存成矩阵形式，行表示语言变量的值，列表示论域的值（由于论域的值有小数，需要转换成整数下标），隶属度函数如表1所示。

模糊逻辑系统的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.引言对于模糊控制的实现是模糊控制在实际应用中的一个重要环节。

模糊PID控制算法的C#实现

模糊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。

步进电机模糊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算法需要根据具体的系统和需求进行调试和优化，以实现良好的控制效果。

模糊控制算法c程序

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

#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语言程序代码请注意，由于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参数和变量，以及温度传感器读取函数和控制器输出函数。

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

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

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

（完整版）模糊PID控制的C程序

（完整版）模糊PID控制的C程序//e:[-3,3] ec:[-3,3] kp:[-0.3,0.3]#include#define NB 0#define NM 1#define NS 2#define ZO 3#define PS 4#define PM 5#define PB 6/*********************************************************/ float uf(float x,float a,float b,float c);float cuf(float x,float a,float b,float c);float ufl(float x,float a,float b);float cufl(float x,float a,float b);float ufr(float x,float a,float b);float cufr(float x,float a,float b);float ufr(float x,float a,float b);float cufr(float x,float a,float b);float fand(float a,float b);float forr(float a,float b);float FuzzyKp(float e,float ec);//主程序void main(){float a,b,Kp;printf("The E is:");scanf("%f",&a);printf("The Ec is:");scanf("%f",&b);Kp=FuzzyKp(a,b);printf("The parameter Kp is: %f\n\n",Kp);float FuzzyKp(float e,float ec){float es[7];float ecs[7];/******模糊推理规则的可信度通过取小点运算得到*****/ float form[7][7];//(表X7)（隶属度表）int i,j;/*************求得的最大值赋给form[a][b]*********/ int a=0,b=0;float lsd;int p;float detkp;/**************************/int kp[7][7]={{PB,PB,PM,PS,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}};es[NB]=ufl(e,-3,-1);es[NM]=uf(e,-3,-2,0);es[NS]=uf(e,-3,-1,1);es[ZO]=uf(e,-2,0,2);es[PS]=uf(e,-1,1,3);es[PM]=uf(e,0,2,3);es[PB]=ufr(e,1,3);ecs[NB]=ufl(ec,-3,-1);//ececs[NM]=uf(ec,-3,-2,0);ecs[NS]=uf(ec,-3,-1,1);ecs[ZO]=uf(ec,-2,0,2);ecs[PS]=uf(ec,-1,1,3);ecs[PM]=uf(ec,0,2,3);ecs[PB]=ufr(ec,1,3);for(i=0;i<7;i++){float w,h,r;for(j=0;j<7;j++){h=es[i];r=ecs[j];w=fand(h,r);form[i][j]=w;}}for(i=0;i<7;i++){for(j=0;j<7;j++){if(form[a][b]<form[i][j])< p="">{a=i;b=j;}}}lsd=form[a][b];//es和ecs最值中的最大值p=kp[a][b]; if(p==NB)detkp=cufl(lsd,-0.3,-0.1);else if(p==NM)detkp=cuf(lsd,-0.3,0.2,0);else if(p==NS)detkp=cuf(lsd,-0.3,-0.1,0.1);else if(p==ZO)detkp=cuf(lsd,-0.2,0,0.2);else if(p==PS)detkp=cuf(lsd,-0.1,0.1,0.3);else if(p==PM)detkp=cuf(lsd,0,0.2,0.3);else if(p==PB)detkp=cufr(lsd,0.1,0.3);return detkp;}/**************************************以下为附属子函数*//**************求隶属度（三角形）模糊化处理***************/ float uf(float x,float a,float b,float c){if(x<=a)return (0);else if((a<x)&&(x<=b))< p="">return( (x-a)/(b-a));else if((b<x)&&(x<=c))< p="">return( (c-x)/(c-b));else if(x>c)return (0);}/****************三角形反模糊化处理(最大隶属度法)**********************/float cuf(float x,float a,float b,float c){float y,z;z=(b-a)*x+a;y=c-(c-b)*x;return (y+z)/2;}/*****************梯形(左)求隶属度模糊化*******************/ float ufl(float x,float a,float b){if(x<=a)return 1;else if((a<x)&&(x<=b))< p="">return (b-x)/(b-a);else if(x>b)return 0;}/*******************梯形反模糊化***********************/ float cufl(float x,float a,float b){return b-(b-a)*x;}/*****************梯形(右)求隶属度模糊化*******************/ float ufr(float x,float a,float b){if(x<=a)return 0;if((a<x)&&(x<b))< p="">return (x-a)/(b-a);if(x>=b)return 1;}/*******************梯形反模糊化***********************/ float cufr(float x,float a,float b){return (b-a)*x +a;}/*******************求交集***********************/ float fand(float a,float b){return (a}/*******************求并集***********************/ float forr(float a,float b){return (a<b)?b:a;< p="">}</b)?b:a;<></x)&&(x<b))<></x)&&(x<=b))<></x)&&(x<=c))<></x)&&(x<=b))<></form[i][j])<>。

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控制算法进行进一步改进和优化。

二阶模糊控制C代码

for(i=0;eff0[i]<5;i++)//x0 {
for(j=0;eff1[j]<5;j++)//x1 {
k=eff0[i]*5+eff1[j]; //表示激活的是第 k 条规则 w=ratio0[i]*ratio1[j]; //第 n 条规则的权重 y+=w*(mf[k][0]*x0+mf[k][1]*x1+mf[k][2]);//第 n 条规则的输出 w_sum+=w; //权重之和 } } result=y/w_sum; if(result>100) result=100; else if(result<-100) result=-100;
//Define Input2 : x1 static const double x1MF[5][3] ={ {-150,-100.013780153615,-49.9047004963334}, // parameters of MF1 {-100.000934290399,-50.0303441133254,-0.0768935809041217}, // parameters of MF2 {-50.1310625242235,0.00302377893580271,50.1515206951587}, // parameters of MF3 {0.0821405084483802,50.0357443829106,100.005433716464}, // parameters of MF4 {49.898634165903,100.016136279777,150} // parameters of MF5 }; //The definition of x1 end.

模糊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。

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);}。