精华内容
下载资源
问答
  • PID c语言
    2022-06-14 15:56:30

     自己写的pid代码

    
    //位置型PID
    typedef struct _position_pid{
        float target_value;       //定义设定值
        float measure_value;      //定义实际值
        float output_value;       //定义输出值
        float output_max;
        float output_min;
        float err;                //定义偏差值
        float err_last;           //定义上一个偏差值
        float integral;           //定义积分值
        float Kp;                 //比例系数
        float Ki;                 //积分系数
        float Kd;                 //微分系数
    }position_pid_t;
    
    
    float position_pid_calc(position_pid_t *pid, float target_value, float measure_value)
    {
        pid->target_value = target_value;
        pid->measure_value = measure_value;
        pid->output_value = 0;
    
        pid->err = pid->target_value - pid->measure_value;
    
        //pid->integral += (pid->Ki * pid->err);
    
        //pid->output_value += pid->integral;
    
        pid->output_value += (pid->Kp * pid->err) + pid->Kd*(pid->err - pid->err_last);
    
        pid->err_last = pid->err;
    
        return pid->output_value;
    }
    
    
    
    
    
    //增量型PID
    typedef struct _increment_pid{
        float target_value;       //定义设定值
        float measure_value;      //定义实际值
        float output_value;       //定义输出值
        float output_max;
        float output_min;
        float err;                //定义偏差值
        float err_last;           //定义上一个偏差值
        float err_last_last;      //定义上一个的上一个偏差值
        float Kp;                 //比例系数
        float Ki;                 //积分系数
        float Kd;                 //微分系数
    }increment_pid_t;
    
    
    float increment_pid_calc(increment_pid_t *pid, float target_value, float measure_value)
    {
        pid->target_value = target_value;
        pid->measure_value = measure_value;
    
        pid->err = pid->target_value - pid->measure_value;
    
        pid->output_value = (pid->Kp * pid->err) - (pid->Ki* pid->err_last)  + (pid->Kd * pid->err_last_last);
    
        pid->err_last_last = pid->err_last;
        pid->err_last = pid->err;
    
        return pid->output_value;
    }
    
    

    参考: 

    PID控制算法的C语言实现_沐白001的博客-CSDN博客_pid 实现

    位置式PID与增量式PID的介绍和代码实现_【ql君】qlexcel的博客-CSDN博客_pid位置式和增量式详解

    更多相关内容
  • 用于温度控制的PID程序,用c语言编写而成,在试验应用中比较可靠,已经调试过
  • 模糊+PID C语言实现

    2018-06-20 00:11:13
    模糊PID算法,采用C语言实现,对于控制类,特别像温度控制类变化需要预测的类型,可以采用此算法
  • 增量式PID,c 语言下实现的例程。有很好的参考性。
  • C语言实现PID算法的程序代码,简单易懂
  • PID.rar_pid_pid c语言

    2022-09-22 20:23:38
    单片机51AT89S52 PID 控制部分的程序 开发环境KEIL C语言开发
  • PID calculations for the _pid structure *a. This function uses the positional form of the pid equation, and incorporates an integral windup prevention algorithim. Rectangular integration is used, so ...
  • PID算法用C语言实现,详细介绍PID算法的原理及应用。
  • PID.rar_pid c语言

    2022-09-24 18:17:27
    PIDC语言算法使用,对PID使用有大的帮组
  • PID实例,用c语言实现的PID程序,很实用。
  • PID算法 C语言 控制 原理 经验总结
  • pid.rar_pid c语言

    2022-09-21 09:07:23
    PID经典实用的C语言算法可用于了解学习
  • 模糊PID控制的C语言实现,C语言开发方便移植
  • 基于单片机的c语言描述PID算法,可移植
  • C语言编写的模糊PID,已经增加注释,分享给大家学习
  • 一个比较典型的PID处理程序,C语言编写
  • 一个经典的PID算法实例 很有参考价值 C语言实现
  • C语言的,单片机做温度控制的小系统程序,含PID算法
  • 模糊PIDC语言程序,模糊PIDC语言程序,模糊PIDC语言程序,
  • PID算法(DSP C语言),可以作参考用
  • 自适应PID C语言代码

    2018-02-24 11:00:59
    自适应 PID c语言自适应 PID
  • PID控制,C语言PID机电控制,比例,积分,微分算法
  • Incremental PID Control增量式PID算法C语言实现C implementation of Incremental PID Control
  • 模糊-PID控制C语言源程序.rar,pid-fuzzy.c
  • KEILC51语言基于模糊控制的PID程序
  • 模糊pid 电机控制 直流电机 c语言编写 高手指正错误
  • PID控制算法的C语言实现(完整版).pdf
  • PIDC语言例程
  • PID C语言实现

    千次阅读 多人点赞 2017-06-09 14:54:30
    PID控制算法的C语言实现一 PID算法原理  最近两天在考虑一般控制算法的C语言实现问题,发现网络上尚没有一套完整的比较体系的讲解。于是总结了几天,整理一套思路分享给大家。  在工业应用中PID及其衍生算法是...

    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之间存在怎样的联系呢?

    http://blog.21ic.com/user1/3407/archives/2006/33541.html(见附录1)这篇文章上给出了一种方法,即,每个电压对应一个转速,电压和转速之间呈现线性关系。但是我考虑这种方法的前提是把直流电机的特性理解为线性了,而实际情况下,直流电机的特性绝对不是线性的,或者说在局部上是趋于线性的,这就是为什么说PID调速有个范围的问题。具体看一下http://articles.e-works.NET.cn/component/article90249.htm(见附录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;            //定义设定值
        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;
    }

    注意:这里用了最基本的算法实现形式,没有考虑死区问题,没有设定上下限,只是对公式的一种直接的实现,后面的介绍当中还会逐渐的对此改进。

       到此为止,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个数据(具体的参数整定过程就不说明了,网上这种说明非常多):


    83.000001 11.555000 59.559675 28.175408 52.907421 38.944152
    51.891699 46.141651
    53.339054 51.509998 55.908450 55.944631 58.970680
    59.882936 62.225001 63.537254 65.527707 67.01105868.81064670.355318
    72.042040 73.595658 75.20762076.745444
    78.301526 79.812136 81.321929 82.800304
    84.268909
    85.713108
    87.143455
    88.553005
    89.946960
    91.322078
    92.680996
    94.022234
    95.347186
    96.655242

    199.999321 199.999323 199.999344
    199.999352 199.999364
    199.999381 199.999390 199.999401
    199.999412 199.999430 199.999432
    199.999453 199.999461 199.999473


     

     

    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.SetSpeed-pid.ActualSpeed;
        float incrementSpeed=pid.Kp*(pid.err-pid.err_next)+pid.Ki*pid.err+pid.Kd*(pid.err-2*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个数据为:


    83.000000
    11.555000
    59.559677
    28.175406
    52.907425
    38.944149
    51.891701
    46.141655
    53.339050
    51.510002
    55.908447
    55.944637
    58.970676
    59.882942
    62.224998
    63.537247
    65.527702
    67.011047
    68.810638
    70.355309
    72.042023
    73.595642
    75.207603
    76.745430
    78.301514
    79.812126
    81.321915
    82.800293
    84.268898
    85.713097
    87.143440
    88.552994
    89.946945
    91.322067
    92.680977
    94.022224
    95.347176
    96.655235
    97.947174
    99.222801
    100.482597
    101.726562
    102.955040
    104.168114
    105.366058
    106.549004
    107.717178
    108.870743
    110.009888
    111.134796
    112.245636
    113.342598

    199.999329
    199.999344
    199.999344
    199.999359
    199.999359
    199.999374
    199.999374
    199.999390
    199.999390
    199.999405
    199.999405
    199.999420
    199.999420
    199.999435
    199.999435
    199.999451
    199.999451
    199.999466
    199.999466
    199.999481
    199.999481
    199.999496
    199.999496
    199.999512
    199.999512

    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*(pid.err-pid.err_last);    //算法具体实现过程

     

    其它部分的代码参见《PID控制算法的C语言实现三》中的讲解,不再赘述。同样采集1000个量,会发现,系统到199所有的时间是原来时间的1/2,系统的快速性得到了提高。



    199.003571
    199.036804
    199.068924
    199.099960
    199.129974
    199.158981
    199.187012
    199.214111
    199.240311
    199.265640

    199.999771
    199.999771
    199.999771
    199.999771
    199.999771
    199.999771
    199.999771

    PID控制算法的C语言实现六 抗积分饱和的PID控制算法C语言实现

       所谓的积分饱和现象是指如果系统存在一个方向的偏差,PID控制器的输出由于积分作用的不断累加而加大,从而导致执行机构达到极限位置,若控制器输出U(k)继续增大,执行器开度不可能再增大,此时计算机输出控制量超出了正常运行范围而进入饱和区。一旦系统出现反向偏差,u(k)逐渐从饱和区退出。进入饱和区越深则退出饱和区时间越长。在这段时间里,执行机构仍然停留在极限位置而不随偏差反向而立即做出相应的改变,这时系统就像失控一样,造成控制性能恶化,这种现象称为积分饱和现象或积分失控现象。

        防止积分饱和的方法之一就是抗积分饱和法,该方法的思路是在计算u(k)时,首先判断上一时刻的控制量u(k-1)是否已经超出了极限范围: 如果u(k-1)>umax,则只累加负偏差; 如果u(k-1)<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.SetSpeed-pid.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*(pid.err-pid.err_last);

        pid.err_last=pid.err;
        pid.ActualSpeed=pid.voltage*1.0;
        return pid.ActualSpeed;
    }

    最终的测试程序运算结果如下,可以明显的看出系统的稳定时间相对前几次来讲缩短了不少。


    100.000000
    30.000000
    95.000000
    65.500000
    103.750000
    92.175003
    115.237503
    112.173752
    126.794380
    127.653938
    137.468842
    139.967911
    146.934479
    149.954224
    155.144211
    158.157745
    162.174561
    164.953079
    168.149734
    170.611786
    173.205124
    175.339691
    177.470551
    179.298065
    181.063431
    182.616440
    184.086655
    185.400513
    186.628952
    187.737457
    188.766006
    189.699692
    190.561951
    191.347580
    192.071030
    192.731674
    193.338928
    193.894257
    194.404160
    194.870834
    195.299072
    195.691193
    196.050888
    196.380341
    196.682465
    196.959244
    197.213043
    197.445572
    197.658768
    197.854111
    198.033203
    198.197311
    198.347763
    198.485626
    198.612015
    198.727829
    198.834000
    198.931290
    199.020477
    199.102219
    199.177139
    199.245804
    199.308746
    199.366425
    199.419296
    199.467758
    199.512161
    199.552872

    199.999939
    199.999939
    199.999939
    199.999939
    199.999939
    199.999939
    199.999939

    PID控制算法的C语言实现七 梯形积分的PID控制算法C语言实现

       先看一下梯形算法的积分环节公式

       作为PID控制律的积分项,其作用是消除余差,为了尽量减小余差,应提高积分项运算精度,为此可以将矩形积分改为梯形积分,具体实现的语句为:

    pid.voltage=pid.Kp*pid.err+index*pid.Ki*pid.integral/2+pid.Kd*(pid.err-pid.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=(200-abs(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.SetSpeed-pid.ActualSpeed;

        if(abs(pid.err)>200)           //变积分过程
        {
        index=0.0;
        }else if(abs(pid.err)<180){
        index=1.0;
        pid.integral+=pid.err;
        }else{
        index=(200-abs(pid.err))/20;
        pid.integral+=pid.err;
        }
        pid.voltage=pid.Kp*pid.err+index*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;
    }

    最终结果可以看出,系统的稳定速度非常快(测试程序参见本系列教程3):


    120.000000
    64.000000
    148.800003
    96.959999
    165.632004
    120.934395
    177.300476
    139.081223
    185.469742
    152.898834
    191.139313
    163.452988
    195.022278
    171.538986
    197.635025
    177.753738
    199.350967
    182.546188
    200.439255
    186.254608
    201.093094
    189.134460
    201.450439
    191.379044
    201.609268
    193.135010
    201.638611
    194.513870
    201.586670
    195.600708
    201.486694
    196.460571
    201.361328
    197.143387
    201.225632
    197.687561
    201.089340
    198.122787
    200.958511
    198.472076
    200.836655
    198.753296
    200.725555
    198.980423
    200.625870
    199.164398
    200.537506
    199.313843
    200.459900
    199.435547
    200.392258
    199.534912
    200.333679
    199.616211
    200.283203
    199.682877
    200.239899
    199.737640
    200.202866
    199.782700
    200.171295
    199.819855
    200.144470
    199.850525
    200.121704
    199.875870
    200.102432
    199.896851
    200.086136
    199.914230
    200.072372
    199.928635
    200.060776
    199.940582
    200.051010
    199.950500
    200.042801
    199.958755
    200.035904
    199.965622
    200.030090
    199.971344
    200.025223
    199.976105
    200.021118
    199.980057
    200.017700
    199.983353
    200.014832
    199.986099
    200.012421
    199.988403
    200.010391
    199.990326
    200.008698
    199.991928
    200.007263
    199.993256
    200.006088
    199.994370
    200.005081
    199.995300
    200.004257
    199.996063
    200.003555
    199.996719
    200.002975
    199.997253
    200.002487
    199.997711
    200.002075
    199.998077
    200.001740
    199.998398
    200.001465
    199.998657
    200.001221
    199.998886
    200.001007
    199.999084
    200.000839
    199.999237
    200.000702
    199.999359
    200.000580
    199.999451
    200.000488
    199.999542
    200.000397
    199.999619
    200.000336
    199.999680
    200.000275
    199.999725
    200.000229
    199.999756
    200.000198
    199.999802
    200.000168
    199.999832
    200.000137
    199.999863
    200.000107
    199.999893
    200.000092
    199.999908
    200.000076
    199.999924
    200.000061

    200.000046
    199.999954
    200.000046
    199.999954
    200.000046
    199.999954
    200.000046
    199.999954
    200.000046
    199.999954
    200.000046
    199.999954
    200.000046
    199.999954
    200.000046
    199.999954
    200.000046
    199.999954
    200.000046
    199.999954
    200.000046
    199.999954
    200.000046
    199.999954
    200.000046
    199.999954
    200.000046
    199.999954
    200.000046
    199.999954
    200.000046
    199.999954
    200.000046
    199.999954
    200.000046
    199.999954
    200.000046

    PID控制算法的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(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,隶属于中的程度是0.7,隶属于大的程度是0。这里实际上是有一个问题的,就是这个隶属的程度怎么确定?这就要求我们去设计一个隶属函数。详细内容可以查阅相关的资料,这里没有办法那么详细的说明了。http://baike.baidu.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系统,我们需要调节的是比例、积分、微分三个环节,那么这三个环节的作用就需要我们认清,也就是说,我们需要根据超调量、调节时间、震荡情况等信息来考虑对这三个环节调节的比重,输入量和输出量都不是单一的,可是其中必然有某种内在的逻辑联系。所以这种逻辑联系就成为我们设计工作的重点了。下一篇文章将详细分析PID三个变量和系统性能参数之间的联系。

     

     

    PID控制算法的c语言实现十一(PID系列完结篇) 模糊PID的参数整定

      这几天一直在考虑如何能够把这一节的内容说清楚,对于PID而言应用并没有多大难度,按照基本的算法设计思路和成熟的参数整定方法,就算是没有经过特殊训练和培训的人,也能够在较短的时间内容学会使用PID算法。可问题是,如何能够透彻的理解PID算法,从而能够根据实际的情况设计出优秀的算法呢。

      通过讲述公式和基本原理肯定是最能说明问题的,可是这样的话怕是犯了“专家”的错误了。对于门槛比较低的技术人员来讲,依然不能透彻理解。可是说的入耳了,能不能透彻说明也是一个问题,所以斟酌了几天,整理了一下思路才开始完成PID系列文章的最后一篇。

      我所说的最后一篇不代表PID的功能和发展就止步与此,仅仅是说明,透过这一些列的文章,基本上已经可以涵盖PID设计的要点,至于更深入的研究,就交给有需要的读者去做。

       上一节中大致讲述了一下模糊算法。实际上模糊算法的很多概念在上一节中并没有深入的解释。举的例子也只是为了说明模糊算法的基本含义,真正的模糊算法是不能这么设计的,当然也不会这么简单。模糊算法的核心是模糊规则,如果模糊规则制定的出色,那么模糊算法的控制效率就高。其实这是智能算法的一般特性,规则是系统判断和处理的前提。那么就说说PID的规则该怎么制定。

       我们知道,模糊算法的本质是对PID的三个参数进行智能调节。那么首先要提出的问题是如何对PID的参数进行调节?这个问题其实是参数整定的问题,现实当中有很多整定方法。可是我们需要从根本上了解为什么这么整定,才能知道该如何建立数学模型进行分析。那么要回答如何整定参数的问题,就需要先明白PID参数的作用都是什么?对系统有什么影响?

      我们从作用和副作用两个方面说明参数对系统的影响。

       1.比例环节Kp,作用是加快系统的响应速度,提高系统的调节精度,副作用是会导致超调;

       2.积分环节Ki,作用是消除稳态误差,副作用是导致积分饱和现象;

       3.微分环节Kd,作用是改善系统的动态性能,副作用是延长系统的调节时间。

      理解了上述问题,那么就可以“辩证施治,对症下药”了。比如说,如果系统响应速度慢,我们就加大Kp的取值,如果超调量过大我们就减小Kp的取值等等。可是问题这些语言的描述该如何用数学形式表达出来呢。我们所知道的,反馈系统的实质就是系统的输出量作为反馈量与系统的输入量进行作差,从而得到系统的误差e,那么这个误差e就能够反应目前系统所处的状态。误差e可以表明目前系统的输出状态到底偏离要求多少。而误差e的变化律ec,表示误差变化的速度。这样,我们可以根据这两个量的状态来分析三个参数此时应该如何取值,假如e为负方向比较大,ec也为负方向增大状态,此时比例环节要大一些,从而加快调节速度,而积分环节要小一些,甚至不加积分环节,从而防止负方向上出现饱和积分的现象。微分环节可以稍加一些,在不影响调节时间的情况下,起到改善系统动态性能的作用。

     

     

     

     

     

     

     

    附录1

    看到有不少人问到底如何让UK值与PWM占空比值对应,进而实现占空比输出和输出控制电压对应。

    (注意,我这里讨论的前提是输出控制的是电压,不是PWM方波。PWM输出后要经过滤波整形再输出控制。)

    前提条件:

    输出电压控制电压范围是0-10V。

    给定、反馈、输出电压采样输入电压范围是0-5V(经过运放)。

    使用单片机AD为10位AD芯片。

    那么10位AD芯片电压采集得到的数据范围就是0-1024。

    PWM为 8位可调占空比方波,0对应输出占空比为0的方波,255对应输出占空比100%的方波,127对应输出50%的方波。

    比如当前给定是2.5V,反馈电压是1V。(KP,KI,KD等系数略,关于PID算法的整数实现我在前文中有论述如何实现)。

    那么经过AD采样

    1、给定2.5V对应为 512

    2、反馈1V对应为 205

    假定经过PID计算得到的UK为400

    也就意味着输出电压应当为(400*(UPWM峰值电压))/1024

    那么UK对应的PWM占空比是多少呢?

    我们知道,UK=1024对应占空比为100,也就是PWM的占空比系数为255。可知,PWM系数 = UK/4;

    那么400就应当对应系数 400/4=100。

    也就是输出电压=400*10/1024=3.9V

    同时,由于采样精度以及PWM输出占空比精度控制的问题,将导致输出电压和期望值不是那么线性,所以,我在项目内加入了输出电压采样的控制。

    采样AD输入为0-5V,所以,对于输出0-10V有一个缩小的比例。

    输出10V则采样值对应为255

    输出5V则采样之对应127

    可知,3.9V对应AD结果为97

    采样输出电压值,可以针对性的调整一下占空比输出,从而得到误差允许范围内的一个控制输出电压。

    同时,经过一些加速控制的手段。可以比较迅速的达到控制的目的。

    下文中的UK控制方法是针对增量式PID控制而来做的。

    /****************************************************/

    void    PWMProcess(void)

    {

        uint16 idata temp;

        uint16 idata UKTemp;

     temp = 0;

        UKTemp = 0;

        if( Pwm.ChangeFlag_Uint8 != 0 )   //判断是否需要改变占空比

     {                  //是否需要改变占空比和你的被控系统特性有关

         Pwm.ChangeFlag_Uint8 = 0;

      UKTemp = PID.Uk_Uint16 + SwIn.AddValue_Uint16;   

     //计算UK控制量

     //控制量和计算值以及一个开关量有关,我这里的开关量是系统需要的时候叠加在控制量上的一个变量。

      if(UKTemp>999)

      {

                UKTemp = 999;

      }

    //这里只所以是999封顶而不是1024是因为我的系统PWM的峰值电压是12V导致。

            while(1)                        //如果输出电压和期望电压相差 Delta,则继续调整占空比,直到在误差以内

            {

          ADChPro(UPWMADCH);          //测量输出电压

       if( ADPool.Value_Uint16[UPWMADCH] == UKTemp)

       {

                    return;

       }

       if( ADPool.Value_Uint16[UPWMADCH] > UKTemp)   //如果当前电压大于输出电压,减小占空比

       {

           if( ( ADPool.Value_Uint16[UPWMADCH] - UKTemp ) > UDELTA )

        {

            temp = ADPool.Value_Uint16[UPWMADCH] - UKTemp;  //

         temp = temp / 2;       //下降可以加速下降,所以下降参数加倍

         if( Pwm.DutyCycle_Uint8 > temp )

         {

                            Pwm.DutyCycle_Uint8 = Pwm.DutyCycle_Uint8 - temp;

         }

         else

         {

                            Pwm.DutyCycle_Uint8 = 0;

         }

        }

        else

        {

                        return;

        }

       }

       else           //如果当前电压小于输出电压

       {

           if( ( UKTemp - ADPool.Value_Uint16[UPWMADCH] ) > UDELTA )

        {

            temp = UKTemp - ADPool.Value_Uint16[UPWMADCH];

         temp = temp / 4;  //上升处理不要超调,所以每次只+一半

         if( (255-Pwm.DutyCycle_Uint8) > temp )

         {

                            Pwm.DutyCycle_Uint8 += (temp/2);

         }

         else

         {

                            Pwm.DutyCycle_Uint8 = 255;

         }

        }

        else

        {

                        return;

        }

       }

                DisPlayVoltage();

                PWMChangeDuty(Pwm.DutyCycle_Uint8);  //改变占空比

       Delay(10,10);

     

            }

     }

    }

    /*****************************************************/

     

     

    附录2

    直流电机PWM调速系统中控制电压非线性研究

    引言

        由于线性放大驱动方式效率和散热问题严重,目前绝大多数直流电动机采用开关驱动方式。开关驱动方式是半导体功率器件工作在开关状态,通过脉宽调制PWM控制电动机电枢电压,实现调速。目前已有许多文献介绍直流电机调速,宋卫国等用89C51单片机实现了直流电机闭环调速;张立勋等用AVR单片机实现了直流电机PWM调速;郭崇军等用C8051实现了无刷直流电机控制;张红娟等用PIC单片机实现了直流电机PWM调速;王晨阳等用DSP实现了无刷直流电机控制。上述文献对实现调速的硬件电路和软件流程的设计有较详细的描述,但没有说明具体的调压调速方法,也没有提及占空比与电机端电压平均值之间的关系。在李维军等基于单片机用软件实现直流电机PWM调速系统中提到平均速度与占空比并不是严格的线性关系,在一般的应用中,可以将其近似地看作线性关系。但没有做深入的研究。本文通过实验验证,在不带电机情况下,PWM波占空比与控制输出端电压平均值之间呈线性关系;在带电机情况下,占空比与电机端电压平均值满足抛物线方程,能取得精确的控制。本文的电机闭环调速是运用Matlab拟合的关系式通过PID控制算法实现。

    1 系统硬件设计

        本系统是基于TX-1C实验板上的AT89C52单片机,调速系统的硬件原理图如图1所示,主要由AT89C52单片机、555振荡电路、L298驱动电路、光电隔离、霍尔元件测速电路、MAX 232电平转换电路等组成。

     

    图1 闭环控制系统示意图

    2 系统软件设计

        系统采用模块化设计,软件由1个主程序,3个中断子程序,即外部中断0、外部中断1,定时器0子程序,PID算法子程序,测速子程序及发送数据到串口显示子程序组成,主程序流程图如图2所示。外部中断0通过比较直流电平与锯齿波信号产生PWM波,外部中断1用于对传感器的脉冲计数。定时器0用于对计数脉冲定时。测得的转速通过串口发送到上位机显示,通过PID模块调整转速到设定值。本实验采用M/T法测速,它是同时测量检测时间和在此检测时间内霍尔传感器所产生的转速脉冲信号的个数来确定转速。由外部中断1对霍尔传感器脉冲计数,同时起动定时器0,当计数个数到预定值2 000后,关定时器0,可得到计2 000个脉冲的计数时间,由式计算出转速:

    n=60f/K=60N/(KT) (1)

        式中:n为直流电机的转速;K为霍尔传感器转盘上磁钢数;f为脉冲频率;N为脉冲个数;T为采样周期。

     

    图2 主程序流程图

    3 实验结果及原因分析

        3.1 端电压平均值与转速关系

        3.1.1 实验结果

        实验用的是永磁稳速直流电机,型号是EG-530YD-2BH,额定转速2 000~4 000 r/min,额定电压12 V。电机在空载的情况下,测得的数据用Matlab做一次线性拟合,拟合的端电压平均值与转速关系曲线如图3(a)所示。相关系数R-square:0.952 1。拟合曲线方程为:

    y=0.001 852x+0.296 3 (2)

        由式(2)可知,端电压平均值与转速可近似为线性关系,根椐此关系式,在已测得的转速的情况下可以计算出当前电压。为了比较分析,同样用Matlab做二次线性拟合,拟合的端电压平均值与转速关系曲线如图3(b)所示。相关系数R-square:0.986 7。

     

    图3 端电压平均值与转速关系曲线图

    3.1.2 原因分析

        比较图3(a)可知,当转速在0~1 500 r/min和4 000~5 000 r/min,端电压平均值与转速间存在的非线性,用二次曲拟合如图3(b)所示,拟合相关系数较高。由图3(a)可见,当电机转速为0时电机两端电压平均值约为1.3 V。这是因为电机处于静止状态时,摩擦力为静摩擦力,静摩擦力是非线性的。随着外力的增加而增加,最大值发生在运动前的瞬间。电磁转矩为负载制动转矩和空载制动转矩之和,由于本系统不带负载,因此电磁转矩为空载制动转矩。空载制动转矩与转速之间此时是非线性的。电磁转矩与电流成正比,电流又与电压成正比,因此此时电压与转速之间是非线性的。

        当转速在2 000~4 000 r/min线性关系较好,占空比的微小改变带来的转速改变较大,因此具有较好的调速性能。这是因为随着运动速度的增加,摩擦力成线性的增加,此时的摩擦力为粘性摩擦力。粘性摩擦是线性的,与速度成正比,空载制动转矩与速度成正比,也即电磁转矩与电流成正比,电流又与电压成正比,因此此时电压与转速之间是线性的。当转速大于4 000 r/min。由于超出了额定转速所以线性度较差且调速性能较差。此时用二次曲线拟合结果较好,因为当电机高速旋转时,摩擦阻力小到可以忽略,此时主要受电机风阻型负荷的影响,当运动部件在气体或液体中运动时,其受到的摩擦阻力或摩擦阻力矩被称为风机型负荷。对同一物体,风阻系数一般为固定值。阻力大小与速度的平方成正比。即空载制动转矩与速度的平方成正比,也即电磁转矩与速度的平方成正比,电磁转矩与电流成正比,电流又与电压成正比,因此此时电压与转速之间是非线性的。

     3.2 占空比与端电压平均值关系

        3.2.1 实验结果

        拟合占空比与端电压平均值关系曲线如图4所示。相关系数R-square:0.998 4。拟合曲线方程为:

     

    图4 占空比与端电压平均值关系曲线图

        如图4所示,占空比与端电压平均值满足抛物线方程。运用积分分离的PID算法改变电机端电压平均值,可以运用此关系式改变占空比,从而实现了PWM调速。

        用示波器分别测出电压的顶端值Utop与底端值Ubase,端电压平均值Uarg满足关系式:

        其中:α为占空比。

        正是由于所测得的电机端电压底端值Ubase不为0,所以得出的占空比与端电压平均值之间关系曲线为抛物线。若将电机取下,直接测L298的out1与out2输出电压。所测得的电机端电压底端值Ubase约为0,所得的占空比与端电压平均值满足线性关系,即令式(4)中Ubase为0,式(4)变为:

     

        3.2.2 原因分析

        将电机取下后,直接测L298的输出端之间的电压,占空比与端电压平均值满足关系式(5),说明整个硬件电路的设计以及软件编程的正确性。从电机反电势角度分析,当直流电机旋转时,电枢导体切割气隙磁场,在电枢绕组中产生感应电动势。由于感应电动势方向与电流的方向相反,感应电动势也即反电势。直流电机的等效模型如图5所示。图5(a)表示电机工作在电动机状态。图5(b)表示电机工作在发电机状态。

     

    图5 直流电机等效电路

        如图5(a)所示,电压平衡方程为:

    式中:U为外加电压;Ia为电枢电流;Ra为电枢绕组电阻;2△Ub为一对电刷接触压降,一般取2△Ub为0.5~2 V;Ea为电枢绕组内的感应电动势。电机空载时,电枢电流可忽略不计,即电流Ia为0。空载时的磁场由主磁极的励磁磁动势单独作用产生。给电机外加12 V的额定电压,由(6)可得反电势:

     

        以40%的占空比为例,电机端电压Uab是测量中的电压平均值Uarg,其值为8.34 V,测量中的电压底端值Ubase约为7 V。由式(7)可得Ea的值范围应在6.34~7.84 V。由图5(b)可见,此时Uab的值是测得的底端值Ubase即电机的电动势Ea为7 V。

        当PWM工作在低电平状态,直流电机不会立刻停止,会继续旋转,电枢绕组切割气隙磁场,电机此时工作在发电机状态,产生感应电动势E。

     

        式中:Ce为电机电动势常数;φ为每级磁通量。由于电机空载,所以图5(b)中无法形成回路。用单片机仿真软件Proteus可直观的看出在PWM为低电平状态,电机处于减速状态。低电平持续时间越长,电机减速量越大。正是由于在低电平期间,电机处于减速状态,由式(8)可知,Ce,φ均为不变量,转速n的变化引起E的改变。此时Uab的值等于E的值。电机在低电平期间不断的减速,由于PWM周期较短,本文中取20 ms,电机在低电平期间转速还未减至0,PWM又变为高电平了。这样,就使测得的Ubase值不为0。以40%的占空比为例,当PWM工作在低电平状态,测得Ubase的值约为7 V。由式(8)可知,当正占空比越大,转速也就越大,同时减速时间越短,感应电势E的值越大。所以Ubase的值也就越大。

    4 结语

        重点分析了直流电机PWM调速过程中控制电压的非线性,对非线性的影响因素做了详细的分析。由于PWM在低电平期间电压的底端值不为0,导致了占空比与电机端电压平均值之间呈抛物线关系。因此,可用得出的抛物线关系式实现精确调速。本系统的非线性研究可为电机控制中非线性的进一步研究提供依据,在实际运用中,可用于移动机器人、飞行模拟机的精确控制。

     

     

    附录3

    隶属函数(membership function),用于表征模糊集合的数学工具。对于普通集合A,它可以理解为某个论域U上的一个子集。为了描述论域U中任一元素u是否属于集合A,通常可以用0或1标志。用0表示u不属于A,而用1表示属于A ,从而得到了U上的一个二值函数χA(u),它表征了U的元素u对普通集合的从属关系,通常称为A的特征函数,为了描述元素u对U上的一个模糊集合的隶属关系,由于这种关系的不分明性,它将用从区间[0,1]中所取的数值代替0,1这两值来描述,记为(u),数值(u)表示元素隶属于模糊集的程度,论域U上的函数μ即为模糊集的隶属函数,而(u)即为u对A的隶属度

    展开全文
  • 模糊PID控制C语言代码

    2021-01-14 16:34:12
    模糊PID控制C语言代码,codeblock工程

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,002
精华内容 17,600
关键字:

PID c语言