PID控制算法的C语言实现
经典控制PID控制器-C语言代码实现
经典控制PID控制器-C语言代码的实现// 1.定义PID变量结构体struct _pid{float SetValue; //定义设定值float ActualValue; //定义实际值float err; //定义偏差值float err_last; //定义上一个偏差值float Kp,Ki,Kd; //定义比例、积分、微分系数float ActuatorCtrlValue; //控制执行器变量float integral; //定义积分值float Umax; //定义实际值的上限float Umin; //定义实际值得下限float errDisIntegralVar; //定义接触积分环节的偏差限值float ControlOutValue;//定义控制输出}pid;//2. PID算法实现float PID_realize(float SetVar,float ActualVar,float UHigLim,float ULowLim,float ErrDisIntegralLim){int index;pid.SetValue=SetVar;pid.ActualValue=ActualVar;pid.Umax=UHigLim;pid.Umin=ULowLim;pid.err=pid.ActualValue-pid.SetValue;pid.errDisIntegralVar=ErrDisIntegralLim;//积分饱和处理if (pid.ActualValue>pid.Umax){if (abs(pid.err)>pid.errDisIntegralVar){index=1;if (pid.err>0){pid.integral+=1.3*pid.err;}}else{index=1;if (pid.err>0){ pid.integral+=1.2*pid.err;}}}else if(pid.ActualValue<pid.Umin){if (abs(pid.err)>pid.errDisIntegralVar){index=1;if (pid.err<0){pid.integral+=1.3*pid.err;}}else{index=1;if (pid.err<0){pid.integral+=1.2*pid.err;}}}else{if (abs(pid.err)>pid.errDisIntegralVar){index=1;pid.integral+=1.1*pid.err;}else{index=1;pid.integral+=pid.err;}}pid.ControlOutValue=pid.Kp*pid.err+index*pid.Ki*pid.integral+pid.Kd*(pid.err-pi d.err_last);pid.err_last=pid.err;return pid.ControlOutValue;}。
PID控制算法的C语言实现(完整版)
PID控制算法的C语言实现(完整版) 在现代工业生产中，为了实现对生产过程的精确控制，我们需要采用一种能够根据实际需求自动调整参数的控制算法。
PID(Proportional-Integral-Derivative)控制算法就是这样一种广泛应用于工业控制系统的算法。
本文将详细介绍PID控制算法的C语言实现，包括算法的基本原理、实现方法以及注意事项。
我们来了解一下PID控制算法的基本原理。
PID控制器由三个部分组成：比例(P)、积分(I)和微分(D)。
这三个部分分别对误差信号进行处理，然后将处理后的信号相加得到控制输出。
具体来说，比例部分根据误差信号的大小产生相应的控制作用；积分部分对误差信号进行累积，以消除系统的静差；微分部分对误差信号的变化趋势进行预测，以便及时调整控制策略。
通过这三个部分的综合作用，PID控制器能够实现对生产过程的精确控制。
接下来，我们来看一下如何用C语言实现PID控制算法。
我们需要定义一些变量来存储所需的参数和状态信息。
例如，我们需要定义比例系数Kp、积分系数Ki、微分系数Kd以及误差信号e等。
我们还需要定义一些变量来存储上一次的误差信号和积分项等。
这些变量的定义如下：```cdouble Kp, Ki, Kd; // 比例、积分、微分系数double e; // 当前误差信号double de; // 当前误差信号的导数double last_e; // 上一次的误差信号double integral; // 积分项有了这些变量之后，我们就可以开始实现PID控制器的计算过程了。
PID控制器的计算过程主要包括以下几个步骤：1. 计算误差信号：当前误差信号等于期望值与实际值之差。
2. 计算比例项：比例项等于当前误差信号乘以比例系数Kp;3. 计算积分项：积分项等于当前误差信号乘以积分系数Ki加上累积误差信号乘以积分系数Ki;4. 计算微分项：微分项等于当前误差信号的导数乘以微分系数Kd;5. 计算控制输出：控制输出等于比例项、积分项和微分项之和。
PID算法C语言实现
这是一个PID算法的C语言实现程序: "double sensor (void),void actuator(double rDelta,double LastrDelta )各函数的功能及语句的作用, 以及主函数里的变量j和数值a[]的设置的作用,以及for循环语句的作用, "望大家再分享的同时,给份详细注释,在线等待,大家帮助大家,^_^.#include <string.h>#include <stdio.h>typedef struct PID { /*K1=实际放大倍数,T1=实际积分时间,T2=实际微分时间,T=采样周期*/double SetPoint; /*定义PID结构体*/double K1;double T1;double T2;double T;double Err1; /*前一时刻误差,E(K-1)*/} PID;double PIDCalc( PID *pp, double NextPoint,double Ud1,double Ui1 ) /*PID计算*/{double Ti,Td,Kp,Ki,Kd,Ud,Up,Ui,Err;Ti = pp-> T1 + pp-> T2; /*积分时间*/Td = (pp-> T1 * pp-> T2) / (pp-> T1 + pp-> T2); /*微分时间*/Kp = pp-> K1 * ((pp-> T1 + pp-> T2) / pp-> T1); /*比例系数*/Ki =pp-> T / Ti * Kp; /*积分系数*/Kd = Td / pp-> T * Kp; /*微分系数*/ Err = pp-> SetPoint-NextPoint; /*当前误差*/Ud = pp->T2/ ((Kd * pp-> T) + pp-> T2) * Ud1+ Kd * (pp-> T2 + pp-> T) / (Kd *pp-> T + pp-> T2) * Err - Kd * pp-> T2 / (Kd * pp-> T + pp-> T2) *pp-> Err1; /*微分作用*/Ui = Ui1 + pp-> K1 * (pp-> T / pp->T1) * Ud; /*积分作用*/Up = pp-> K1 * Ud; /*比例作用*/Ud1=Ud;/*UD1=ud(k-1),ui1=ui(k-1)*/Ui1=Ui;return (Ud + Up + Ui);/*y(k)*/}void PIDInit (PID *pp){memset ( pp,0,sizeof(PID));}/*double sensor (void){return 1.0;}*//*输入口*/void actuator(double rDelta,double LastrDelta ) /*输出口*/{double n;n=rDelta-LastrDelta;/*y(k)-y(k-1)*/LastrDelta=rDelta;printf ( "%f\n ",n);}void main(void){int j,a[]={15,14,12.5,10.5,5.5,6.7,9.5,11.3,9.6,10.2,10.035,9.2356,10.2356,9.3654,10.01101 };PID sPID;double rOut;double LastrOut=0;/*y(k-1)*/double rIn;double Ud1 = 1;double Ui1 = 1;PIDInit ( &sPID );/*PID初始化*/sPID.K1 = 1;sPID.T1 = 1;sPID.T2 = 1;sPID.T = 1;sPID.SetPoint = 10.0;/*设定值*/sPID.Err1 = 1;for (j=0;j <15;j++){rIn = a[j]; /*sensor ();*/ /*输入*/rOut= PIDCalc ( &sPID,rIn,Ud1,Ui1 );actuator ( rOut, LastrOut );}}这应该是个仿真程序.sensor原来是个输入函数,后来注释掉了,用数组代替了.actuator输出函数,这里现示跟踪情况.j,是15个点的循环变量.a[j],是个模拟的输入.语句:return 1.0; 变量:rDelta LastrDelta语句:n=rDelta-LastrDelta; LastrDelta=rDelta; printf ( "%f\n ",n);又分别如何解释呢,新手上路,多指教.^_^。
PID的C语言实现
位置式PID的C语言实现第一步：定义PID变量结构体，代码如下：struct _pid{float SetSpeed; //定义设定值float ActualSpeed; //定义实际值float err; //定义偏差值float err_last; //定义上一个偏差值float Kp,Ki,Kd; //定义比例、积分、微分系数float voltage; //定义电压值（控制执行器的变量）float integral; //定义积分值}pid;控制算法中所需要用到的参数在一个结构体中统一定义，方便后面的使用。
第二部：初始化变量，代码如下：void PID_init(){printf("PID_init begin \n");pid.SetSpeed=0.0;pid.ActualSpeed=0.0;pid.err=0.0;pid.err_last=0.0;pid.voltage=0.0;pid.integral=0.0;pid.Kp=0.2;pid.Ki=0.015;pid.Kd=0.2;printf("PID_init end \n");}统一初始化变量，尤其是Kp,Ki,Kd三个参数，调试过程当中，对于要求的控制效果，可以通过调节这三个量直接进行调节。
第三步：编写控制算法，代码如下：float PID_realize(float speed){pid.SetSpeed=speed;pid.err=pid.SetSpeed-pid.ActualSpeed;pid.integral+=pid.err;pid.voltage=pid.Kp*pid.err+pid.Ki*pid.integral+pid.Kd*(pid.err-pid.err_last);pid.err_last=pid.err;pid.ActualSpeed=pid.voltage*1.0;return pid.ActualSpeed;}注意：这里用了最基本的算法实现形式，没有考虑死区问题，没有设定上下限，只是对公式的一种直接的实现，后面的介绍当中还会逐渐的对此改进。
c语言pid算法
c语言pid算法PID（Proportional-Integral-Derivative）控制器是一种非常常见且有效的控制系统算法，主要用于调节一个过程或者系统的输出，使其尽可能接近期望的设定值。
PID控制器的名字来源于它的三个主要组成部分：比例（Proportional）、积分（Integral）和微分（Derivative）。
在C语言中，一个简单的PID控制器可以如下实现：c复制代码#include<stdio.h>typedef struct {double kp; // 比例系数double ki; // 积分系数double kd; // 微分系数double last_error; // 上一次的误差double integral; // 误差的积分} PIDController;double calculatePID(PIDController* pid, double setpoint, double actual_value, double dt) {double error = setpoint - actual_value;// Proportional termdouble pout = pid->kp * error;// Integral termpid->integral += error * dt;double iout = pid->ki * pid->integral;// Derivative termdouble derivative = (error - pid->last_error) / dt;double dout = pid->kd * derivative;// Save error for next timepid->last_error = error;// Return total outputreturn pout + iout + dout;}int main() {PIDController pid;pid.kp = 1.0;pid.ki = 0.1;pid.kd = 0.01;st_error = 0;pid.integral = 0;double setpoint = 100.0; // 目标值double actual_value = 0.0; // 实际值double dt = 0.1; // 时间间隔for (int i = 0; i < 100; i++) {double output = calculatePID(&pid, setpoint, actual_value, dt);actual_value += output * dt; // 更新实际值printf("Setpoint: %f, Actual Value: %f, Output: %f\n", setpoint, actual_value, output);}return0;}在这个示例中，我们定义了一个PIDController结构体，它包含了PID控制器的所有参数。
PID控制算法的C语言实现
PID控制算法的C语言实现PID控制算法由比例(P)、积分(I)和微分(D)三个部分组成。
比例部分根据给定输入与实际输出的差值来调整控制器输出；积分部分根据多次采样输入与输出的偏差的总和来调整控制器输出；微分部分根据采样输入与输出的变化率来调整控制器输出。
以下是PID控制算法的C语言实现的完整版。
```c#include <stdio.h>#include <stdlib.h>typedef structdouble Kp; // 比例系数double Ki; // 积分系数double Kd; // 微分系数double setpoint; // 设定值double error_sum; // 误差和double prev_error; // 上一次误差} PIDController;void PIDController_init(PIDController* pid, double Kp, double Ki, double Kd, double setpoint)pid->Kp = Kp;pid->Ki = Ki;pid->Kd = Kd;pid->setpoint = setpoint;pid->error_sum = 0;pid->prev_error = 0;double PIDController_update(PIDController* pid, double input, double dt)double error = pid->setpoint - input; // 计算误差pid->error_sum += error * dt; // 更新误差积分double d_error = (error - pid->prev_error) / dt; // 计算误差变化率double output = pid->Kp * error + pid->Ki * pid->error_sum + pid->Kd * d_error; // 计算控制器输出pid->prev_error = error; // 更新上一次误差return output;int maidouble input = 0; // 输入值，即实际输出double dt = 0.01; // 采样时间间隔PIDController pid;PIDController_init(&pid, 1, 0.5, 0.25, 0); // 初始化PID控制器input += PIDController_update(&pid, input, dt); // 更新输入值}return 0;```以上是PID控制算法的完整C语言实现。
最全PID控制算法的C语言实现
最全PID控制算法的C语言实现PID控制算法是一种在控制系统中常用的反馈控制算法，用于根据实际测量值来调节输出来实现对系统状态的控制。
PID算法包含三个控制参数：比例常数（Kp）、积分常数（Ki）和微分常数（Kd）。
这三个参数分别调节了比例控制、积分控制和微分控制的比例，用于实现不同的控制效果。
下面是一个最全的PID控制算法的C语言实现示例：```c#include <stdio.h>//定义PID控制算法的参数float Kp = 1.0; // 比例常数float Ki = 0.5; // 积分常数float Kd = 0.2; // 微分常数//定义全局变量用于记录控制过程中的误差与累积误差float error = 0.0;float lastError = 0.0;float integral = 0.0;//定义PID控制函数float pidControl(float target, float current, float dt)//计算误差error = target - current;//计算累积误差integral += error * dt;//计算微分误差float derivative = (error - lastError) / dt;//计算PID输出float output = Kp * error + Ki * integral + Kd * derivative; //更新上一次误差lastError = error;return output;int mai//模拟控制过程float target = 100.0; // 目标值float current = 0.0; // 当前值float dt = 0.1; // 控制周期for(int i = 0; i < 100; i++)//调用PID控制函数float output = pidControl(target, current, dt);//更新当前值，模拟实际过程中的测量误差current += output * dt + 0.2;printf("Target: %.2f, Current: %.2f, Output: %.2f\n", target, current, output);}return 0;```上述代码通过定义全局变量来记录控制过程中的误差与累积误差，并在PID控制函数中进行计算和更新。
PID算法的C语言实现
PID算法的C语⾔实现1.根据我控制算法类⽂章中关于PID的理论的⼀些描述，同时也根据⽹络上⼀些其他的PID⽂章，以及⾃⼰最近⼀个项⽬的实践后，总结了⼏套基于C语⾔的PID算法，由于⽹络中很少有⼈进⾏分享完整的PID算法实现，我这⾥分享下。
（1）头⽂件，定义pid的结构体，类的概念，包含pid的属性和⽅法#ifndef __PID_H_#define __PID_H_#include <stdint.h>typedef struct _pid{int16_t set_value; // 给定值，rin(k)int16_t actual_value; // 实际值，反馈值，rout(k)int16_t err; // 偏差值，rin(k) - rout(k)int16_t err_last; // 上⼀次偏差值，rin(k - 1) - rout(k - 1)int16_t err_last_last; // 上⼀次上⼀次的偏差值，rin(k - 2) - rout(k - 2)float kp; // ⽐例系数float ki; // 积分系数float kd; // 微分系数float uk; // pid公式运算结果值float incremental_value; // 增量值float integral_value; // 积分值float umax; // uk的上限值，抗积分饱和⽤float umin; // uk的下限值，抗积分饱和⽤int16_t err_up_value; // 偏差上限值，积分分离⽤int16_t ki_k; // 积分的再次乘机系数，积分分离⽤float out_value; //float(*position_type)(struct _pid *ppid); // 位置型PID算法，⽆积分分离、⽆抗积分饱和float(*incremental_type)(struct _pid *ppid); // 增量型PID算法float(*integral_separation_type)(struct _pid *ppid); // 积分分离PID算法float(*int_sep_anti_sat_type)(struct _pid *ppid); // 积分分离 + 抗积分饱和PID算法}_pid_t;_pid_t *pid_create(void);extern _pid_t *pg_pid;#endif（2）.c⽂件，包含头⽂件中4个PID算法的实现，包含位置型PID算法、增量型PID算法、积分分离PID算法、积分分离+抗饱和PID算法#include <stdlib.h>#include <string.h>#include "pid.h"#include "FreeRTOS.h"#include "task.h"#include "queue.h"#include "portmacro.h"#include "semphr.h"#include "Debug.h"/*************************************** Funciton Name : pid_position_type* Function ：位置型PID算法，⽆积分分离、⽆抗积分饱和** @author ：why* @note : 积分分离：能解决初期系统偏差值⼤，累加到积分项中，引起系统超调、振荡问题。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
PID控制算法的C语言实现一PID算法原理最近两天在考虑一般控制算法的C语言实现问题，发现网络上尚没有一套完整的比较体系的讲解。
于是总结了几天，整理一套思路分享给大家。
在工业应用中PID及其衍生算法是应用最广泛的算法之一，是当之无愧的万能算法，如果能够熟练掌握PID算法的设计与实现过程，对于一般的研发人员来讲，应该是足够应对一般研发问题了，而难能可贵的是，在我所接触的控制算法当中，PID控制算法又是最简单，最能体现反馈思想的控制算法，可谓经典中的经典。
经典的未必是复杂的，经典的东西常常是简单的，而且是最简单的，想想牛顿的力学三大定律吧，想想爱因斯坦的质能方程吧，何等的简单！简单的不是原始的，简单的也不是落后的，简单到了美的程度。
先看看PID算法的一般形式：PID的流程简单到了不能再简单的程度，通过误差信号控制被控量，而控制器本身就是比例、积分、微分三个环节的加和。
这里我们规定（在t时刻）：1.输入量为rin(t);2.输出量为rout(t);3.偏差量为err(t)=rin(t)-rout(t);pid的控制规律为理解一下这个公式，主要从下面几个问题着手，为了便于理解，把控制环境具体一下：1.规定这个流程是用来为直流电机调速的;2.输入量rin(t)为电机转速预定值;3.输出量rout(t)为电机转速实际值;4.执行器为直流电机;5.传感器为光电码盘，假设码盘为10线;6.直流电机采用PWM调速转速用单位转/min表示;不难看出以下结论：1.输入量rin（t）为电机转速预定值（转/min）;2. 输出量rout(t)为电机转速实际值（转/min）;3.偏差量为预定值和实际值之差（转/min）;那么以下几个问题需要弄清楚：1.通过PID环节之后的U(t)是什么值呢2.控制执行器（直流电机）转动转速应该为电压值（也就是PWM占空比）。
3.那么U(t)与PWM之间存在怎样的联系呢（见附录1）这篇文章上给出了一种方法，即，每个电压对应一个转速，电压和转速之间呈现线性关系。
但是我考虑这种方法的前提是把直流电机的特性理解为线性了，而实际情况下，直流电机的特性绝对不是线性的，或者说在局部上是趋于线性的，这就是为什么说PID调速有个范围的问题。
具体看一下（见附录2）这篇文章就可以了解了。
所以在正式进行调速设计之前，需要现有开环系统，测试电机和转速之间的特性曲线（或者查阅电机的资料说明），然后再进行闭环参数整定。
这篇先写到这，下一篇说明连续系统的离散化问题。
并根据离散化后的特点讲述位置型PID和增量型PID的用法和C语言实现过程。
PID控制算法的C语言实现二PID算法的离散化上一节中，我论述了PID算法的基本形式，并对其控制过程的实现有了一个简要的说明，通过上一节的总结，基本已经可以明白PID控制的过程。
这一节中先继续上一节内容补充说明一下。
1.说明一下反馈控制的原理，通过上一节的框图不难看出，PID控制其实是对偏差的控制过程;2.如果偏差为0,则比例环节不起作用，只有存在偏差时，比例环节才起作用。
3.积分环节主要是用来消除静差，所谓静差，就是系统稳定后输出值和设定值之间的差值，积分环节实际上就是偏差累计的过程，把累计的误差加到原有系统上以抵消系统造成的静差。
4.而微分信号则反应了偏差信号的变化规律，或者说是变化趋势，根据偏差信号的变化趋势来进行超前调节，从而增加了系统的快速性。
好了，关于PID的基本说明就补充到这里，下面将对PID连续系统离散化，从而方便在处理器上实现。
下面把连续状态的公式再贴一下：假设采样间隔为T，则在第K T时刻：偏差err(K)=rin(K)-rout(K);积分环节用加和的形式表示，即err(K)+err(K+1)+……;微分环节用斜率的形式表示，即[err(K)-err(K-1)]/T;从而形成如下PID离散表示形式：则u(K)可表示成为：至于说Kp、Ki、Kd三个参数的具体表达式，我想可以轻松的推出了，这里节省时间，不再详细表示了。
其实到这里为止，PID的基本离散表示形式已经出来了。
目前的这种表述形式属于位置型PID，另外一种表述方式为增量式PID，由U上述表达式可以轻易得到：那么：这就是离散化PID的增量式表示方式，由公式可以看出，增量式的表达结果和最近三次的偏差有关，这样就大大提高了系统的稳定性。
需要注意的是最终的输出结果应该为u(K)+增量调节值;PID的离散化过程基本思路就是这样，下面是将离散化的公式转换成为C语言，从而实现微控制器的控制作用。
PID控制算法的C语言实现三位置型PID的C语言实现上一节中已经抽象出了位置性PID和增量型PID的数学表达式，这一节，重点讲解C语言代码的实现过程，算法的C语言实现过程具有一般性，通过PID算法的C语言实现，可以以此类推，设计其它算法的C语言实现。
第一步：定义PID变量结构体，代码如下：struct _pid{float SetSpeed; 例系数Kp的作用是加快系统的响应速度，提高系统的调节精度。
Kp越大，系统的响应速度越快，系统的调节精度越高，但是容易产生超调，甚至会使系统不稳定。
Kp取值过小，则会降低调节精度，使响应速度缓慢，从而延长调节时间，是系统静态、动态特性变差；2.积分作用系数Ki的作用是消除系统的稳态误差。
Ki越大，系统的静态误差消除的越快，但是Ki过大，在响应过程的初期会产生积分饱和的现象，从而引起响应过程的较大超调。
若Ki过小，将使系统静态误差难以消除，影响系统的调节精度；3.微分系数Kd的作用是改善系统的动态特性，其作用主要是在响应过程中抑制偏差向任何方向的变化，对偏差变化进行提前预报。
但是kd过大，会使响应过程提前制动，从而延长调节时间，而且会降低系统的抗干扰性。
反应系统性能的两个参数是系统误差e和误差变化律ec，这点还是好理解的：首先我们规定一个误差的极限值，假设为Mmax；规定一个误差的比较大的值，假设为Mmid；规定一个误差的较小值，假设为Mmin；当abs（e）>Mmax时，说明误差的绝对值已经很大了，不论误差变化趋势如何，都应该考虑控制器的输入应按最大（或最小）输出，以达到迅速调整误差的效果，使误差绝对值以最大的速度减小。
此时，相当于实施开环控制。
当e*ec>0时，说明误差在朝向误差绝对值增大的方向变化，此时，如果abs(e)>Mmid，说明误差也较大，可考虑由控制器实施较强的控制作用，以达到扭转误差绝对值向减小的方向变化，并迅速减小误差的绝对值。
此时如果abs(e)<Mmid，说明尽管误差是向绝对值增大的方向变化，但是误差绝对值本身并不是很大，可以考虑控制器实施一般的控制作用，只需要扭转误差的变化趋势，使其向误差绝对值减小的方向变化即可。
当e*err<0且e*err(k-1)>0或者e=0时，说明误差的绝对值向减小的方向变化，或者已经达到平衡状态，此时保持控制器输出不变即可。
当e*err<0且e*err(k-1)<0时，说明误差处于极限状态。
如果此时误差的绝对值较大，大于Mmin，可以考虑实施较强控制作用。
如果此时误差绝对值较小，可以考虑实施较弱控制作用。
当abs(e)<Mmin时，说明误差绝对值很小，此时加入积分，减小静态误差。
上面的逻辑判断过程，实际上就是对于控制系统的一个专家判断过程。
（未完待续）PID控制算法的C语言实现十模糊算法简介在PID控制算法的C语言实现九中，文章已经对模糊PID的实质做了一个简要说明。
本来打算等到完成毕业设计，工作稳定了再着力完成剩下的部分。
鉴于网友的要求和信任，抽出时间来，对模糊PID做一个较为详细的论述，这里我不打算做出仿真程序了，但就基本概念和思路进行一下说明，相信有C语言基础的朋友可以通过这些介绍性的文字自行实现。
这篇文章主要说明一下模糊算法的含义和原理。
实际上模糊算法属于智能算法，智能算法也可以叫非模型算法，也就是说，当我们对于系统的模型认识不是很深刻，或者说客观的原因导致我们无法对系统的控制模型进行深入研究的时候，智能算法常常能够起到不小的作用。
这点是方便理解的，如果一个系统的模型可以轻易的获得，那么就可以根据系统的模型进行模型分析，设计出适合系统模型的控制器。
但是现实世界中，可以说所有的系统都是非线性的，是不可预测的。
但这并不是说我们就无从建立控制器，因为，大部分的系统在一定的条件和范围内是可以抽象成为线性系统的。
问题的关键是，当我们系统设计的范围超出了线性的范围，我们又该如何处理。
显然，智能算法是一条很不错的途径。
智能算法包含了专家系统、模糊算法、遗传算法、神经网络算法等。
其实这其中的任何一种算法都可以跟PID去做结合，而选择的关键在于，处理的实时性能不能得到满足。
当我们处理器的速度足够快速时，我们可以选择更为复杂的、精度更加高的算法。
但是，控制器的处理速度限制了我们算法的选择。
当然，成本是限制处理器速度最根本的原因。
这个道理很简单，51单片机和DSP的成本肯定大不相同。
专家PID和模糊PID是常用的两种PID选择方式。
其实，模糊PID适应一般的控制系统是没有问题。
文章接下来将说明模糊算法的一些基本常识。
模糊算法其实并不模糊。
模糊算法其实也是逐次求精的过程。
这里举个例子说明。
我们设计一个倒立摆系统，假如摆针偏差＜5°，我们说它的偏差比较“小”；摆针偏差在5°和10°之间，我们说它的偏差处于“中”的状态；当摆针偏差＞10°的时候，我们说它的偏差有点儿“大”了。
对于“小”、“中”、“大”这样的词汇来讲，他们是精确的表述，可问题是如果摆针偏差是3°呢，那么这是一种什么样的状态呢。
我们可以用“很小”来表述它。
如果是7°呢，可以说它是“中”偏“小”。
那么如果到了80°呢，它的偏差可以说“非常大”。
而我们调节的过程实际上就是让系统的偏差由非常“大”逐渐向非常“小”过度的过程。
当然，我们系统这个调节过程是快速稳定的。
通过上面的说明，可以认识到，其实对于每一种状态都可以划分到大、中、小三个状态当中去，只不过他们隶属的程度不太一样，比如6°隶属于小的程度可能是，隶属于中的程度是，隶属于大的程度是0。
这里实际上是有一个问题的，就是这个隶属的程度怎么确定这就要求我们去设计一个隶属函数。
详细内容可以查阅相关的资料，这里没有办法那么详细的说明了。
（见附录3）这里面有些说明。
那么，知道了隶属度的问题，就可以根据目前隶属的程度来控制电机以多大的速度和方向转动了，当然，最终的控制量肯定要落实在控制电压上。
这点可以很容易的想想，我们控制的目的就是让倒立摆从隶属“大”的程度为1的状态，调节到隶属“小”的程度为1的状态。