C语言实现PID算1
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语言实现一 PID算法原理之迟辟智美创作最近两天在考虑一般控制算法的C语言实现问题,发现网络上尚没有一套完整的比力体系的讲解.于是总结了几天,整理一套思路分享给年夜家.在工业应用中PID及其衍生算法是应用最广泛的算法之一,是当之无愧的万能算法,如果能够熟练掌握PID算法的设计与实现过程,对一般的研发人员来讲,应该是足够应对一般研发问题了,而难能可贵的是,在我所接触的控制算法傍边,PID控制算法又是最简单,最能体现反馈思想的控制算法,可谓经典中的经典.经典的未必是复杂的,经典的工具经常是简单的,而且是最简单的,想想牛顿的力学三年夜定律吧,想想爱因斯坦的质能方程吧,何等的简单!简单的不是原始的,简单的也不是落后的,简单到了美的水平.先看看PID算法的一般形式:PID的流程简单到了不能再简单的水平,通过误差信号控制被控量,而控制器自己就是比例、积分、微分三个环节的加和.这里我们规定(在t时刻):1.输入量为rin(t);2.输出量为rout(t);3.偏差量为err(t)=rin(t)rout(t);pid的控制规律为理解一下这个公式,主要从下面几个问题着手,为了便于理解,把控制环境具体一下:1.规定这个流程是用来为直流机电调速的;2.输入量rin(t)为机电转速预定值;3.输出量rout(t)为机电转速实际值;4.执行器为直流机电;5.传感器为光电码盘,假设码盘为10线;6.直流机电采纳PWM调速转速用单元转/min 暗示;不难看出以下结论:1.输入量rin(t)为机电转速预定值(转/min);2. 输出量rout(t)为机电转速实际值(转/min);3.偏差量为预定值和实际值之差(转/min);那么以下几个问题需要弄清楚:1.通过PID环节之后的U(t)是什么值呢?2.控制执行器(直流机电)转动转速应该为电压值(也就是PWM占空比).3.那么U(t)与PWM之间存在怎样的联系呢?/user1/3407/archives//33541.html(见附录1)这篇文章上给出了一种方法,即,每个电压对应一个转速,电压和转速之间呈现线性关系.可是我考虑这种方法的前提是把直流机电的特性理解为线性了,而实际情况下,直流机电的特性绝对不是线性的,或者说在局部上是趋于线性的,这就是为什么说PID调速有个范围的问题.具体看一下/component/article90249.htm (见附录2)这篇文章就可以了解了.所以在正式进行调速设计之前,需要现有开环系统,测试机电和转速之间的特性曲线(或者查阅机电的资料说明),然后再进行闭环参数整定.这篇先写到这,下一篇说明连续系统的离散化问题.并根据离散化后的特点讲述位置型PID和增量型PID的用法和C语言实现过程.PID控制算法的C语言实现二 PID算法的离散化上一节中,我论述了PID算法的基本形式,并对其控制过程的实现有了一个简要的说明,通过上一节的总结,基本已经可以明白PID控制的过程.这一节中先继续上一节内容弥补说明一下.1.说明一下反馈控制的原理,通过上一节的框图不难看出,PID控制其实是对偏差的控制过程;2.如果偏差为0,则比例环节不起作用,只有存在偏差时,比例环节才起作用.3.积分环节主要是用来消除静差,所谓静差,就是系统稳定后输出值和设定值之间的差值,积分环节实际上就是偏差累计的过程,把累计的误差加到原有系统上以抵消系统造成的静差.4.而微分信号则反应了偏差信号的变动规律,或者说是变动趋势,根据偏差信号的变动趋势来进行超前调节,从而增加了系统的快速性.好了,关于PID的基本说明就弥补到这里,下面将对PID 连续系统离散化,从而方便在处置器上实现.下面把连续状态的公式再贴一下:假设采样间隔为T,则在第KT时刻:偏差err(K)=rin(K)rout(K);积分环节用加和的形式暗示,即err(K)+err(K+1)+……;微分环节用斜率的形式暗示,即[err(K)err(K1)]/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; //界说设定值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.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.SetSpeedpid.ActualSpeed;pid.integral+=pid.err;pid.voltage=pid.Kp*pid.err+pid.Ki*pid.integral+pid.Kd*(pid. errpid.err_last); pid.err_last=pid.err;pid.ActualSpeed=pid.voltage*1.0;}注意:这里用了最基本的算法实现形式,没有考虑死区问题,没有设定上下限,只是对公式的一种直接的实现,后面的介绍傍边还会逐渐的对此改进.到此为止,PID的基本实现部份就初步完成了.下面是测试代码:int main(){printf("System begin \n");PID_init();int count=0;while(count<1000){float speed=PID_realize(200.0);printf("%f\n",speed);count++;}return 0;}下面是经过1000次的调节后输出的1000个数据(具体的参数整定过程就不说明了,网上这种说明非常多):PID控制算法的C语言实现四增量型PID的C语言实现上一节中介绍了最简单的位置型PID的实现手段,这一节主要讲解增量式PID的实现方法,位置型和增量型PID的数学公式请拜会我的系列文《PID控制算法的C语言实现二》中的讲解.实现过程仍然是分为界说变量、初始化变量、实现控制算法函数、算法测试四个部份,详细分类请介入《PID控制算法的C 语言实现三》中的讲解,这里直接给出代码了.#include<stdio.h>#include<stdlib.h>struct _pid{float SetSpeed; //界说设定值float ActualSpeed; //界说实际值float err; //界说偏差值float err_next; //界说上一个偏差值float err_last; //界说最上前的偏差值float Kp,Ki,Kd; //界说比例、积分、微分系数}pid;void PID_init(){pid.SetSpeed=0.0;pid.ActualSpeed=0.0;pid.err=0.0;pid.err_last=0.0;pid.err_next=0.0;pid.Kp=0.2;pid.Ki=0.015;pid.Kd=0.2;}float PID_realize(float speed){pid.SetSpeed=speed;pid.err=pid.SetSpeedpid.ActualSpeed;floatincrementSpeed=pid.Kp*(pid.errpid.err_next)+pid.Ki*pid.err+pid.Kd*(pid.err2*pid.err_next+pid.err_last);pid.ActualSpeed+=incrementSpeed;pid.err_last=pid.err_next;pid.err_next=pid.err;return pid.ActualSpeed;}int main(){PID_init();int count=0;while(count<1000){float speed=PID_realize(200.0);printf("%f\n",speed);count++;}return 0;}运行后的1000个数据为:PID控制算法的C语言实现五积分分离的PID控制算法C语言实现通过三、四两篇文章,基本上已经弄清楚了PID控制算法的最惯例的表达方法.在普通PID控制中,引入积分环节的目的,主要是为了消除静差,提高控制精度.可是在启动、结束或年夜幅度增减设按时,短时间内系统输出有很年夜的偏差,会造成PID运算的积分积累,招致控制量超越执行机构可能允许的最年夜举措范围对应极限控制量,从而引起较年夜的超调,甚至是震荡,这是绝对不允许的.为了克服这一问题,引入了积分分离的概念,其基本思路是当被控量与设定值偏差较年夜时,取消积分作用; 当被控量接近给定值时,引入积分控制,以消除静差,提高精度.其具体实现代码如下:pid.Kp=0.2;pid.Ki=0.04;pid.Kd=0.2; //初始化过程if(abs(pid.err)>200){index=0;}else{index=1;pid.integral+=pid.err;}pid.voltage=pid.Kp*pid.err+index*pid.Ki*pid.integral+pid.Kd*(p id.errpid.err_last); //算法具体实现过程其它部份的代码拜会《PID控制算法的C语言实现三》中的讲解,不再赘述.同样收集1000个量,会发现,系统到199所有的时间是原来时间的1/2,系统的快速性获得了提高.PID控制算法的C语言实现六抗积分饱和的PID控制算法C语言实现所谓的积分饱和现象是指如果系统存在一个方向的偏差,PID控制器的输出由于积分作用的不竭累加而加年夜,从而招致执行机构到达极限位置,若控制器输出U(k)继续增年夜,执行器开度不成能再增年夜,此时计算机输出控制量超越了正常运行范围而进入饱和区.一旦系统呈现反向偏差,u(k)逐渐从饱和区退出.进入饱和区越深则退出饱和区时间越长.在这段时间里,执行机构仍然停留在极限位置而不随偏差反向而立即做出相应的改变,这时系统就像失控一样,造成控制性能恶化,这种现象称为积分饱和现象或积分失控现象.防止积分饱和的方法之一就是抗积分饱和法,该方法的思路是在计算u(k)时,首先判断上一时刻的控制量u(k1)是否已经超越了极限范围:如果u(k1)>umax,则只累加负偏差; 如果u(k1)<umin,则只累加正偏差.从而防止控制量长时间停留在饱和区.直接贴出代码,不懂的看看前面几节的介绍.struct _pid{float SetSpeed; //界说设定值float ActualSpeed; //界说实际值float err; //界说偏差值float err_last; //界说上一个偏差值float Kp,Ki,Kd; //界说比例、积分、微分系数float voltage; //界说电压值(控制执行器的变量)float integral; //界说积分值float umax;float umin;}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.1; //注意,和上几次相比,这里加年夜了积分环节的值pid.Kd=0.2;pid.umax=400;pid.umin=200;printf("PID_init end \n");}float PID_realize(float speed){int index;pid.SetSpeed=speed;pid.err=pid.SetSpeedpid.ActualSpeed;if(pid.ActualSpeed>pid.umax) //灰色底色暗示抗积分饱和的实现{if(abs(pid.err)>200) //蓝色标注为积分分离过程{index=0;}else{index=1;if(pid.err<0){pid.integral+=pid.err;}}}else if(pid.ActualSpeed<pid.umin){if(abs(pid.err)>200) //积分分离过程{index=0;}else{index=1;if(pid.err>0){pid.integral+=pid.err;}}}else{if(abs(pid.err)>200)//积分分离过程{index=0;}else{index=1;pid.integral+=pid.err;}}pid.voltage=pid.Kp*pid.err+index*pid.Ki*pid.integral+pid.Kd*(p id.errpid.err_last);pid.err_last=pid.err;pid.ActualSpeed=pid.voltage*1.0;return pid.ActualSpeed;}最终的测试法式运算结果如下,可以明显的看出系统的稳按时间相对前几次来讲缩短了很多.PID控制算法的C语言实现七梯形积分的PID控制算法C语言实现先看一下梯形算法的积分环节公式作为PID控制律的积分项,其作用是消除余差,为了尽量减小余差,应提高积分项运算精度,为此可以将矩形积分改为梯形积分,具体实现的语句为:pid.voltage=pid.Kp*pid.err+index*pid.Ki*pid.integral/2+pid.Kd*(pid.er rpid.err_last); //梯形积分其它函数请拜会本系列教程六中的介绍最后运算的稳定命据为:199.999878,较教程六中的199.9999390而言,精度进一步提高.PID控制算法的C语言实现八变积分的PID控制算法C语言实现变积分PID可以看成是积分分离的PID算法的更一般的形式.在普通的PID控制算法中,由于积分系数ki是常数,所以在整个控制过程中,积分增量是不变的.可是,系统对积分项的要求是,系统偏差年夜时,积分作用应该减弱甚至是全无,而在偏差小时,则应该加强.积分系数取年夜了会发生超调,甚至积分饱和,取小了又不能短时间内消除静差.因此,根据系统的偏差年夜小改变积分速度是有需要的.变积分PID的基本思想是设法改变积分项的累加速度,使其与偏差年夜小相对应:偏差越年夜,积分越慢; 偏差越小,积分越快.这里给积分系数前加上一个比例值index:当abs(err)<180时,index=1;当180<abs(err)<200时,index=(200abs(err))/20;当abs(err)>200时,index=0;最终的比例环节的比例系数值为ki*index;具体PID实现代码如下:pid.Kp=0.4;pid.Ki=0.2; //增加了积分系数pid.Kd=0.2;float PID_realize(float speed){float index;pid.SetSpeed=speed;pid.err=pid.SetSpeedpid.ActualSpeed;if(abs(pid.err)>200) //变积分过程{index=0.0;}else if(abs(pid.err)<180){index=1.0;pid.integral+=pid.err;}else{index=(200abs(pid.err))/20;pid.integral+=pid.err;}pid.voltage=pid.Kp*pid.err+index*pid.Ki*pid.integral+pid.Kd*(p id.errpid.err_last);pid.err_last=pid.err;pid.ActualSpeed=pid.voltage*1.0;return pid.ActualSpeed;}最终结果可以看出,系统的稳定速度非常快(测试法式拜会本系列教程3):120.00 0000 64.000 000 148.80 0003 96.959 999 165.63 120.93 4395 177.30 0476 139.08 1223 185.46 9742 152.89 8834 191.13 9313 163.45 2988 195.022278171.538986197.635025177.753738199.350967182.546188200.439255186.254608201.093094189.134460201.450439191.379044201.609268193.135010201.638611194.513870201.586670195.600708201.486694196.460571201.361328197.143387201.225632197.687561201.089340198.122787200.958511198.472076200.836655198.753296200.725555198.980423200.625870199.164398200.537506199.313843200.459900199.435547200.392258199.534912200.333679199.616211200.283203199.682877200.239899199.737640200.202866199.782700200.171295199.819855200.144470199.850525200.121704199.875870200.102432199.896851200.086136199.914230200.072372199.928635200.060776199.940582200.051010199.950500200.042801199.958755200.035904199.965622200.030090199.971344200.025223199.976105200.021118 199.98 0057 200.01 7700 199.98 3353 200.01 4832 199.98 6099 200.01 2421 199.98 8403 200.01 0391 199.99 0326 200.00 8698 199.99 1928 200.00 7263 199.99 3256 200.00 6088 199.99 4370 200.00 5081 199.99 5300 200.00 4257 199.99 6063 200.00 3555 199.99 6719 200.002975199.997253200.002487199.997711200.002075199.998077200.001740199.998398200.001465199.998657200.001221199.998886200.001007199.999084200.000839199.999237200.000702199.999359200.000580199.999451200.000488199.999542200.000397199.999619200.000336199.999680200.000275199.999725200.000229199.999756200.000198199.999802200.000168199.999832200.000137199.999863200.000107199.999893200.000092199.999908200.000076199.999924200.000061199.999939200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.00199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.99 9954 200.00 0046 199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046199.999954200.000046PID控制算法的C语言实现九专家PID与模糊PID 的C语言实现本节是PID控制算法的C语言实现系列的最后一节,前面8节中,已经分别从PID的实现到深入的过程进行了一个简要的讲解,畴前面的讲解中不难看出,PID的控制思想非常简单,其主要问题点和难点在于比例、积分、微分环节上的参数整定过程,对执行器控制模型确定或者控制模型简单的系统而言,参数的整定可以通过计算获得,对一般精度要求不是很高的执行器系统,可以采纳拼凑的方法进行实验型的整定.然而,在实际的控制系统中,线性系统究竟是少数,年夜部份的系统属于非线性系统,或者说是系统模型不确定的系统,如果控制精度要求较高的话,那么对参数的整定过程是有难度的.专家PID和模糊PID就是为满足这方面的需求而设计的.专家算法和模糊算法都归属于智能算法的范畴,智能算法最年夜的优点就是在控制模型未知的情况下,可以对模型进行控制.这里需要注意的是,专家PID也好,模糊PID也罢,绝对不是专家系统或模糊算法与PID控制算法的简单加和,他是专家系统或者模糊算法在PID控制器参数整定上的应用.也就是说,智能算法是辅助PID进行参数整定的手段.其实在前面几节的讲述中,已经用到了专家PID的一些特例行为了,从第五节到第八节都是专家系统一些特列化的算法,对某些条件进行了局部的判定,比如如果偏差太年夜的话,就去除积分项,这自己就是含有经验的专家系统.专家系统、模糊算法,需要参数整定就一定要有整定的依据,也就是说什么情况下整定什么值是要有依据的,这个依据是一些逻辑的组合,只要找出其中的逻辑组合关系来,这些依据就再明显不外了.下面先说一下专家PID的C语言实现.正如前面所说,需要找到一些依据,还得从PID系数自己说起.1.比例系数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(k1)>0或者e=0时,说明误差的绝对值向减小的方向变动,或者已经到达平衡状态,此时坚持控制器输出不变即可.当e*err<0且e*err(k1)<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,隶属于中的水平是0.7,隶属于年夜的水平是0.这里实际上是有一个问题的,就是这个隶属的水平怎么确定?这就要求我们去设计一个隶属函数.详细内容可以查阅相关的资料,这里没有法子那么详细的说明了.http://baike.百度.com/view/150383.htm(见附录3)这里面有些说明.那么,知道了隶属度的问题,就可以根据目前隶属的水平来控制机电以多年夜的速度和方向转动了,固然,最终的控制量肯定要落实在控制电压上.这点可以很容易的想想,我们控制的目的就是让倒立摆从隶属“年夜”的水平为1的状态,调节到隶属“小”的水平为1的状态.当隶属年夜多一些的时候,我们就加快调节的速度,当隶属小多一些的时候,我们就减慢调节的速度,进行微调.可问题是,年夜、中、小的状态是汉字,怎么用数字暗示,进而用法式代码暗示呢?其实我们可以给年夜、中、小三个状态设定三个数字来暗示,比如年夜暗示用3暗示,中用2暗示,小用1暗示.那么我们完全可以用1*0.3+2*0.7+3*0.0=1.7来暗示它,固然这个公式也纷歧定是这样的,这个公式的设计是系统模糊化和精确化的一个过程,读者也可拜会相关文献理解.但就1.7这个数字而言,可以说明,目前6°的角度偏差处于小和中之间,可是更偏向于中.我们就可以根据这个数字来调节机电的转动速度和时间了.固然,这个数字与机电转速的对应关系,也需要根据实际情况进行设计和调节.前面一个例子已经基本上说明了模糊算法的基来源根基理了.可是实际上,一个系统的限制因素经常不是一个.上面的例子中,只有偏差角度成了系统调节的参考因素.而实际系统中,比如PID系统,我们需要调节的是比例、积分、微分三个环节,那么这三个环节的作用就需要我们认清,也就是说,我们。
C语言实现PID算法
C语言实现PID算法PID算法是一种常用的控制算法,在工控系统中广泛应用。
下面将详细介绍C语言实现PID算法的步骤和代码。
PID算法是基于反馈的控制算法,通过对系统输出与期望输出之间的差异进行处理,生成一个控制器的输出信号,从而实现对系统状态的调节。
PID算法由比例(P)、积分(I)和微分(D)三个部分组成。
具体的计算公式为:输出值=Kp*(误差+1/Ti*积分项+Td*微分项)其中,Kp为比例系数,Ti为积分时间常数,Td为微分时间常数。
积分项为历史误差的累积,微分项为误差变化率的反馈。
下面是C语言实现PID算法的代码:```c//PID算法的数据结构typedef structdouble Kp; // 比例系数double Ti; // 积分时间常数double Td; // 微分时间常数double lastError; // 上一次的误差double integral; // 积分项}PID;void initPID(PID* pid, double Kp, double Ti, double Td)pid->Kp = Kp;pid->Ti = Ti;pid->Td = Td;pid->lastError = 0;pid->integral = 0;//更新PID算法的参数void updatePID(PID* pid, double error, double dt)double proportional, integral, derivative;//比例项proportional = pid->Kp * error;//积分项pid->integral += error * dt;integral = pid->Kp / pid->Ti * pid->integral;//微分项derivative = pid->Kp * pid->Td * (error - pid->lastError) / dt;//更新上一次的误差pid->lastError = error;//计算输出值double output = proportional + integral + derivative;//进行输出处理(例如对输出进行限幅)//...//输出控制信号//...```使用上述代码,可以通过调用`initPID`函数进行PID算法的初始化,并通过调用`updatePID`函数更新PID算法的参数和计算控制器的输出。
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(Proportional-Integral-Derivative)算法是一种常用的控制算法,被广泛应用于自动控制系统中。
它是通过计算系统当前的误差,来调整控制器的输出值,从而使得系统的输出与期望输出之间达到期望的关系。
以下是一个简单的PID算法的C语言实现示例:```c#include <stdio.h>//PID控制器参数float Kp = 1.0; // 比例系数float Ki = 0.5; // 积分系数float Kd = 0.2; // 微分系数//预设值float setpoint = 100.0;//PID控制器输出限制float outMin = 0.0;float outMax = 255.0;//PID控制器变量float integral = 0.0;float lastError = 0.0;//PID控制器计算函数//计算误差float error = setpoint - input;//计算比例项float proportional = Kp * error;//计算积分项integral += Ki * error;//计算微分项float derivative = Kd * (error - lastError);//保存上一次的误差lastError = error;//计算PID输出float output = proportional + integral + derivative; //限制输出值在指定范围内if (output > outMax)output = outMax;} else if (output < outMin)output = outMin;}return output;int maifloat processVariable = 0.0; // 进程变量,即被控制物理系统的输出值//模拟控制循环for (int i = 0; i < 100; i++)//获取控制器输出值//模拟物理系统processVariable += (output * 0.1);printf("Iteration: %d\tOutput: %.2f\tProcessVariable: %.2f\n", i, output, processVariable);}return 0;```上述代码中,首先定义了PID控制器的参数(比例系数Kp、积分系数Ki和微分系数Kd)、预设值(setpoint)以及PID控制器的输出限制(outMin和outMax)。
PID控制算法的C语言实现(完整版)
1.规定这个流程是用来为直流电机调速的;
PID控制算法的C语言实现一 PID算法原理
最近两天在考虑一般控制算法的C语言实现问题,发现网络上尚没有一套完整的比较体系的讲解。于是总结了几天,整理一套思路分享给大家。 在工业应用中PID及其衍生算法是应用最广泛的算法之一,是当之无愧的万能算法,如果能够熟练掌握PID算法的设计与实现过程,对于一般的研发人员来讲,应该是足够应对一般研发问题了,而难能可贵的是,在我所接触的控制算法当中,PID控制算法又是最简单,最能体现反馈思想的控制算法,可谓经典中的经典。经典的未必是复杂的,经典的东西常常是简单的,而且是最简单的,想想牛顿的力学三大定律吧,想想爱因斯坦的质能方程吧,何等的简单!简单的不是原始的,简单的也不是落后的,简单到了美的程度。先看看PID算法的一般形式:
PID的流程简单到了不能再简单的程度,通过误差信号控制被控量,而控制器本身就是比例、积分、微分三个环节的加和。这里我们规定(在t时刻):
1.输入量为rin(t);
2.输出量为rout(t);
3.偏差量为err(t)=rin(t)-rout(t);
pid的控制规律为
PID控制算法的C语言实现(完整版)
PID控制算法的C语言实现(完整版) 嘿,伙计们!今天我们要聊聊一个非常实用的技能——PID控制算法。
PID是英文Proportional-Integral-Derivative的缩写,翻译过来就是“比例积分微分”。
这个算法在我们的日常生活中随处可见,比如空调、洗衣机等家电的温度调节,还有汽车的速度控制等等。
那么,这个看似高深莫测的算法到底是怎么实现的呢?别急,让我们一起揭开它的神秘面纱吧!我们来了解一下PID控制算法的基本概念。
PID控制算法主要包括三个部分:比例(P)、积分(I)和微分(D)。
这三个部分分别对误差进行处理,然后将处理后的结果相加,得到控制输出。
具体来说,比例部分主要负责消除误差的瞬时成分;积分部分主要负责消除误差的稳态成分;微分部分则负责预测误差的未来变化趋势。
通过这三个部分的综合作用,我们可以实现对系统的精确控制。
接下来,我们来看一下PID控制算法的具体实现。
我们需要定义一些变量和参数,比如比例系数Kp、积分系数Ki、微分系数Kd以及采样时间Ts等。
这些参数的选择对于算法的效果至关重要,需要根据实际应用场景进行调整。
然后,我们需要不断地对系统进行采样,计算出当前的状态值和期望值之间的误差e(t)。
误差e(t)可以通过以下公式计算得到:e(t) = 期望值实际值有了误差e(t),我们就可以开始计算PID控制器的输出了。
根据之前的介绍,PID控制器的输出由比例、积分和微分三个部分组成。
具体计算过程如下:1. 比例部分:计算比例系数Kp乘以误差e(t),得到比例输出u(t);2. 积分部分:计算积分系数Ki乘以误差e(t)的时间积分,得到积分输出u(t);3. 微分部分:计算微分系数Kd乘以误差e(t)的时间微分,得到微分输出u(t)。
将比例、积分和微分三个部分的输出相加,得到最终的控制输出u(t)。
这样,我们就完成了一次PID控制算法的计算过程。
这只是理论上的实现方法,实际上还需要考虑一些其他因素,比如控制器的稳定性、响应速度等。
最全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 : 积分分离:能解决初期系统偏差值⼤,累加到积分项中,引起系统超调、振荡问题。
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语言实现精修订一、算法的实现步骤1.初始化PID参数:设定比例系数Kp、积分系数Ki和微分系数Kd的初值。
一般情况下,可以根据系统的特性进行经验调整。
2.设置控制目标:设定系统需要达到的目标值。
3.读取当前系统的测量值:使用传感器或其他设备获取当前系统的实际测量值。
4.计算系统误差:将目标值减去实际测量值,得到系统的误差。
5.计算PID控制量:将控制量设为比例项、积分项和微分项的和。
比例项为误差乘以比例系数Kp,积分项为误差的累积乘以积分系数Ki,微分项为误差变化率乘以微分系数Kd。
6.更新PID参数:根据实际情况,可调整PID参数的值。
一般情况下,可以使用经验调整方法,如试探法或模拟法。
7.输出控制量:将PID控制量作为输出,在系统中执行相应的控制操作,如调节电机的转速或改变阀门的开度。
8.循环执行以上步骤,直到系统达到控制目标或终止算法。
二、参数调整方法1.经验调整法:根据系统的特性和控制要求,选择合适的PID参数初值,通过实验或仿真来逐步调整参数,使系统达到最佳控制效果。
2. Ziegler-Nichols法则:利用开环试验的响应特性,通过确定系统的临界增益和周期,计算出PID参数。
该方法相对简单,但对系统的稳定性要求较高。
3.自整定法:利用系统的模型参数,结合在线参数调整技术,通过试错调整来获取最佳PID参数。
方法复杂度较高,但能够适应系统动态性变化较大的情况。
4.基于优化算法的自适应调整法:利用遗传算法、粒子群算法等优化算法,通过迭代计算获得最佳PID参数。
该方法不需要系统模型,但需要大量的计算和优化算法的实现。
三、实际应用案例假设有一个加热器,需要将温度控制在一个设定值范围内。
可以使用PID控制算法实现温度的稳定控制。
1.初始化PID参数:设定比例系数Kp=1,积分系数Ki=0.5和微分系数Kd=0.22.设置控制目标:设定温度控制的目标范围为35℃到40℃。
3.读取当前系统的温度值:使用温度传感器读取当前系统的实际温度值。
PID控制算法的C语言实现完整版
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算法c语言程序
位置式pid算法c语言程序下面是一个简单的位置式PID算法的C语言程序示例: c.#include <stdio.h>。
// 定义PID控制器的参数。
#define Kp 1.0。
#define Ki 0.1。
#define Kd 0.2。
// 定义全局变量。
double error_sum = 0; // 误差累积。
double last_error = 0; // 上一次的误差。
// PID控制器函数。
double pid_controller(double setpoint, double measured_value) {。
double error = setpoint measured_value; // 计算当前误差。
double p_term, i_term, d_term, output;// 比例控制器。
p_term = Kp error;// 积分控制器。
error_sum += error;i_term = Ki error_sum;// 微分控制器。
d_term = Kd (error last_error);last_error = error;// 计算PID输出。
output = p_term + i_term + d_term;return output;}。
int main() {。
double setpoint = 100; // 设定值。
double measured_value = 0; // 测量值。
double output;// 模拟PID控制过程。
for (int i = 0; i < 100; i++) {。
// 模拟测量值的变化。
measured_value += 1;// 计算PID输出。
output = pid_controller(setpoint, measured_value);// 输出PID控制器的输出。
printf("PID输出: %f\n", output);}。
位置式、增量式pid算法c语言实现
位置式、增量式pid算法c语言实现PID算法是一种常见的控制算法。
在控制系统中,PID算法可以用来控制常量、速度、位置、温度等多种量。
其中,位置式与增量式PID算法是其中两种比较常见的实现方式。
本文将针对这两种算法进行详细介绍,并附上C语言实现。
一、位置式PID算法1.算法原理位置式PID算法是最基本的PID算法实现方式。
其主要原理是,根据当前误差值(设为e),通过加权求和的方式得到当前的控制量(设为u)。
具体地,PID算法可以表示为下式:u(t) = Kp * e(t) + Ki * ∫e(t)dt + Kd * de/dt其中,Kp、Ki、Kd分别表示比例系数、积分系数和微分系数,e(t)表示当前误差值,de/dt表示当前误差的变化率,∫e(t)dt表示误差的积分值。
2.算法实现为了实现位置式PID算法,我们需要先定义三个变量表示比例系数、积分系数和微分系数。
同时,我们还需要定义一些变量进行PID计算时的存储。
其中,包括误差值、误差的积分值、误差的变化率等。
下面给出位置式PID算法的C语言实现代码://PID Algorithm for position controlfloat Kp = 1.0; //Proportional coefficientfloat Ki = 0.1; //Integral coefficientfloat Kd = 0.01; //Differential coefficientfloat output = 0.0; //Control outputoutput = p_term + i_term + d_term;其中,Kp、Ki、Kd分别与位置式PID算法相同。
Δe(t)表示当前误差的变化量,即Δe(t) = e(t) - e(t-1)。
由于Δe(t)比e(t)更加稳定,所以增量式PID算法在某些情况下表现更好。
float PID_incremental_control(float set_point, float process_value){error = set_point - process_value;delta_error = error - last_error;p_term = Kp * delta_error;i_term += Ki * error;d_term = Kd * (delta_error + delta_error_last + delta_error_last_last);三、总结本文从原理出发,分别介绍了位置式和增量式PID算法的基本思路和实现方式,并提供了相应的C语言实现代码。
C语言实现PID算法
C语言实现PID算法#include <stdio.h>struct _pid {int pv; /*integer that contains the process value*/int sp; /*integer that contains the set point*/float integral;float pgain;float igain;float dgain;int deadband;int last_error;};struct _pid warm,*pid;int process_point, set_point,dead_band;float p_gain, i_gain, d_gain, integral_val,new_integ;;/*------------------------------------------------------------------------pid_initDESCRIPTION This function initializes the pointers in the _pid structure to the process variable and the setpoint. *pv and *sp areinteger pointers.------------------------------------------------------------------------*/void pid_init(struct _pid *warm, int process_point, int set_point){struct _pid *pid;pid = warm;pid->pv = process_point;pid->sp = set_point;}/*------------------------------------------------------------------------pid_tuneDESCRIPTION Sets the proportional gain (p_gain), integral gain (i_gain), derivitive gain (d_gain), and the dead band (dead_band) ofa pid control structure _pid.------------------------------------------------------------------------*/void pid_tune(struct _pid *pid, float p_gain, float i_gain, float d_gain, int dead_band) {pid->pgain = p_gain;pid->igain = i_gain;pid->dgain = d_gain;pid->deadband = dead_band;pid->integral= integral_val;pid->last_error=0;}/*------------------------------------------------------------------------pid_setintegDESCRIPTION Set a new value for the integral term of the pid equation.This is useful for setting the initial output of thepid controller at start up.------------------------------------------------------------------------*/void pid_setinteg(struct _pid *pid,float new_integ){pid->integral = new_integ;pid->last_error = 0;}/*------------------------------------------------------------------------pid_bumplessDESCRIPTION Bumpless transfer algorithim. When suddenly changing setpoints, or when restarting the PID equation after anextended pause, the derivative of the equation can causea bump in the controller output. This function will helpsmooth out that bump. The process value in *pv shouldbe the updated just before this function is used.------------------------------------------------------------------------*/void pid_bumpless(struct _pid *pid){pid->last_error = (pid->sp)-(pid->pv);}/*------------------------------------------------------------------------pid_calcDESCRIPTION Performs PID calculations for the _pid structure *a. This function uses the positio nal form of the pid equation, and incorporates an integral windup prevention algorithim. Rectangu lar integration is used, so this function must be repeated on a consistent time basis for accurate con trol.RETURN V ALUE The new output value for the pid loop.USAGE #include "control.h"*/float pid_calc(struct _pid *pid){int err;float pterm, dterm, result, ferror;err = (pid->sp) - (pid->pv);if (abs(err) > pid->deadband){ferror = (float) err; /*do integer to float conversion only once*/pterm = pid->pgain * ferror;if (pterm > 100 || pterm < -100){pid->integral = 0.0;}else{pid->integral += pid->igain * ferror;if (pid->integral > 100.0){pid->integral = 100.0;}else if (pid->integral < 0.0) pid->integral = 0.0;}dterm = ((float)(err - pid->last_error)) * pid->dgain;result = pterm + pid->integral + dterm;}else result = pid->integral;pid->last_error = err;return (result);}void main(void)float display_value;int count=0;pid = &warm;// printf("Enter the values of Process point, Set point, P gain, I gain, D gain \n");// scanf("%d%d%f%f%f", &process_point, &set_point, &p_gain, &i_gain, &d_gain);process_point = 30;set_point = 40;p_gain = (float)(5.2);i_gain = (float)(0.77);d_gain = (float)(0.18);dead_band = 2;integral_val =(float)(0.01);printf("The values of Process point, Set point, P gain, I gain, D gain \n");printf(" %6d %6d %4f %4f %4f\n", process_point, set_point, p_gain, i_gain, d_gain); printf("Enter the values of Process point\n");while(count<=20){scanf("%d",&process_point);pid_init(&warm, process_point, set_point);pid_tune(&warm, p_gain,i_gain,d_gain,dead_band);pid_setinteg(&warm,0.0); //pid_setinteg(&warm,30.0);//Get input value for process pointpid_bumpless(&warm);// how to display outputdisplay_value = pid_calc(&warm);printf("%f\n", display_value);//printf("\n%f%f%f%f",warm.pv,warm.sp,warm.igain,warm.dgain);count++;}}PID算法/******************************************************************** *********************************** PID控制算法 PID Control Algorithm* 在仿真和实验中,航向预估控制方法和与之对比的常规控制方法的控制器均采用增量PID算法,* 且两者的比例、积分和微分系数一样.增量PID算法如式(7)所示:* ΔU = U(k)-U(k-1) =Kp*[e(k)-e(k-1)]+Ki*e(k)+Kd*[e(k)-2*e(k-1)+e(k-2)]* 其中:Kp、Ki、Kd分别为比例、积分和微分放大系数,u(k)表示第k个采样时刻的控制量,e(k)表示第k个采样时刻的航向输入偏差.********************************************************************* **********************************/void PID_Calc(int PID_EK){long deltaU,tmp;deltaU = (long)u_dbPIDKp.IntData*(PID_EK-PID_EK_1); // 增量计算deltaU +=(long)u_dbPIDKi.IntData*PID_EK;tmp = (long)PID_EK-(2*PID_EK_1)+PID_EK_2;deltaU +=tmp* u_dbPIDKd.IntData;PID_UK = PID_UK_1+deltaU; // 结果if(PID_UK>4095000) PID_UK = 4095000;else if(PID_UK<0) PID_UK=0;PID_UK_1 = PID_UK; // 保存新的K-1次输出值PID_EK_2 = PID_EK_1; // 保存新的K-1次输入值PID_EK_1 = PID_EK;}PID是比例,积分,微分的缩写,Uo(N)=P*E(N)+I*[E(N)+E(N-1)+...+E(0)]+D*[E(N)-E(N-1)]E-误差P--改变P 可提高响应速度,减小静态误差,但太大会增大超调量和稳定时间。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
pid算法C源程序,还有实现pid自动调整。
51用于控制温度26-100摄氏度。
#include <stdlib.h>
#include "global_varible.h"
/****************************************************************************
* 模块名: PID
* 描述: PID调节子程序
* 采用PID-PD算法。
在偏差绝对值大于△e时,用PD算法,以改善动态品质。
* 当偏差绝对值小于△e时,用PID算法,提高稳定精度。
* PIDout=kp*e(t)+ki*[e(t)+e(t-1)+...+e(1)]+kd*[e(t)-e(t-1)]
*==========
* 入口: 无
* 出口: 无
* 改变: PID_T_Run=加热时间控制
*****************************************************************************/
void PID_Math(void)
{
signed long ee1; //偏差一阶
//signed long ee2; //偏差二阶
signed long d_out; //积分输出
if(!Flag_PID_T_OK)
return;
Flag_PID_T_OK=0;
Temp_Set=3700; //温度控制设定值37.00度
PID_e0 = Temp_Set-Temp_Now; //本次偏差
ee1 = PID_e0-PID_e1; //计算一阶偏差
//ee2 = PID_e0-2*PID_e1+PID_e2; //计算二阶偏差
if(ee1 > 500) //一阶偏差的限制范围
ee1 = 500;
if(ee1 < -500)
ee1 = -500;
PID_e_SUM += PID_e0; //偏差之和
if(PID_e_SUM > 200) //积分最多累计的温差
PID_e_SUM = 200;
if(PID_e_SUM < -200)
PID_e_SUM = -200;
PID_Out = PID_kp*PID_e0+PID_kd*ee1; //计算PID比例和微分输出
if(abs(PID_e0) < 200) //如果温度相差小于1.5度则计入PID积分输出
{
if(abs(PID_e0) > 100) //如果温度相差大于1度时积分累计限制
{
if(PID_e_SUM > 100)
PID_e_SUM = 100;
if(PID_e_SUM < -100)
PID_e_SUM = -100;
}
d_out = PID_ki*PID_e_SUM; //积分输出
if(PID_e0 < -5) //当前温度高于设定温度0.5度时积分累计限制
{
if(PID_e_SUM > 150)
PID_e_SUM = 150;
if(PID_e_SUM > 0) //当前温度高于设定温度0.5度时削弱积分正输出d_out >>= 1;
}
PID_Out += d_out; //PID比例,积分和微分输出
}
else
PID_e_SUM=0;
PID_Out/=100; //恢复被PID_Out系数放大的倍数
if(PID_Out > 200)
PID_Out=200;
if(PID_Out<0)
PID_Out=0;
if(PID_e0 > 300) //当前温度比设定温度低3度则全速加热
PID_Out=200;
if(PID_e0 < -20) //当前温度高于设定温度0.2度则关闭加热
PID_Out=0;
Hot_T_Run=PID_Out; //加热时间控制输出
PID_e2 = PID_e1; //保存上次偏差
PID_e1 = PID_e0; //保存当前偏差
}
////////////////////////////////////////////////////////////void PID_Math() end.。