精华内容
下载资源
问答
  • 增量式PID

    2020-06-12 09:36:09
    这里写目录标题连续PID控制器离散式PID控制器位置式PID增量式PID 连续PID控制器 比例积分微分控制器,三个环节P(比例)、I(积分)、D(微分)通过线性组合,输入量为偏差信号e(t),输出为控制信号u(t)。 根据...

    连续PID控制器

    比例积分微分控制器,三个环节P(比例)、I(积分)、D(微分)通过线性组合,输入量为偏差信号e(t),输出为控制信号u(t)。
    根据系统输出y与期望输入r的偏差e,调控u使整个系统输出y趋近于r,增强系统的稳定性。
    在这里插入图片描述

    这是时域模式,因此进行拉普拉斯变换,获得复频域传递函数
    在这里插入图片描述
    kp-比例系数——提高系统的动态响应,对应于系统响应图的超调量以及调整时间;
    Ti 积分时间——Ki=1/Ti消除稳态误差,积分环节存在就会产生系统误差积累,调整Ti,是为了降低过大的误差积累;es=lim G(s)H(s)
    Td 微分时间——克服系统震荡,调小Kd,可以加快系统稳定性,降低超调量与响应速度,保证动态性能。
    (主要是调整Kp,Kd两个参数)
    在这里插入图片描述
    来源百科。

    离散式PID控制器

    位置式PID

    在数字化系统中,假设周期采样Fs,采样周期为T,离散自变量为n,则离散PID控制表达式4.1为:
    在这里插入图片描述
    式中,
    在这里插入图片描述

    增量式PID

    由位置式PID公式,通过递推公式,
    在这里插入图片描述
    使用增量型PID可以防止出现数据溢出的现象,保证了控制信号没有出现误差的累计,其只需确定最近两次的采样值,也就是偏差信号,所以通过加权处理,控制效果会更好一些。
    可以获得增量型PID表达式。

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    链接: MATLAB程序下载.

    数据结构核心原理与算法应用

    展开全文
  • 目录1 什么是增量式PID?2 举个例子2.1 位置式PID2.2 增量式PID3 伪算法4 C语言实现5 总结在之前一篇博客中(简易PID算法的快速扫盲)简单介绍了PID算法的基本原理和位置式算法的实现过程,由于部分推导过程已经在上一...

    824036744d9f7d808b761c4226a4f6af.png

    目录

    • 1 什么是增量式PID?

    • 2 举个例子

      • 2.1 位置式PID

      • 2.2 增量式PID

    • 3 伪算法

    • 4 C语言实现

    • 5 总结

    在之前一篇博客中( 简易PID算法的快速扫盲 )简单介绍了PID算法的基本原理位置式算法的实现过程,由于部分推导过程已经在上一篇文章做过介绍,所以推导过程本文不再赘述,重点将对离散增量式PID的算法进行实现。

    1 什么是增量式PID?

    先看一下增量式PID的离散公式如下:

    :比例系数:积分系数:微分系数:偏差

    对于所谓的位置式增量式的算法,这两者只是在算法的实现上的存在差异,本质的控制上对于系统控制的影响还是相同,单纯从输入和输出的角度来比较,具体如下表所示;

    069e88db88f559498076d3f689f587e3.png

    这里简单的说明一下;

    • 位置式:位置式算法较为简单,直接输入当前的偏差 ,即可得到输出
    • 增量式:增量式算法需要保存历史偏差,,即在第次控制周期时,需要使用第和第次控制所输入的偏差,最终计算得到 ,此时,这还不是我们所需要的PID输出量;所以需要进行累加;

    不难发现第一次控制周期时,即时;

    由以上公式我们可以推导出下式;

    所以可以看出,最终PID的输出量,满足以下公式;

    可见增量式算法,就是所计算出的PID增量的历史累加和;

    e890e2470fe3150d3c1d624130af1167.png

    2 举个例子

    2.1 位置式PID

    下面从一个简单的例子中去理解一下增量式PID,这里依然举一个不是很恰当的例子;如果是位置式PID算法的话:

    • 隆哥对一个直流电机进行调速,设定了转速为 1000
    • 这时由于反馈回来的速度和设定的速度偏差为 
    • 经过位置式PID计算得到
    • 作为Process的输入值(可以是PWM的占空比),最终Process输出相应的PWM驱动直流电机;
    • 反馈装置检测到电机转速,然后重复以上步骤;

    整体框图如下所示;8d46f3dc114bc0ca83d265af4ecec72b.png

    2.2 增量式PID

    对于增量式PID来说;

    • 隆哥对一个直流电机进行调速,设定了转速为 1000
    • 这时由于反馈回来的速度和设定的速度偏差为 ,系统中保存上一次的偏差和上上次的偏差,这三个输入量经过增量PID计算得到
    • 系统中还保存了上一次的PID输出,所以加上增量,就是本次控制周期的PID输出——
    • 作为Process的输入值(可以是PWM的占空比),最终Process输出相应的PWM驱动直流电机;
    • 反馈装置检测到电机转速,然后重复以上步骤;

    整体框图如下所示;

    04d71903154539b5e52839f51bcb1571.png

    所以这里不难发现,所谓增量式PID,它的特点有:

    • 需要输入历史的偏差值;
    • 计算得到的是PID输出增量,因此每一次需要累加历史增量最为当前的PID输出;

    下面简单介绍一下如何实现增量式PID算法;

    3 伪算法

    previous02_error := 0  //上上次偏差
    previous01_error := 0  //上一次偏差
    integral := 0   //积分和
    pid_out := 0   //pid增量累加和
    //循环 
    //采样周期为dt
    loop:
     //setpoint 设定值
     //measured_value 反馈值
        error := setpoint − measured_value //计算得到偏差
        proportion := error - previous01_error //计算得到比例输出
        integral := error × dt //计算得到积分累加和
        derivative := (error − 2*previous01_error + previous02_error) / dt //计算得到微分
        pid_delta := Kp × error + Ki × integral + Kd × derivative //计算得到PID增量
        pid_out := pid_out + pid_delta //计算得到PID输出

        //保存当前的偏差和上一次偏差作为下一次采样所需要的历史偏差
        previous02_error := previous01_error 
        previous01_error := error    //保存当前偏差为下一次采样时所需要的历史偏差
        wait(dt) //等待下一次采用
        goto loop

    4 C语言实现

    这里直接使用了TI公司的PID算法,做了积分抗饱和;具体可以参考controlSUITE\libs\app_libs\motor_control\math_blocks\v4.2\pid_grando.h

    具体代码如下所示;

    pid_grando.h

    /* =================================================================================
    File name:       PID_GRANDO.H 
    ===================================================================================*/



    #ifndef __PID_H__
    #define __PID_H__

    typedef struct {  _iq  Ref;      // Input: reference set-point
          _iq  Fbk;      // Input: feedback
          _iq  Out;      // Output: controller output 
          _iq  c1;      // Internal: derivative filter coefficient 1
          _iq  c2;      // Internal: derivative filter coefficient 2
        } PID_TERMINALS;
        // note: c1 & c2 placed here to keep structure size under 8 words

    typedef struct {  _iq  Kr;    // Parameter: reference set-point weighting 
          _iq  Kp;    // Parameter: proportional loop gain
          _iq  Ki;       // Parameter: integral gain
          _iq  Kd;           // Parameter: derivative gain
          _iq  Km;           // Parameter: derivative weighting
          _iq  Umax;   // Parameter: upper saturation limit
          _iq  Umin;   // Parameter: lower saturation limit
        } PID_PARAMETERS;

    typedef struct {  _iq  up;    // Data: proportional term
          _iq  ui;    // Data: integral term
          _iq  ud;    // Data: derivative term
          _iq  v1;    // Data: pre-saturated controller output
          _iq  i1;    // Data: integrator storage: ui(k-1)
          _iq  d1;    // Data: differentiator storage: ud(k-1)
          _iq  d2;    // Data: differentiator storage: d2(k-1) 
          _iq  w1;    // Data: saturation record: [u(k-1) - v(k-1)]
        } PID_DATA;


    typedef struct {  PID_TERMINALS term;
          PID_PARAMETERS param;
          PID_DATA  data;
        } PID_CONTROLLER;

    /*-----------------------------------------------------------------------------
    Default initalisation values for the PID objects
    -----------------------------------------------------------------------------*/
                         

    #define PID_TERM_DEFAULTS {    \                  0,  \
                               0,  \
                               0,  \
                               0,  \                  0   \
                       }


    #define PID_PARAM_DEFAULTS {    \
                               _IQ(1.0), \
                               _IQ(1.0), \
                               _IQ(0.0), \
                               _IQ(0.0), \
                               _IQ(1.0), \
                               _IQ(1.0), \
                               _IQ(-1.0) \
                       }


    #define PID_DATA_DEFAULTS {        \
                               _IQ(0.0), \
                               _IQ(0.0), \
                               _IQ(0.0), \
                               _IQ(0.0), \
                               _IQ(0.0), \
                               _IQ(0.0), \
                               _IQ(0.0), \
                               _IQ(1.0)  \
                       }



    /*------------------------------------------------------------------------------
      PID Macro Definition
    ------------------------------------------------------------------------------*/


    #define PID_MACRO(v)                                         \                                                             \/* proportional term */                                         \
    v.data.up = _IQmpy(v.param.Kr, v.term.Ref) - v.term.Fbk;  \                                              \/* integral term */                                          \
    v.data.ui = _IQmpy(v.param.Ki, _IQmpy(v.data.w1,                  \
    (v.term.Ref - v.term.Fbk))) + v.data.i1;                     \
    v.data.i1 = v.data.ui;                                         \                                              \/* derivative term */                                          \
    v.data.d2 = _IQmpy(v.param.Kd, _IQmpy(v.term.c1,                  \
    (_IQmpy(v.term.Ref, v.param.Km) - v.term.Fbk))) - v.data.d2; \
    v.data.ud = v.data.d2 + v.data.d1;                       \
    v.data.d1 = _IQmpy(v.data.ud, v.term.c2);                     \                                              \/* control output */                                          \
    v.data.v1 = _IQmpy(v.param.Kp,                                    \
    (v.data.up + v.data.ui + v.data.ud));                             \
    v.term.Out= _IQsat(v.data.v1, v.param.Umax, v.param.Umin);        \
    v.data.w1 = (v.term.Out == v.data.v1) ? _IQ(1.0) : _IQ(0.0);      \

    #endif // __PID_H__



    example

    /* Instance the PID module */ 
     
    PID   pid1={ PID_TERM_DEFAULTS, PID_PARAM_DEFAULTS, PID_DATA_DEFAULTS }; 
     
    main() { 
     
        pid1.param.Kp = _IQ(0.5);     
        pid1.param.Ki  = _IQ(0.005);    
        pid1.param.Kd = _IQ(0);      
        pid1.param.Kr  = _IQ(1.0);     
        pid1.param.Km =_IQ(1.0);     
        pid1.param.Umax= _IQ(1.0);      
        pid1.param.Umin= _IQ(-1.0); 
     

     
    void interrupt periodic_interrupt_isr() {  

        pid1.Ref = input1_1;   // Pass _iq inputs to pid1 
        pid1.Fbk = input1_2;   // Pass _iq inputs to pid1   
        PID_MACRO(pid1);  // Call compute macro for pid1        
        output1 = pid1.Out;  // Access the output of pid1     
    }
     

    5 总结

    本文简单总结了位置式PID算法增量式PID算法的差异,参考了TI公司的增量式PID算法实现,对于不同的控制对象可以根据系统要求选择合适的PID算法

    由于作者能力和水平有限,文中难免存在错误和纰漏,请不吝赐教。

    精彩回顾

    ● STC单片机自动下载电路● 简易PID算法的快速扫盲

    ● 你会51单片机的精确延时吗?

    ● 原来SPI并没有我想的那么简单

    ● 什么是状态机?用C语言实现进程5状态模型

    ●精彩好文:CPU 到底是怎么识别代码的?

    展开全文
  • 目录1 什么是增量式PID?2 举个例子2.1 位置式PID2.2 增量式PID3 伪算法4 C语言实现5 总结在之前一篇博客中(简易PID算法的快速扫盲)简单介绍了PID算法的基本原理和位置式算法的实现过程,由于部分推导过程已经在上一...

    目录

    • 1 什么是增量式PID?

    • 2 举个例子

      • 2.1 位置式PID

      • 2.2 增量式PID

    • 3 伪算法

    • 4 C语言实现

    • 5 总结

    在之前一篇博客中( 简易PID算法的快速扫盲 )简单介绍了PID算法的基本原理位置式算法的实现过程,由于部分推导过程已经在上一篇文章做过介绍,所以推导过程本文不再赘述,重点将对离散增量式PID的算法进行实现。

    1 什么是增量式PID?

    先看一下增量式PID的离散公式如下:
    :比例系数:积分系数:微分系数:偏差
    对于所谓的位置式增量式的算法,这两者只是在算法的实现上的存在差异,本质的控制上对于系统控制的影响还是相同,单纯从输入和输出的角度来比较,具体如下表所示;985094abd02cd3ddf76d0637c5cf96f7.png这里简单的说明一下;
    • 位置式:位置式算法较为简单,直接输入当前的偏差 ,即可得到输出
    • 增量式:增量式算法需要保存历史偏差,,即在第次控制周期时,需要使用第和第次控制所输入的偏差,最终计算得到 ,此时,这还不是我们所需要的PID输出量;所以需要进行累加;
    不难发现第一次控制周期时,即时;由以上公式我们可以推导出下式;所以可以看出,最终PID的输出量,满足以下公式;可见增量式算法,就是所计算出的PID增量的历史累加和;
    f84483893cdb8e2a39ca3dbfe95f71c0.png

    2 举个例子

    2.1 位置式PID

    下面从一个简单的例子中去理解一下增量式PID,这里依然举一个不是很恰当的例子;如果是位置式PID算法的话:
    • 隆哥对一个直流电机进行调速,设定了转速为 1000
    • 这时由于反馈回来的速度和设定的速度偏差为
    • 经过位置式PID计算得到
    • 作为Process的输入值(可以是PWM的占空比),最终Process输出相应的PWM驱动直流电机;
    • 反馈装置检测到电机转速,然后重复以上步骤;
    整体框图如下所示;

    84d6f088df4c9f6d9831713d879bd34c.png

    2.2 增量式PID

    对于增量式PID来说;
    • 隆哥对一个直流电机进行调速,设定了转速为 1000
    • 这时由于反馈回来的速度和设定的速度偏差为 ,系统中保存上一次的偏差和上上次的偏差,这三个输入量经过增量PID计算得到
    • 系统中还保存了上一次的PID输出,所以加上增量,就是本次控制周期的PID输出——
    • 作为Process的输入值(可以是PWM的占空比),最终Process输出相应的PWM驱动直流电机;
    • 反馈装置检测到电机转速,然后重复以上步骤;
    整体框图如下所示;
    e9bbf008b907dbab0b2c40940d9ff832.png
    所以这里不难发现,所谓增量式PID,它的特点有:
    • 需要输入历史的偏差值;
    • 计算得到的是PID输出增量,因此每一次需要累加历史增量最为当前的PID输出;
    下面简单介绍一下如何实现增量式PID算法;

    3 伪算法

    previous02_error := 0  //上上次偏差
    previous01_error := 0  //上一次偏差
    integral := 0   //积分和
    pid_out := 0   //pid增量累加和//循环 //采样周期为dt
    loop://setpoint 设定值//measured_value 反馈值
        error := setpoint − measured_value //计算得到偏差
        proportion := error - previous01_error //计算得到比例输出
        integral := error × dt //计算得到积分累加和
        derivative := (error − 2*previous01_error + previous02_error) / dt //计算得到微分
        pid_delta := Kp × error + Ki × integral + Kd × derivative //计算得到PID增量
        pid_out := pid_out + pid_delta //计算得到PID输出//保存当前的偏差和上一次偏差作为下一次采样所需要的历史偏差
        previous02_error := previous01_error 
        previous01_error := error    //保存当前偏差为下一次采样时所需要的历史偏差
        wait(dt) //等待下一次采用goto loop

    4 C语言实现

    这里直接使用了TI公司的PID算法,做了积分抗饱和;具体可以参考controlSUITE\libs\app_libs\motor_control\math_blocks\v4.2\pid_grando.h具体代码如下所示;pid_grando.h
    /* =================================================================================
    File name:       PID_GRANDO.H 
    ===================================================================================*/
    #ifndef __PID_H__#define __PID_H__typedef struct {  _iq  Ref;      // Input: reference set-point
          _iq  Fbk;      // Input: feedback
          _iq  Out;      // Output: controller output 
          _iq  c1;      // Internal: derivative filter coefficient 1
          _iq  c2;      // Internal: derivative filter coefficient 2
        } PID_TERMINALS;// note: c1 & c2 placed here to keep structure size under 8 wordstypedef struct {  _iq  Kr;    // Parameter: reference set-point weighting 
          _iq  Kp;    // Parameter: proportional loop gain
          _iq  Ki;       // Parameter: integral gain
          _iq  Kd;           // Parameter: derivative gain
          _iq  Km;           // Parameter: derivative weighting
          _iq  Umax;   // Parameter: upper saturation limit
          _iq  Umin;   // Parameter: lower saturation limit
        } PID_PARAMETERS;typedef struct {  _iq  up;    // Data: proportional term
          _iq  ui;    // Data: integral term
          _iq  ud;    // Data: derivative term
          _iq  v1;    // Data: pre-saturated controller output
          _iq  i1;    // Data: integrator storage: ui(k-1)
          _iq  d1;    // Data: differentiator storage: ud(k-1)
          _iq  d2;    // Data: differentiator storage: d2(k-1) 
          _iq  w1;    // Data: saturation record: [u(k-1) - v(k-1)]
        } PID_DATA;typedef struct {  PID_TERMINALS term;
          PID_PARAMETERS param;
          PID_DATA  data;
        } PID_CONTROLLER;/*-----------------------------------------------------------------------------
    Default initalisation values for the PID objects
    -----------------------------------------------------------------------------*/
                         #define PID_TERM_DEFAULTS {    \                  0,  \
                               0,  \
                               0,  \
                               0,  \                  0   \
                       }
    #define PID_PARAM_DEFAULTS {    \
                               _IQ(1.0), \
                               _IQ(1.0), \
                               _IQ(0.0), \
                               _IQ(0.0), \
                               _IQ(1.0), \
                               _IQ(1.0), \
                               _IQ(-1.0) \
                       }
    #define PID_DATA_DEFAULTS {        \
                               _IQ(0.0), \
                               _IQ(0.0), \
                               _IQ(0.0), \
                               _IQ(0.0), \
                               _IQ(0.0), \
                               _IQ(0.0), \
                               _IQ(0.0), \
                               _IQ(1.0)  \
                       }
    /*------------------------------------------------------------------------------
      PID Macro Definition
    ------------------------------------------------------------------------------*/
    #define PID_MACRO(v)                                         \                                                             \/* proportional term */                                         \
    v.data.up = _IQmpy(v.param.Kr, v.term.Ref) - v.term.Fbk;  \                                              \/* integral term */                                          \
    v.data.ui = _IQmpy(v.param.Ki, _IQmpy(v.data.w1,                  \
    (v.term.Ref - v.term.Fbk))) + v.data.i1;                     \
    v.data.i1 = v.data.ui;                                         \                                              \/* derivative term */                                          \
    v.data.d2 = _IQmpy(v.param.Kd, _IQmpy(v.term.c1,                  \
    (_IQmpy(v.term.Ref, v.param.Km) - v.term.Fbk))) - v.data.d2; \
    v.data.ud = v.data.d2 + v.data.d1;                       \
    v.data.d1 = _IQmpy(v.data.ud, v.term.c2);                     \                                              \/* control output */                                          \
    v.data.v1 = _IQmpy(v.param.Kp,                                    \
    (v.data.up + v.data.ui + v.data.ud));                             \
    v.term.Out= _IQsat(v.data.v1, v.param.Umax, v.param.Umin);        \
    v.data.w1 = (v.term.Out == v.data.v1) ? _IQ(1.0) : _IQ(0.0);      \
    #endif // __PID_H__
    example
    /* Instance the PID module */ 
    PID   pid1={ PID_TERM_DEFAULTS, PID_PARAM_DEFAULTS, PID_DATA_DEFAULTS }; 
    main() { 
        pid1.param.Kp = _IQ(0.5);     
        pid1.param.Ki  = _IQ(0.005);    
        pid1.param.Kd = _IQ(0);      
        pid1.param.Kr  = _IQ(1.0);     
        pid1.param.Km =_IQ(1.0);     
        pid1.param.Umax= _IQ(1.0);      
        pid1.param.Umin= _IQ(-1.0); 
    void interrupt periodic_interrupt_isr() {  
        pid1.Ref = input1_1;   // Pass _iq inputs to pid1 
        pid1.Fbk = input1_2;   // Pass _iq inputs to pid1   
        PID_MACRO(pid1);  // Call compute macro for pid1        
        output1 = pid1.Out;  // Access the output of pid1     
    }

    5 总结

    本文简单总结了位置式PID算法增量式PID算法的差异,参考了TI公司的增量式PID算法实现,对于不同的控制对象可以根据系统要求选择合适的PID算法-END-

    往期好文合集

    PID到底是个啥?来给你讲个故事再论PID,PID其实很简单。。。电子设计竞赛(4)-常用的两种PID算法

      最 后   

    若觉得文章不错,转发分享,也是我们继续更新的动力。5T资源大放送!包括但不限于:C/C++,Linux,Python,Java,PHP,人工智能,PCB、FPGA、DSP、labview、单片机、等等在公众号内回复「更多资源」,即可免费获取,期待你的关注~53ae78c699c9feb574654ae0b2cc1922.png20c503c8a668a15fc19074292c222e9a.gif
    展开全文
  • PID控制系统原理图二、PID控制算法大致分为增量式PID和位置式PID。1.位置式PID:输出控制的值u(k)当前误差,过去累计误差,当前误差与上次误差的和相加。直接输出控制值。位置式公式2.增量式PID:由公式可以看出,输出...
    少年不识愁滋味,爱上层楼。爱上层楼,为赋新词强说愁。而今识尽愁滋味,欲说还休。欲说还休,却道天凉好个秋。

    一、开局一张图,剩下全靠编。

    449d4a5b2020b7806730aa8949b7b40b.png

    PID控制系统原理图

    二、PID控制算法大致分为增量式PID和位置式PID。

    1.位置式PID:输出制的值u(k)当前误差,过去累计误差,当前误差与上次误差的和相加。直接输出控制值。

    323f4255c0567f03e128f8ceabf15b64.png

    位置式公式

    2.增量式PID:由公式可以看出,输出值只与前三次误差有关系。输出值u(k)需要进行累加。

    b8dc50996755d4728317916df6b945af.png

    增量式公式

    3.我这里使用到的是增量式PID,下图是PID调节理想状态下的模型。结合前面所提到的文章“一种提高ADC精度的方法”,用生成的多项式来修正ADC转换出来的结果,再加上PID调节,可以提高设备的精度和响应速度。

     6ba65e817b3dea072b9b39724ca8186e.gif

    理想状态下模型

     二、参数的调节

    PID系数的确定更多是依靠调试的经验和实际的情况,最终快速,稳定,准确的达到目标值。难点在于调节速度和稳定,速度提高会导致系统震荡、过冲,系统过于稳定会导致调节速度过慢,所以需要取合适的参数来平衡。在实际系统中还会遇到实际的问题,比如:过冲,系统惯性,系统延迟,反馈时间,这些都是根据设备的不同而不同,需要根据具体的实际情况调节。调试的方法具体分为三步。

    1.先调节比例系数P,将I=0,D=0;先将P取一个较大的值,然后慢慢减小,直到系统的震荡减小。设定的调节目标值需要小于系统的最大阀值。

    2.调节积分时间常数I,比例系数P参数确定后,调节I的方法与P相似,调至系统不震荡为止。3.调节微分时间常数D,P和I确定之后,最后来调节D,方法与上面一样,调节至系统不震荡为止。

    三、实际案例

    最后贴出部分源代码
    void power_pid(void)        /*xiaoyang,增量式PID*/{    static float dac_channe11_value=600;    static float power_error,power_last_error,power_previous_error;     /*本次误差,上次误差,上上次误差*/    if(RF & Power && ready)    {        power_error = Pset - PowerOut;        dac_channe11_value += 0.002f*(power_error-power_last_error)                              +0.030f*power_error                              +0.004f*(power_error-2*power_last_error+power_previous_error);        power_previous_error = power_last_error;        /*上次误差存入上上次误差*/        power_last_error = power_error;         /*本次误差存入上次误差*/        if(dac_channe11_value > 4000)            dac_channe11_value = 4000;                DAC_SetChannel2Data(DAC_Align_12b_R,dac_channe11_value);         /*硬件采用两级放大,这是使用两级共同放大*/        DAC_SetChannel1Data(DAC_Align_12b_R,dac_channe11_value);    }    else    {        dac_channe11_value=600;        power_error=0, power_last_error=0,power_previous_error=0;        DAC_SetChannel2Data(DAC_Align_12b_R,dac_channe11_value);        DAC_SetChannel1Data(DAC_Align_12b_R,dac_channe11_value);    }}

    算法代码

    从输出功率波形上来看,输出功率在短时间内得到了上升,在达到了设定功率后,稳定没有跳变或变化很小,误差范围控制在0.5%。

    337ff1bc21e4999d6955d155fa5bbbdb.png

    功率输出波形

    从实际的输出功率与设定的输出功率可以看出,设定值为6000W,实际输出功率为5999W。

    9ecc8f15acca4b3a5f026b5138dd8f30.png

    功率设置

    展开全文
  • 增量式pid.rar

    2020-09-10 11:44:25
    项目需要最近在做pid控制器,看了一些文章,写了一个增量式pid算法。适合新手学习原理。代码注释很多。
  • 增量式PID的算法

    2020-07-30 22:22:49
    最近做一个压力控制的设备需要用到PID算法,在网上找到一个增量式PID算法,注释比较详细,通俗易懂,但是有错漏。其实照着公式来写是没有什么问题的,下面给出修改后的代码。
  • 位置式PID与增量式PID区别浅析

    万次阅读 多人点赞 2019-04-26 08:55:12
    1PID控制算法 什么是PID PID 控制器以各种形式使用超过了 1 世纪,广泛应用在机械设备、气动设备 和电子设备.在工业应用中PID及其衍生算法是应用最广泛的算法之一,是当之无愧的万能算法 PID 实指“比例 ...
  • stm32增量式PID.rar

    2020-08-04 09:21:56
    stm32f103增量式PID代码,通过adc对电压采样后,stm32进行增量式PID调节,最终使输出电压达到期望值
  • 增量式PIDsimulink程序

    2018-09-11 16:22:04
    增量式PID控制器仿真程序,使用simulink仿真,MATLAB版本2014a
  • 这里个大家分享了一个增量式PID控制C语言的源代码。
  • 增量式PID和位置式PID算法实现和PID库(51单片机+STM32+arduino)
  • 增量式PID控制算法.doc

    2020-07-26 19:49:46
    增量式PID算法 原理及实现方法 物理模型 软件算法流程图流程图 增量式PID算法的优点,对声音信标麦克纳姆轮pid的代码 写法有帮助,里面还有一个连接,附带代码,可以参考。搜集全网最实用资料。
  • 目录1 什么是增量式PID?2 举个例子2.1 位置式PID2.2 增量式PID3 伪算法4 C语言实现5 总结在之前一篇博客中(简易PID算法的快速扫盲)简单介绍了PID算法的基本原理和位置式算法的实现过程,由于部分推导过程已经在上一...
  • 增量式PID算法

    2011-11-01 11:28:40
    增量式PID算法,自己查阅资料,总结了增量式PID算法的模型内容等资料
  • 位置式pid和增量式pid

    热门讨论 2011-03-03 11:04:19
    内含位置式pid和增量式pid 两种控制算法实例,在simulink环境下的模型。并对各种算法性能进行了比较
  • Matlab增量式PID算法仿真 ,包含m文件和simulink仿真文件,希望对大家有帮助
  • 增量式PID控制

    千次阅读 2018-02-12 13:16:38
    增量式PID控制,数字PID控制算法的一种基本形式,是通过对控制量的增量(本次控制量和上次控制量的差值)进行PID控制的一种控制算法。中文名增量式PID控制外文名Increment PID Control基本概念对控制量的增量进行PID...
  • 位置式PID和增量式PID的区分

    千次阅读 2018-01-26 11:36:42
    位置式PID和增量式PID的区分 位置式PID: 增量式PID: 附上本人参考别人写的代码 位置式PID和增量式PID的区分 仅是个人理解,如有错误请指出。 位置式PID: 当前的输出与过去的所有状态都有关系(积分累加也...
  • 增量式PID的MATLAB实现,实现华北电力大学课程设计-增量式PID的MATLAB实现.是火电厂热工自动控制的课程设计,供大家参考
  • 增量式PID算法的MATLAB实现

    千次阅读 热门讨论 2019-06-22 13:27:19
    增量式PID的MATLAB实现PID控制的分类连续PID控制离散PID控制位置式PID控制增量式PID控制位置式PID与增量式PID的比较离散PID控制的MATLAB实现实现增量式PID算法绘制GUI界面,实时更改给定值 PID控制的分类 连续PID控制...
  • 增量式PID控制算法

    2019-08-22 13:00:37
    增量式PID控制算法是指其输出只是被控制量的增量Uk。当执行机构需要的控制量是增量时而不是位置量的绝对值时,例如步进电机等,都使用增量式控制算法。 增量式PID控制算法可通过全量式推导出来,由全量式得到U(k)...
  • matlab数字增量式pid简单程序,适合对PID不是很熟悉的人
  • 增量式PID的matlab实现,是simulinks仿真实现,网上的一般为位置式的PID,增量式PID的simulinks仿真我自己也找了很久,最终自己做了一个能用的
  • 增量式PID和位置式PID控制算法及各自的离散表达式及两者算法的区别。
  • 描述了位置式PID控制与增量式PID控制的比较,根据比较结果,增量式PID控制较适合于执行机构带积分部件的对象,如步进电机,充电机等
  • C语言实现PID算法:位置式PID和增量式PID

    万次阅读 多人点赞 2018-06-26 11:00:30
    大学参加过电子竞赛的朋友都应该玩过电机(或者说循迹小车),我们要控制电机按照设定的速度运转,PID控制在其中起到了关键的作用。 说来惭愧,大学这门课程学的不咋滴,老师讲的课基本没听进去过。直到后面接触...
  • 位置式与增量式PID

    2019-10-03 19:36:36
    位置式与增量式PID 转载自 https://blog.csdn.net/u014453443/article/details/100573722 感谢 大佬(苏守坤)
  • 增量式PID控制算法C51程序

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 678
精华内容 271
关键字:

增量式pid