很难找的基于模糊控制的程序源代码
单片机 模糊控制pid 源代码
单片机模糊控制pid 源代码1. 单片机模糊控制PID的基本原理单片机模糊控制PID是一种基于模糊控制理论和PID控制理论相结合的控制方法。
其基本原理是通过模糊控制算法对系统进行模糊化处理，将输入和输出都转化为模糊量，然后再利用PID控制算法对模糊量进行处理，最终得到控制量，从而实现对系统的控制。
2. 单片机模糊控制PID的源代码实现单片机模糊控制PID的源代码实现需要先进行模糊化处理，然后再进行PID控制计算。
下面是一个基于C语言的单片机模糊控制PID的源代码示例：```#include <stdio.h>#include <stdlib.h>#include <math.h>//模糊化处理函数float fuzzy(float error){float fuzzy_error = 0;if(error < -10)fuzzy_error = -1;else if(error >= -10 && error < -5)fuzzy_error = (error + 10) / 5;else if(error >= -5 && error <= 5)fuzzy_error = 0;else if(error > 5 && error <= 10)fuzzy_error = (error - 5) / 5;else if(error > 10)fuzzy_error = 1;return fuzzy_error;}//PID控制函数float PID(float error, float last_error, float sum_error) {float kp = 0.5;float ki = 0.1;float kd = 0.2;float p = kp * error;float i = ki * sum_error;float d = kd * (error - last_error);return p + i + d;}int main(){float error = 0;float last_error = 0;float sum_error = 0;float control = 0;for(int i = 0; i < 100; i++){error = 10 - i;float fuzzy_error = fuzzy(error);sum_error += error;control = PID(fuzzy_error, last_error, sum_error);last_error = error;printf("control: %f\n", control);}return 0;}```3. 单片机模糊控制PID的应用场景单片机模糊控制PID可以应用于各种需要精确控制的场景，例如温度控制、机器人控制、电机控制等。
模糊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语言程序代码。
基于MSP430和模糊PID油田注水流量控制系统
不及其他工艺工程 ， 注水方法 和装备相 对落 后 ， 近年来 ， 随着我
国各 主 力 油 田 已 相 继 进 入 高 或 特 高 含 水 期 ， 油 速 度 变 缓 、 采 含 水 上 升 加 快 、 量 逐 步 下 降 、 本 上 升 的 矛 盾 已无 法 回 避 ， 过 产 成 通
１ 脚的 Ｔ ＿ ２ １ ＿ ２０封装 中 ， 由分 立元件 构成 的桥式驱 动 电路 相 与 比，ＭＤ ８０ Ｌ １２ ０构成的驱动 电路结构简化 ， 内设 过热报警输 出和
自动关 断保 护 电 路 ， 能 更 加 可 靠 。 Ｌ 性 ＭＤＩ２ ０可 采 用 ２种 不 ８０
用检测 仪器 、电机 控制 、家 庭 自动化 等 领域得 到 了广 泛 的应
集 电路 、Ｃ Ｌ Ｄ显 示 电 路 、 盘 电 路 等 。 键
２ １ 以单 片 机 为 核 心 的 控 制 系统 ．
接触的材料 为高合金钢 ， 耐磨耐腐蚀 ， 积相 对较小 ， 体 测量精度
能达 到 １ 左 右 。 ％ ２ ５ 电 机 控 制 ． 驱 动 电路 为 用 于 电机 驱 动 的功 率 集 成 芯 片 Ｌ １２ ０ 它 ＭＤ ８ ０ 。
系 统 由微 功 耗 单 片 机 系 统 、 门控 制 、 源 管 理 模 块 、 Ｃ 阀 电 ＬＤ
显示 、 Ｐ Ｓ 块 等 部 分 组 成 。 系 统 图 的 硬 件 原 理 框 图 如 图 １ ＧＲ 模
所示。
工作 原 理 ： 统 以 ＭＳ ４ ０ １９为 核 心 ， 统 大 部 分 时 问 都 系 Ｐ ３Ｆ４ 系 处 于 低 功 耗 模 式 Ｌ Ｍ０ 当定 时 中 断 到 来 时 ， 醒 Ｃ Ｕ进 入 工 作 Ｐ ， 唤 Ｐ 周期 开 始 新 一 轮 采 集 压 力 、 量 信 号 ， 流 当完 成 采 集 信 号 的 转 换
自动化控制系统中的模糊控制方法与调参技巧
自动化控制系统中的模糊控制方法与调参技巧自动化控制系统中的模糊控制方法是一种基于模糊逻辑的控制策略，可以处理系统模型复杂、不确定性强的问题。
模糊控制方法通过将模糊逻辑应用于控制器设计中，能够有效地应对实际系统中的各种非线性、时变和不确定性因素，提高控制系统的鲁棒性和自适应能力。
在模糊控制系统中，模糊逻辑通过将模糊的自然语言规则转化为数学形式，对系统的输入和输出进行模糊化处理，从而实现对系统的自动控制。
模糊控制方法主要包括模糊推理、模糊建模和模糊控制器设计三个主要步骤。
首先，模糊推理是模糊控制方法的核心，它根据一组模糊规则对输入变量进行模糊推理，从而确定最终的控制策略。
在模糊推理中，需要定义一组模糊规则，每个模糊规则都由若干个模糊集和若干个模糊关系所组成。
通过对输入变量的模糊化处理和模糊规则的匹配，可以得到控制器的输出。
其次，模糊建模是模糊控制方法的前提，它是将实际系统映射为模糊控制系统的关键步骤。
模糊建模可以通过实验数据、专家知识或模型等方式获得系统的输入输出数据，然后利用聚类和拟合等方法建立系统的模糊模型。
模糊建模的目的是找到系统的内在规律和数学模型，以便后续的模糊控制器设计和参数调优。
最后，模糊控制器设计是模糊控制方法的具体实现，它根据模糊推理和模糊建模的结果，确定模糊控制器的结构和参数。
模糊控制器的结构包括输入变量的模糊集合和输出变量的模糊集合，参数则决定了模糊控制器的具体行为。
参数调优是模糊控制器设计的关键环节，通过合理地设置参数，可以使模糊控制器在实际系统中具有良好的控制性能和鲁棒性。
为了获得较好的控制性能，模糊控制系统中的调参技巧是必不可少的。
调参技巧通常包括以下几个方面：首先，选取适当的输入变量和输出变量，并对其进行模糊化处理。
输入变量和输出变量的选择应考虑到系统的特性和控制目标，而模糊化处理的方法则可以采用三角函数、梯形函数等常用的模糊集合类型。
其次，确定模糊规则的数量和形式。
模糊规则的数量和形式直接影响到模糊控制系统的稳定性和鲁棒性。
基于PLC的模糊控制器设计及Simulink仿真
64 | 电子制作 2021年02月热能，当电流流过电阻材料时，电能转换成热能，产生热量，再通过热的传导、对流、辐射，能有效地用来加热特定的试验件，并保持高的效率，此种加热方式称为辐射加温。
辐射加热具有热转换率高、加热温度高等优点，因此是试验车台上使用最广泛的一种加热方式。
温度是试验任务中一项很重要的监控指标，很多试验任务要求在特定的温度下才能进行，实际温度值和控制的精度、准确度决定了试验能否进行下去，因此研究温度控制工作原理，寻找合适的控制算法具有重要意义。
辐射加温控制系统是典型的一阶纯滞后环节，可用一阶惯性环节加滞后环节表示，具有升温单向性、大惯性、纯滞后、非线性和时变性等特点，用传统控制方式易导致超调大、调节时间长、控制精度低。
其升温、保温是依靠电阻丝加热，当其温度一旦超调就无法用控制手段使其降温。
理论和经验表明，传统的PID 控制对温度控制系统无法达到理想效果[1-2]。
模糊控制是目前十分成熟的一种智能控制方法，其采用模糊逻辑把人的控制经验归纳为定性描述的一组条件语言，利用模糊集理论，将其定量化，使控制器模仿人的操作策略，模糊控制具有很强的鲁棒性和稳定性，大量的理论研究和实践也充分证明了用模糊控制理论控制电阻炉温度是一种非常好的方法策略[3]。
PLC 具有通用性好、性能可靠、编程灵活、扩展方便等优点，在工业控制中广泛使用，PLC 指令越来越强大，能够实现许多复杂的控制算法，利用PLC 实现模糊控制，结合二者的长处，在工业控制中大有前景。
基于上述，本文提出在PLC 平台上将模糊控制方法和常规PID 控制结合的控制策略。
1 控制策略当实际温度值和给定温度值偏差较大时，采用模糊控制合式控制策略，既可以保证系统动态响应效果，又能改善稳态控制精度，系统控制框图如图1所示。
其中S 为转换开关，其设定值一般取最大误差的10%，本文取20，即给定值和实际值偏差在20℃以内采用PID 控制，超过20℃采用模糊[4]模糊控制器能在线对PID 参数进行修改，进一步完善了传统PID 控制器的性能，更好的适应控制系统参数变化和工作条件，如图1所示，模糊控制器由模糊化，模糊推理和解模糊三个环节构成，将工程上的精确量转换为模糊输入信息，利用模糊规则进行模糊推理，经解模糊后转换为精确值，送到被控对象。
模糊逻辑与模糊控制的基本原理
模糊逻辑与模糊控制的基本原理在现代智能控制领域中，模糊逻辑与模糊控制是研究的热点之一。
模糊逻辑可以应用于形式化描述那些非常复杂，无法准确或完全定义的问题，例如语音识别、图像处理、模式识别等。
而模糊控制可以通过模糊逻辑的方法来设计控制系统，对那些难以表达精确数学模型的问题进行控制，主要用于不确定的、非线性的、运动系统模型的控制。
本文主要介绍模糊逻辑和模糊控制的基本原理。
一、模糊逻辑的基本原理模糊逻辑是对布尔逻辑的延伸，在模糊逻辑中，各种概念之间的相互关系不再是严格的，而是模糊的。
模糊逻辑的基本要素是模糊集合，模糊集合是一个值域在0和1之间的函数，它描述了一个物体属于某个事物的程度。
以温度为例，一般人将15℃以下的温度视为冷，20至30℃为暖，30℃以上为热。
但是在模糊逻辑中，这些概念并不是非黑即白，而可能有一些模糊的层次，如18℃可能既不是冷又不是暖，但是更接近于暖。
因此，设180℃该点的温度为x，则可以用一个图形来描述该温度与“暖”这个概念之间的关系，这个图形称为“隶属函数”或者“成员函数”图。
一个隶属函数是一个可数的、从0到1变化的单峰实函数。
它描述了一个物体与一类对象之间的相似程度。
对于温度为18℃的这个例子，可以用一个隶属函数来表示其与“暖”这一概念之间的关系。
这个隶属函数，可以用三角形或者梯形函数来表示。
模糊逻辑还引入了模糊关系和模糊推理的概念。
模糊关系是对不确定或模糊概念间关系的粗略表示，模糊推理是指通过推理机来对模糊逻辑问题进行判断和决策。
二、模糊控制的基本原理在控制系统中，通常采用PID控制或者其他经典控制方法来控制系统，但对于一些非线性控制系统，这些方法越发显得力不从心。
模糊控制是一种强大的、在处理非线性系统方面表现出色的控制方法。
它通过对遥测信号进行模糊化处理，并将模糊集合控制规则与一系列的控制规则相关联起来以实现控制。
模糊控制的基本组成部分主要包括模糊化、模糊推理、去模糊化等三个步骤。
模糊控制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控制-python实现
模糊pid控制 python实现模糊PID控制（Fuzzy PID control）是一种基于模糊逻辑的控制方法，它结合了模糊控制和经典PID控制的优点，可以在复杂和不确定的环境中实现精确的控制。
本文将介绍模糊PID控制的原理、实现方法以及在Python中的应用。
一、模糊PID控制的原理PID控制是一种经典的控制方法，它通过比较实际输出与期望输出之间的误差，根据比例、积分和微分三个参数进行调节，使系统输出逐渐趋近于期望值。
然而，传统的PID控制方法在面对非线性、时变和不确定性系统时表现不佳。
模糊PID控制通过引入模糊逻辑来解决传统PID控制的问题。
模糊逻辑是一种能够处理模糊信息的数学方法，它可以将模糊的输入映射到模糊的输出。
模糊PID控制器通过将误差、误差变化率和误差积分三个输入量模糊化，然后根据一组模糊规则进行推理，得到模糊输出。
最后，通过解模糊化的方法将模糊输出转化为具体的控制量。
二、模糊PID控制的实现方法1. 模糊化模糊化是将具体的输入量映射到模糊集合上的过程。
常用的模糊化方法有三角隶属函数、梯形隶属函数和高斯隶属函数等。
根据具体的问题和经验，选择合适的隶属函数进行模糊化。
2. 规则库规则库是模糊PID控制的核心。
它包含了一组模糊规则，用于根据输入量的模糊值推理出输出量的模糊值。
模糊规则一般采用IF-THEN的形式，例如“IF 误差是A1 AND 误差变化率是B2 THEN 输出是C3”。
规则库的设计需要根据具体问题进行，可以基于经验或者专家知识。
3. 推理机制推理机制是根据模糊规则进行推理的过程。
常用的推理方法有最大最小合成、模糊推理和模糊推理和等。
推理机制将模糊输入与规则库进行匹配，然后根据匹配的程度计算出模糊输出的隶属度。
4. 解模糊化解模糊化是将模糊输出转化为具体的控制量的过程。
常用的解模糊化方法有最大隶属度法、面积法和重心法等。
解模糊化方法根据模糊输出的隶属度分布，计算出具体的控制量。
模糊控制算法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);}。
2019年全国大学生数学建模竞赛题目A：高压油管的压力控制优秀论文范例三篇(含源代码)
2019年全国大学生数学建模竞赛题目A：高压油管的压力控制优秀论文范例三篇（含源代码）1. 引言高压油管是发动机燃油喷射系统中的重要组成部分，其压力的控制对于发动机的运行稳定性非常关键。
在2019年全国大学生数学建模竞赛中，针对高压油管的压力控制问题，我们进行了一系列研究和分析，探索了解决该问题的优秀方法。
本文将介绍三篇优秀论文范例，并提供源代码供读者参考。
2. 论文一：基于PID控制算法的高压油管压力控制2.1 问题描述本文从数学建模的角度出发，针对高压油管的压力控制问题提出了一种基于PID控制算法的解决方案。
该问题的要求是在给定的工况下，通过控制高压油泵的开关方式，使得一段时间内高压油管内的压力保持在一个预定的范围内。
2.2 算法设计本文提出了基于PID控制算法的高压油管压力控制方案。
PID控制是一种常用的反馈控制算法，通过不断调整控制器的参数，根据当前误差来调整控制信号。
在该方案中，我们将高压油管的压力误差作为PID控制器的输入，根据控制器输出的控制信号，调整高压油泵的开关状态。
通过不断的反馈调整，使得高压油管内的压力稳定在预定范围内。
2.3 仿真与实验结果本文通过对所提出的高压油管压力控制方案进行仿真与实验，验证了该方案的可行性和有效性。
仿真结果表明，通过PID控制算法，可以在较短的时间内将高压油管内的压力控制在预定范围内。
实验结果也进一步验证了方案的有效性。
2.4 源代码# PID控制算法实现def pid_control(p_error, i_error, d_error):Kp =0.5# 比例系数Ki =0.2# 积分系数Kd =0.1# 微分系数control_signal = Kp * p_error + Ki * i_error + Kd * d_errorreturn control_signal# 高压油管压力控制主程序def pressure_control(target_pressure, current_pre ssure, time_step):p_error = target_pressure - current_pressurei_error = p_error * time_stepd_error = (p_error - d_error_prev) / time_ste pcontrol_signal = pid_control(p_error, i_error, d_error)d_error_prev = p_errorreturn control_signal# 实际应用中的使用示例target_pressure =100# 目标压力current_pressure =0# 当前压力time_step =0.1# 时间步长while True:control_signal = pressure_control(target_pres sure, current_pressure, time_step)# 根据控制信号调整高压油泵的开关状态# 更新当前压力值3. 论文二：基于模型预测控制的高压油管压力控制3.1 问题描述本文针对高压油管的压力控制问题，提出了一种基于模型预测控制（MPC）的解决方案。
基于模糊控制的全位移平衡机器人设计
收稿日期：２０２２－０４－１６基金项目：山东省自然科学基金项目（ＺＲ２０２０ＭＦ０９３）；山东省研究生教育优质课程（ＳＤＹＫＣ２００２６）；中石油重大科技合作项目（ＺＤ２０１９ １８３ ００３）引用格式：刘恒，李哲，杨明辉，等．基于模糊控制的全位移平衡机器人设计［Ｊ］．测控技术，２０２３，４２（７）：１０２－１０９．ＬＩＵＨ，ＬＩＺ，ＹＡＮＧＭＨ，ｅｔａｌ．ＤｅｓｉｇｎｏｆＦｕｌｌＤｉｓｐｌａｃｅｍｅｎｔＢａｌａｎｃｉｎｇＲｏｂｏｔＢａｓｅｄｏｎＦｕｚｚｙＣｏｎｔｒｏｌ［Ｊ］．Ｍｅａｓｕｒｅｍｅｎｔ＆ＣｏｎｔｒｏｌＴｅｃｈｎｏｌｏｇｙ，２０２３，４２（７）：１０２－１０９．基于模糊控制的全位移平衡机器人设计刘 恒，李 哲，杨明辉，邓晓刚，曹玉苹（中国石油大学（华东）控制科学与工程学院，山东青岛 ２６６５８０）摘要：设计了一种模糊控制的四轮全位移平衡机器人，通过ＳｏｌｉｄＷｏｒｋｓ改进设计了基于麦克纳姆轮的全位移平衡底盘、双轴云台等机械结构。
以ＡｌｔｉｕｍＤｅｓｉｇｎｅｒ为开发平台设计了ＳＴＭ３２Ｆ４０５核心板主控，外设电路设计主要包括：ＩＣＭ２０９４８传感器电路、ＣＡＮ通信差分电路等。
使用Ｓｉｍｕｌｉｎｋ对算法进行仿真验证，云台控制算法使用了串级ＰＩＤ控制，底盘通过ＨＩ２２０陀螺仪传感器结合模糊控制算法实现平衡及运动。
最终制作出了实体机器人并对模糊控制算法进行了验证，与传统ＰＩＤ算法相比，基于模糊控制的平衡机器人在响应速度、鲁棒性、稳定性等方面均有一定的提升。
相比于传统四轮机器人，制作的平衡机器人能够更好地通过狭小的空间，对环境的适应性更强。
关键词：模糊控制；视觉识别；全位移；平衡机器人中图分类号：ＴＰ２４２．６ 文献标志码：Ａ 文章编号：１０００－８８２９（２０２３）０７－０１０２－０８ｄｏｉ：１０．１９７０８／ｊ．ｃｋｊｓ．２０２２．０８．２９８ＤｅｓｉｇｎｏｆＦｕｌｌＤｉｓｐｌａｃｅｍｅｎｔＢａｌａｎｃｉｎｇＲｏｂｏｔＢａｓｅｄｏｎＦｕｚｚｙＣｏｎｔｒｏｌＬＩＵＨｅｎｇ牞ＬＩＺｈｅ 牞ＹＡＮＧＭｉｎｇｈｕｉ牞ＤＥＮＧＸｉａｏｇａｎｇ牞ＣＡＯＹｕｐｉｎｇ牗ＣｏｌｌｅｇｅｏｆＣｏｎｔｒｏｌＳｃｉｅｎｃｅａｎｄＥｎｇｉｎｅｅｒｉｎｇ牞ＣｈｉｎａＵｎｉｖｅｒｓｉｔｙｏｆＰｅｔｒｏｌｅｕｍ牗ＥａｓｔＣｈｉｎａ牘牞Ｑｉｎｇｄａｏ２６６５８０牞Ｃｈｉｎａ牘Ａｂｓｔｒａｃｔ牶Ａｆｏｕｒ ｗｈｅｅｌｆｕｌｌｄｉｓｐｌａｃｅｍｅｎｔｂａｌａｎｃｉｎｇｒｏｂｏｔｗｉｔｈｆｕｚｚｙｃｏｎｔｒｏｌｉｓｄｅｓｉｇｎｅｄ．ＴｈｒｏｕｇｈＳｏｌｉｄＷｏｒｋｓ牞ｍｅｃｈａｎｉｃａｌｓｔｒｕｃｔｕｒｅｓｓｕｃｈａｓｆｕｌｌｄｉｓｐｌａｃｅｍｅｎｔｂａｌａｎｃｉｎｇｃｈａｓｓｉｓａｎｄｂｉａｘｉａｌｈｅａｄａｒｅｄｅｓｉｇｎｅｄｂａｓｅｄｏｎＭｃ Ｎａｍｗｈｅｅｌ．ＳＴＭ３２Ｆ４０５ｃｏｒｅｂｏａｒｄｍａｉｎｃｏｎｔｒｏｌｉｓｄｅｓｉｇｎｅｄｗｉｔｈＡｌｔｉｕｍＤｅｓｉｇｎｅｒａｓｔｈｅｄｅｖｅｌｏｐｍｅｎｔｐｌａｔ ｆｏｒｍ牞ａｎｄｔｈｅｐｅｒｉｐｈｅｒａｌｃｉｒｃｕｉｔｄｅｓｉｇｎｍａｉｎｌｙｉｎｃｌｕｄｅｓ牶ＩＣＭ２０９４８ｓｅｎｓｏｒｃｉｒｃｕｉｔ牞ＣＡＮｃｏｍｍｕｎｉｃａｔｉｏｎｄｉｆｆｅｒ ｅｎｔｉａｌｃｉｒｃｕｉｔ牞ｅｔｃ．Ｓｉｍｕｌｉｎｋｉｓｕｓｅｄｔｏｓｉｍｕｌａｔｅａｎｄｖｅｒｉｆｙｔｈｅａｌｇｏｒｉｔｈｍ牞ｔｈｅｇｉｍｂａｌｃｏｎｔｒｏｌａｌｇｏｒｉｔｈｍｕｓｅｓｃａｓ ｃａｄｅＰＩＤｃｏｎｔｒｏｌ牞ａｎｄｔｈｅｃｈａｓｓｉｓｉｓｂａｌａｎｃｅｄａｎｄｋｉｎｅｍａｔｉｃｂｙｕｓｉｎｇｔｈｅＨＩ２２０ｇｙｒｏｓｃｏｐｅｓｅｎｓｏｒｃｏｍｂｉｎｅｄｗｉｔｈｆｕｚｚｙｃｏｎｔｒｏｌａｌｇｏｒｉｔｈｍ．Ｆｉｎａｌｌｙ牞ａｓｏｌｉｄｒｏｂｏｔｉｓｐｒｏｄｕｃｅｄａｎｄｔｈｅｆｕｚｚｙｃｏｎｔｒｏｌａｌｇｏｒｉｔｈｍｉｓｖｅｒｉｆｉｅｄ．Ｃｏｍ ｐａｒｅｄｗｉｔｈｔｈｅｔｒａｄｉｔｉｏｎａｌＰＩＤａｌｇｏｒｉｔｈｍ牞ｔｈｅｂａｌａｎｃｅｄｒｏｂｏｔｈａｓｃｅｒｔａｉｎｉｍｐｒｏｖｅｍｅｎｔｉｎｒｅｓｐｏｎｓｅｓｐｅｅｄ牞ｒｏｂｕｓｔ ｎｅｓｓａｎｄｓｔａｂｉｌｉｔｙ．Ｃｏｍｐａｒｅｄｗｉｔｈｔｈｅｔｒａｄｉｔｉｏｎａｌｆｏｕｒ ｗｈｅｅｌｒｏｂｏｔ牞ｔｈｅｂａｌａｎｃｉｎｇｒｏｂｏｔｃａｎｂｅｔｔｅｒｐａｓｓｔｈｒｏｕｇｈｔｈｅｓｍａｌｌｓｐａｃｅａｎｄｈａｓｓｔｒｏｎｇｅｒａｄａｐｔａｂｉｌｉｔｙｔｏｔｈｅｅｎｖｉｒｏｎｍｅｎｔ．Ｋｅｙｗｏｒｄｓ牶ｆｕｚｚｙｃｏｎｔｒｏｌ牷ｖｉｓｕａｌｒｅｃｏｇｎｉｔｉｏｎ牷ｆｕｌｌｄｉｓｐｌａｃｅｍｅｎｔ牷ｂａｌａｎｃｅｄｒｏｂｏｔ随着世界经济和科技的高速发展以及人口数量的不断增多，人类对于各类资源的需求与日俱增，促使各国纷纷开始对未知风险的领域与地区进行资源的勘探与开发。
模糊控制与神经网络
BP神经网络BP (Back Propagation)神经网络是一种神经网络学习算法，全称基于误差反向传播算法的人工神经网络。
如图所示拓扑结构的单隐层前馈网络，一般称为三层前馈网或三层感知器，即：输入层、中间层（也称隐层）和输出层。
它的特点是：各层神经元仅与相邻层神经元之间相互全连接，同层内神经元之间无连接，各层神经元之间无反馈连接，够成具有层次结构的前馈型神经网络系统。
单计算层前馈神经网络只能求解线性可分问题，能够求解非线性问题的网络必须是具有隐层的多层神经网络。
在人工神经网络发展历史中，很长一段时间里没有找到隐层的连接权值调整问题的有效算法。
直到误差反向传播算法（BP算法）的提出，成功地解决了求解非线性连续函数的多层前馈神经网络权重调整问题。
BP (Back Propagation)神经网络，即误差反传误差反向传播算法的学习过程，由信息的正向传播和误差的反向传播两个过程组成。
输入层各神经元负责接收来自外界的输入信息，并传递给中间层各神经元；中间层是内部信息处理层，负责信息变换，根据信息变化能力的需求，中间层可以设计为单隐层或者多隐层结构；最后一个隐层传递到输出层各神经元的信息，经进一步处理后，完成一次学习的正向传播处理过程，由输出层向外界输出信息处理结果。
当实际输出与期望输出不符时，进入误差的反向传播阶段。
误差通过输出层，按误差梯度下降的方式修正各层权值，向隐层、输入层逐层反传。
周而复始的信息正向传播和误差反向传播过程，是各层权值不断调整的过程，也是神经网络学习训练的过程，此过程一直进行到网络输出的误差减少到可以接受的程度，或者预先设定的学习次数为止。
神经网络神经网络是：思维学普遍认为，人类大脑的思维分为抽象（逻辑）思维、形象（直观）思维和灵感（顿悟）思维三种基本方式。
逻辑性的思维是指根据逻辑规则进行推理的过程；它先将信息化成概念，并用符号表示，然后，根据符号运算按串行模式进行逻辑推理；这一过程可以写成串行的指令，让计算机执行。
模糊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参数和变量，以及温度传感器读取函数和控制器输出函数。
模糊控制算法
相互促进发展
模糊集合与模糊逻辑相互促进，不断发展，为解决复杂问题提供了 有力的工具。
03
模糊控制器设计
输入输出变量的确定
输入变量的确定
根据被控对象的特性和控制要求，选 择合适的输入变量，如温度、湿度、 压力等。
输出变量的确定
根据控制要求和系统性能指标，选择 合适的输出变量，如阀门开度、加热 功率等。
模糊控制算法
目录
• 模糊控制算法概述 • 模糊集合与模糊逻辑 • 模糊控制器设计 • 模糊控制算法的实现 • 模糊控制算法的优缺点 • 模糊控制算法的发展趋势与展望
01
模糊控制算法概述
模糊控制算法的定义
模糊集合
模糊集合是传统集合的扩展，它允许元素具有部分属于、部分不属于某个集合的模糊性。在模糊集合中，每个 元素都有一个隶属度，表示它属于该集合的程度。
感谢您的观看
THANKS
糊规则，计算出输出变量的隶属度函数。
模糊推理
基于专家知识和经验制定的模糊条件语句， 用于描述系统输入与输出之间的关系。模糊 规则通常采用“IF-THEN”形式，其中 “IF”部分是输入变量的模糊集合， “THEN”部分是输出变量的模糊集合。
去模糊化
将输出变量的模糊集合转换为精确值的过程 。通过选择合适的去模糊化方法（如最大值 去模糊化、最小值去模糊化、中心平均去模 糊化等），将输出变量的隶属度函数转换为 具体的输出值。
02
规则制定困难
模糊控制算法的核心是模糊规 则的制定，而模糊规则的制定 需要经验丰富的专业人员，且 往往需要反复调整和优化。
03
计算复杂度较高
对于大规模系统，模糊控制算 法的计算复杂度可能较高，需 要高性能的硬件设备才能实现 实时控制。
模糊PID控制中模糊控制规则的获取方法
模糊PID控制中模糊控制规则的获取方法一、概述随着工业自动化程度的不断提高，控制系统对于精确性和鲁棒性的要求也日益增强。
传统的PID控制方法虽然在实际应用中得到了广泛运用，但在处理非线性、时变以及具有不确定性的系统时，其控制效果往往不尽如人意。
模糊PID控制作为一种结合了模糊控制理论与PID控制优点的先进控制方法，逐渐受到了人们的关注。
模糊PID控制的核心在于通过模糊控制规则对PID控制器的参数进行在线调整，以适应系统特性的变化。
而模糊控制规则的获取则是实现模糊PID控制的关键步骤之一。
一个好的模糊控制规则不仅能够提高控制系统的性能，还能够降低系统的复杂度，使其更加易于实现和维护。
模糊控制规则的获取方法主要包括基于经验的方法、基于优化的方法以及基于学习的方法等。
基于经验的方法主要依赖于专家知识或实际操作经验，虽然简单易行，但往往缺乏足够的理论依据和普适性。
基于优化的方法则通过数学优化算法来寻找最优的模糊控制规则，虽然能够得到较为精确的结果，但计算复杂度较高，且对于复杂系统的优化问题可能难以求解。
而基于学习的方法则利用机器学习或深度学习等技术，通过大量数据的学习来获取模糊控制规则，这种方法具有更强的自适应性和泛化能力，但也需要足够的数据支持。
针对模糊PID控制中模糊控制规则的获取方法进行研究，具有重要的理论意义和实际应用价值。
本文旨在探讨各种模糊控制规则获取方法的优缺点及适用范围，为模糊PID控制的实际应用提供有益的参考。
1. 模糊PID控制的基本概念及特点模糊PID控制是一种结合模糊逻辑与PID控制算法的高级控制策略。
PID控制，即比例积分微分控制，是工业控制领域中应用最为广泛的控制方法之一。
传统的PID控制方法在面对复杂、非线性或时变系统时，往往难以取得理想的控制效果。
引入模糊逻辑对PID控制进行改进和优化，以提高其适应性和控制性能，成为了一种重要的研究方向。
模糊PID控制的核心思想是利用模糊逻辑对PID控制器的三个关键参数——比例系数Kp、积分系数Ki和微分系数Kd进行动态调整。
基于西门子S7—200PLC的模糊控制程序的实现
基于西门子S7—200PLC的模糊控制程序的实现【摘要】矿用通风机是矿井生产的重要设备，其运行状态对安全生产至关重要。
本文结合矿用通风机，探讨了如何通过PLC可编程逻辑控制器件来实现模糊控制算法，从而来控制风机转速，实现了对巷道内CO及瓦斯浓度主要参数的监控。
本设计首先通过matlab仿真得到控制规则表，储存在PLC数据区，，然后用建立指针的查询办法实现数据的查询，这样实现的模糊控制算法是可以离线使用的。
论文对所设计的西门子模糊控制进行了实验验证。
实验结果表明，论文所确定的测试方法正确，所设计仪器满足测试要求。
【关键词】矿用通风机模糊控制CO及瓦斯浓度1 模糊控制的概述在传统的控制领域里，控制系统动态模式的精确与否是影响控制优劣的最主要关键，系统动态的信息越详细，则越能达到精确控制的目的。
然而，对于复杂的系统，由于变量太多，往往难以正确的描述系统的动态，于是工程师便利用各种方法来简化系统动态，以达成控制的目的。
在上世纪70年代，美国加州大学博客利分校电器工程系控制专家L.A.Zadeh提出了模糊集合理论，为模糊控制技术的产生奠定了理论基础。
模糊控制系统是以模糊语言变量、模糊逻辑推理以及模糊集理论做为基础，结合基于规则的专家系统和控制理论的一种智能的控制系统，同时也是运用到计算机的控制技术构成的一种具备反馈通道的闭环结构的数字控制系统。
模糊控制器包括五个主要部分，即：定义变量、模糊化、模糊规则、模糊推理及解模糊。
（1）定义变量；也就是决定程序被观察的状况及考虑控制的动作，例如在一般控制问题上，输入变量有输出误差E与输出误差之变化率EC，而控制变量则为下一个状态之输入U。
其中E、EC、U统称为模糊变量。
（2）模糊化；将输入值以适当的比例转换到论域的数值，利用口语化变量来描述测量物理量的过程，以适合的语言值求该值相对之隶属度，此口语化变量我们称之为模糊子集合。
（3）模糊规则；包括数据库与规则库两部分，其中数据库是提供处理模糊数据之相关定义；而规则库则藉由一群语言控制规则描述控制目标和策略。
模糊PID控制算法
模糊PDI控制算法学院：班级：学号：姓名：完成日期：一、模糊PID控制算法综述模糊控制器是一种近年来发展起来的新型控制器，其优点是不要求掌握受控对象的精确数学模型，而根据人工控制规则组织控制决策表，然后由该表决定控制量的大小。
二、模糊PID 控制的原理CPU 根据系统偏差（偏差＝给定－反馈），和偏差变化率（偏差变化率＝当前周期偏差－上周期偏差）查询相应的模糊控制表，得到Kp ，Ki ，Kd 三个参数的整定值，然后进行PID 运算，真正的运用到实际中也就是一张模糊控制查询表，然后就是查表了，也很简单，关键是表的建立还有专家经验的问题等。
三、模糊控制规则模糊控制规则的形成是把有经验的操作者或专家的控制知识和经验制定成若干控制决策表，这些规则可以用自然语言来表达，但一般要进行形式化处理。
例如：①“If A ｎ Then B ｎ”；②“If A ｎ Then B ｎ Else C ｎ”；③“If A ｎ And B ｎ Then C ｎ”；其中A ｎ是论域U 上的一个模糊子集，B ｎ是论域V 上的一个模糊子集。
根据人工试验，可离线组织其控制决策表R ，R 是笛卡尔乘积U×V 上的一个模糊子集。
则某一时刻，以上控制规则的控制量分别为：①B ｎ＝A ｎ．R②B ｎ＝A ｎ．RC ｎ＝A ｎ．R③C ｎ＝（A ｎ×B ｎ）．R式中 ×——模糊直积运算．——模糊合成运算控制规则③是实际模糊控制器最常用的规则形式。
在这类规则中，A一般用来表示被控制量的测量值与期望值的偏差E＝x－x的隶属函数。
B一般表示０偏差变化率C＝d E／dt的隶属函数。
目前设计的模糊控制器基本上都是采用这种方式。
即在模糊控制过程中，同时要把系统与设定值的偏差和偏差的变化率作为模糊输入量。
这种方法不仅能保证系统的稳定性，而且还可减少超调量和振荡现象。
四、模糊PID控制算法PID调节对于线性定常系统的控制是非常有效的，但对于非线性、时变的复杂系统和模型不清楚的系统就不能很好地控制。
模糊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); //获得抽样时间。
模糊控制
2 按模糊控制的线性特性分类 对开环模糊控制系统S，设输入变量为u，输出变量
为v。对任意输入偏差Δ u和输出偏差Δ v，满足
v k u
u U,v V
定义线性度δ ，用于衡量模糊控制系统的线性化
程度：
vmax 2u m a xm
其中 vmax vmax vmin
，umax umax umin
1. 模糊控制器的结构 单变量二维模糊控制器是最常见的结构形式。
2 .定义输入输出模糊集 对误差E、误差变化EC及控制量u的模糊集及其论域
定义如下：
E、EC和u的模糊集均为：NB, NM , NS, Z, PS, PM, PB
E、EC的论域均为：{-3，-2，-1，0，1，2，3} u的论域为：{-4.5,-3,-1.5,0,1,3,4.5}
4.4 模糊自适应整定PID控制
4.4.1 模糊自适应整定PID控制原理
在工业生产过程中，许多被控对象随着负荷变化 或干扰因素影响，其对象特性参数或结构发生改变。 自适应控制运用现代控制理论在线辨识对象特征参数 ，实时改变其控制策略，使控制系统品质指标保持在 最佳范围内，但其控制效果的好坏取决于辨识模型的 精确度，这对于复杂系统是非常困难的。因此，在工 业生产过程中，大量采用的仍然是PID算法，大多数 都以对象特性为基础。
图4-6 多变量模糊控制器
4.2 模糊控制系统分类
1 按信号的时变特性分类 （1）恒值模糊控制系统
系统的指令信号为恒定值，通过模糊控制器消除外 界对系统的扰动作用，使系统的输出跟踪输入的恒定值。 也称为“自镇定模糊控制系统”，如温度模糊控制系统。 （2）随动模糊控制系统
系统的指令信号为时间函数，要求系统的输出高精度、 快速地跟踪系统输入。也称为“模糊控制跟踪系统”或 “模糊控制伺服系统”。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include<iostream.h>#include<iomanip.h>#include<fstream.h>#include<stdlib.h>struct Fzb{int yyz; //语言之int ly; //论域float lsd; //隶属值struct Fzb *next;};class Fuzzy{private:int g[49][3]; //定义了规则库，用于函数间调用float R[169][13]; //定义了关系矩阵，用于函数间调用float H[13][13]; //定义了查询表矩阵，用于函数间的调用public:struct Fzb * Creatfzb(); //建立赋值表函数void Printfzb(struct Fzb *head1); //输出赋值表void Inputgzk(); //导入规则库void jlgx(struct Fzb*E,struct Fzb*EC,struct Fzb*U); //建立关系矩阵void jlcxb(struct Fzb*E,struct Fzb*EC,struct Fzb*U); //建立查询表};struct Fzb *Fuzzy::Creatfzb(){float f[8][14]={{0,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6},{-3,1,0.5,0,0,0,0,0,0,0,0,0,0,0},{-2,0,0.5,1,0.5,0,0,0,0,0,0,0,0,0},{-1,0,0,0,0.5,1,0.5,0,0,0,0,0,0,0},{0,0,0,0,0,0,0.5,1,0.5,0,0,0,0,0},{1,0,0,0,0,0,0,0,0.5,1,0.5,0,0,0},{2,0,0,0,0,0,0,0,0,0,0.5,1,0.5,0},{3,0,0,0,0,0,0,0,0,0,0,0,0.5,1}}; //默认输入赋值表int i,k,j;fstream in,out;struct Fzb *head,*p1,*p2;int n=0;head=NULL;p1=new(Fzb);for(k=1;k<8;k++)for(j=1;j<14;j++){n++;p1->lsd=f[k][j];p1->yyz=(int)f[k][0];p1->ly=(int)f[0][j];if(1==n) head=p1;p2=p1;p1=new(Fzb);p2->next=p1;}p2->next=NULL;int m=0;return (head);}void Fuzzy::Inputgzk(){int G[49][3]={{-3,-3,-3},{-3,-2,-3},{-3,-1,-3},{-3,0,-3},{-3,1,-2},{-3,2,0},{-3,3,0},{-2,-3,-3},{-2,-2,-3},{-2,-1,-3},{-2,0,-3},{-2,1,-2},{-2,2,0},{-2,3,0},{-1,-3,-2},{-1,-2,-2},{-1,-1,-2},{-1,0,-2},{-1,1,0},{-1,2,1},{-1,3,1},{0,-3,-2},{0,-2,-2},{0,-1,-1},{0,0,0},{0,1,1},{0,2,2},{0,3,2},{1,-3,-1},{1,-2,-1},{1,-1,0},{1,0,2},{1,1,2},{1,2,2},{1,3,2},{2,-3,0},{2,-2,0},{2,-1,2},{2,0,3},{2,1,3},{2,2,3},{2,3,3},{3,-3,0},{3,-2,0},{3,-1,2},{3,0,3},{3,1,3},{3,2,3},{3,3,3}}; //默认输入规则库int i,j;int n=0;for(i=0;i<49;i++)for(j=0;j<3;j++){n++;g[i][j]=G[i][j];cout<<setw(5)<<g[i][j]; //显示规则库if(3==n) {cout<<endl;n=0;}}}void Fuzzy::Printfzb(struct Fzb *head1){struct Fzb *p;p=head1;int n,i,j;float a[8][14];while(NULL!=p){a[p->yyz+4][p->ly+7]=p->lsd;p=p->next;}p=head1;while (NULL!=p){a[0][p->ly+7]=p->ly;p=p->next;}p=head1;while (NULL!=p){a[p->yyz+4][0]=p->yyz;p=p->next;}a[0][0]=0;int k;for(i=0;i<8;i++) //用于输出标准形式的赋值表{n=0;for(j=0;j<14;j++){n++;if(0==j&&0!=i){switch((int)a[i][j]) {case -3:cout<<setw(5)<<"NB";break;case -2:cout<<setw(5)<<"NM";break;case -1:cout<<setw(5)<<"NS";break;case 0:cout<<setw(5)<<"Z";break;case 1:cout<<setw(5)<<"PS";break;case 2:cout<<setw(5)<<"PM";break;case 3:cout<<setw(5)<<"PB";}}elsecout<<setw(5)<<a[i][j];if(14==n) cout<<endl;}}}void Fuzzy::jlgx(struct Fzb*E,struct Fzb*EC,struct Fzb*U){int i,j,k,m,n,l,z;struct Fzb*p1,*p2,*p3;p1=E; p2=EC; p3=U;float a[13],b[13],c[13];float R1[169],R2[169][13]; //前者用于存储转置后的一维向量，后者用于暂时存储每条规则生成的关系矩阵for(i=0;i<49;i++){p1=E; p2=EC; p3=U;k=0;m=0;n=0;z=0;while(NULL!=p1){if(p1->yyz==g[i][0])a[k++]=p1->lsd;p1=p1->next;}while(NULL!=p2){if(p2->yyz==g[i][1])b[m++]=p2->lsd;p2=p2->next;}while(NULL!=p3){if(p3->yyz==g[i][2])c[n++]=p3->lsd;p3=p3->next;}for(j=0;j<13;j++)for(l=0;l<13;l++){if(a[j]>b[l])R1[z++]=b[l];elseR1[z++]=a[j];}for(j=0;j<169;j++)for(l=0;l<13;l++){if(R1[j]>c[l])R2[j][l]=c[l];elseR2[j][l]=R1[j];}if(0==i)for(j=0;j<169;j++) //以下于对所有规则对应的关系矩阵作加法 for(l=0;l<13;l++){R[j][l]=R2[j][l];}for(j=0;j<169;j++)for(l=0;l<13;l++){if(R2[j][l]>R[j][l])R[j][l]=R2[j][l];}}i=0;for(j=0;j<169;j++)for(l=0;l<13;l++){i++;cout<<setw(5)<<R[j][l]; //输出总的关系矩if(13==i){cout<<endl;i=0;}}return;}void Fuzzy::jlcxb(struct Fzb*E,struct Fzb*EC,struct Fzb*U){int e,ec,u;int i,j,k,n=0,l=0,x=0;float m=0;struct Fzb*p1,*p2,*p3;p1=E;p2=EC;p3=U;float a[13],b[13];float gg[169];float max=0,min;float t[13]; //用于存储每次生成的U的隶属函数，从而求得每组e,ec对应的u for(i=0;i<13;i++)for(j=0;j<13;j++){m=0;p1=E;p2=EC;p3=U;l=0;e=i-6;ec=j-6;while (NULL!=p1){if(e<0){if(e==p1->ly&&m<p1->lsd){n=p1->yyz;m=p1->lsd;}}else{if(e==p1->ly&&m<=p1->lsd){n=p1->yyz;m=p1->lsd;}}p1=p1->next;}p1=E;while (NULL!=p1){if(n==p1->yyz) a[l++]=p1->lsd; p1=p1->next;}m=0;while (NULL!=p2){if(ec<0){if(ec==p2->ly&&m<p2->lsd) {n=p2->yyz;m=p2->lsd;}}else{if(ec==p2->ly&&m<=p2->lsd) {n=p2->yyz;m=p2->lsd;}}p2=p2->next;}p2=EC;l=0;while (NULL!=p2){if(n==p2->yyz) b[l++]=p2->lsd; p2=p2->next;}/*cout<<e<<" "<<ec<<endl;for(x=0;x<13;x++){cout<<a[x]<<" ";}cout<<endl;for(x=0;x<13;x++){cout<<b[x]<<" ";}cout<<endl;*/n=0;for(x=0;x<13;x++)for(l=0;l<13;l++){if(a[x]<b[l]) gg[n++]=a[x];else gg[n++]=b[l];}for(x=0;x<13;x++) //进行推理合成规则计算{max=0;for(l=0;l<169;l++){if(gg[l]<R[l][x]) min=gg[l];else min=R[l][x];if(max<min) max=min;}t[x]=max;}p3=U;float sum=0;float s=0;float u=0;for(x=0;x<13;x++){if(0!=t[x]){s=x-6;sum+=t[x]*s;u+=t[x];}}H[i][j]=sum/u;}for(i=0;i<13;i++){for(j=0;j<13;j++){if(H[i][j]<0)cout<<setw(4)<<(int)(H[i][j]-0.5);elsecout<<setw(4)<<(int)(H[i][j]+0.5);}cout<<endl;}}void main(){struct Fzb *E,*EC,*U;E=EC=U=NULL;Fuzzy p;int jg;int n=1;E=p.Creatfzb(); //默认建立E的赋值表EC=p.Creatfzb(); //默认建立EC的赋值表U=p.Creatfzb(); //默认建立U的赋值表int t=1;while (1==1) {cout<<endl<<"想做什么："<<endl<<"1、输出E的赋值表"<<endl<<"2、输出EC的赋值表"<<endl<<"3、输出U的赋值表"<<endl<<"4、显示规则库"<<endl<<"5、求解关系函数"<<endl<<"6、输出查询表"<<endl<<"6、退出"<<endl;cout<<"----> ";cin>>jg;switch(jg) {case 1:cout<<"*************************************************************"<<endl; cout<<"E的赋值表如下："<<endl;p.Printfzb(E);break;case 2:cout<<"*************************************************************"<<endl; cout<<"EC的赋值表如下："<<endl;p.Printfzb(EC);break;case 3:cout<<"*************************************************************"<<endl; cout<<"U的赋值表如下："<<endl;p.Printfzb(U);break;case 4:p.Inputgzk();n=0;break;case 5:if(n){cout<<"*************************************************************"<<endl; cout<<" 未调入规则库，请先运行步骤4"<<'\a'<<endl;cout<<"*************************************************************"<<endl; }else{p.jlgx(E,EC,U);t=0;}break;case 6:if(t){cout<<"*************************************************************"<<endl; cout<<" 未创建关系矩阵，请先运行步骤5"<<'\a'<<endl;cout<<"*************************************************************"<<endl; }else{cout<<"*************************************************************"<<endl; cout<<"查询表如下："<<endl;p.jlcxb(E,EC,U);}break;default:return;}}}。