精华内容
下载资源
问答
  • Pid控制算法-位置型pid算法的C++实现

    千次阅读 2017-04-10 11:35:11
    PID控制算法的C++语言实现 三 位置型PID的C++语言实现 上一节中已经抽象出了位置性PID和增量PID的数学表达式,这一节,重点讲解C++代码的实现过程,算法的C++实现过程具有一般性,通过PID算法的C++实现,可以...

    PID控制算法的C++语言实现

    三 位置型PID的C++语言实现

    上一节中已经抽象出了位置性PID和增量型PID的数学表达式,这一节,重点讲解C++代码的实现过程,算法的C++实现过程具有一般性,通过PID算法的C++实现,可以以此类推,设计其它算法的C++实现。

       第一步:定义PID变量结构体,代码如下:

    typedef struct _pid{
        float SetSpeed;        //定义设定值
        float ActualSpeed;       //定义实际值
        float err;           //定义偏差值
        float err_last;         //定义上一个偏差值
        float Kp,Ki,Kd;         //定义比例、积分、微分系数
        float voltage;         //定义电压值(控制执行器的变量)
        float integral;         //定义积分值
    }pid;

    控制算法中所需要用到的参数在一个结构体中统一定义,方便后面的使用。

       第二步:定义一个类:代码如下:

    class Pid_control

    {

    public:

     

    void PID_init();

    float PID_realize(float speed);

     

    private:

    int index;

    Pid pid;

    };

        第三步:初始化变量,代码如下:

    void  Pid_control :: 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_control :: 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的基本实现部分就初步完成了。下面是测试代码:

    #include "pid.h"

    #include <iostream>

    using namespace std;

    int main()

    {

    Pid_control Pid;

    Pid.PID_init();

    int count = 0;

    while (count<1000)

    {

    float speed = Pid.PID_realize(200.0);

    cout << speed << ";" << " ";

    count++;

    }

    cout << endl;

    system("pause");

    return 0;

    }

     

    下面是代码运行结果:


     

     

    展开全文
  • 位置式PID控制算法

    千次阅读 2019-04-23 09:54:57
    位置式PID控制算法
                    刚好前不久搞过PID,部分程序如下,仅供参考

    /*==============================================================================
    在使用单片机作为控制cpu时,请稍作简化,具体的PID参数必须由具体对象通过实验确定。
    由于单片机的处理速度和ram资源的限制,一般不采用浮点数运算,而将所有参数全部用整数,
    运算到最后再除以一个2的N次方数据(相当于移位),作类似定点数运算,可大大提高运算速度,
    根据控制精度的不同要求,当精度要求很高时,注意保留移位引起的“余数”,做好余数补偿。
    这个程序只是一般常用pid算法的基本架构,没有包含输入输出处理部分。
    ==============================================================================*/

    #include <string.h>
    #include <stdio.h>


    /*===============================================================================
    PID Function
    The PID function is used in mainly
    control applications. PID Calc performs one iteration of the PID
    algorithm.
    While the PID function works, main is just a dummy program showing
    a typical usage.

    PID功能
    在PID功能主要用于控制应用。 PID 计算器执行一个PID的迭代算法。虽然PID功能的工程,
    主要只是一个虚拟程序显示一个典型的使用。
    ================================================================================*/
    typedef struct PID {
    double SetPoint; // 设定目标 Desired Value
    double Proportion; // 比例常数 Proportional Const
    double Integral; // 积分常数 Integral Const
    double Derivative; // 微分常数 Derivative Const
    double LastError; // Error[-1]
    double PrevError; // Error[-2]
    double SumError; // Sums of Errors
    } PID;


    /*================================ PID计算部分===============================*/
    double PIDCalc( PID *pp, double NextPoint )
    {
    double dError, Error;

    Error = pp->SetPoint - NextPoint; // 偏差
    pp->SumError += Error; // 积分
    dError = pp->LastError - pp->PrevError; // 当前微分
    pp->PrevError = pp->LastError;
    pp->LastError = Error;
    return (pp->Proportion * Error // 比例项
    + pp->Integral * pp->SumError // 积分项
    + pp->Derivative * dError // 微分项
    );
    }

    /*======================= 初始化的PID结构 Initialize PID Structure===========================*/
    void PIDInit (PID *pp)
    {
    memset ( pp,0,sizeof(PID));
    }


    /*======================= 主程序 Main Program=======================================*/
    double sensor (void) // 虚拟传感器功能 Dummy Sensor Function{ return 100.0;}
    void actuator(double rDelta) // 虚拟驱动器功能 Dummy Actuator Function{}
    void main(void)
    {
    PID sPID; // PID控制结构 PID Control Structure
    double rOut; // PID响应(输出) PID Response (Output)
    double rIn; // PID反馈(输入) PID Feedback (Input)
    PIDInit ( &sPID ); // 初始化结构 Initialize Structure
    sPID.Proportion = 0.5; // 设置PID系数 Set PID Coefficients
    sPID.Integral = 0.5;
    sPID.Derivative = 0.0;
    sPID.SetPoint = 100.0; // 设置PID设定 Set PID Setpoint
    for (;;)
    { // 模拟最多的PID处理 Mock Up of PID Processing
    rIn = sensor (); // 读取输入 Read Input
    rOut = PIDCalc ( &sPID,rIn ); // 执行的PID迭代 Perform PID Interation
    actuator ( rOut ); // 所需的更改的影响 Effect Needed Changes
               
    展开全文
  • 前文对PID算法离散化和增量式PID算法原理进行来探索,之后又使用Matlab进行了仿真实验,对PID三个参数又有了更深入的认识,接下来我们来使用C语言进行PID算法实现,并且结合控制电机的项目来深入学习。 1、PID ...

    前文对PID算法离散化和增量式PID算法原理进行来探索,之后又使用Matlab进行了仿真实验,对PID三个参数又有了更深入的认识,接下来我们来使用C语言进行PID算法实现,并且结合控制电机的项目来深入学习。

    1、PID 算法C 语言原代码

    先贴上一种常见的比较通用的C语言增量式PID算法吧

    typedef struct PID
    {
    intSetPoint; //设定目标 DesiredValue
    longSumError; //误差累计
    doubleProportion; //比例常数Proportional Const
    doubleIntegral; //积分常数 IntegralConst
    doubleDerivative; //微分常数Derivative Const
    intLastError; //Error[-1]
    intPrevError; //Error[-2]
    } PID;
    static PID sPID;
    static PID *sptr = &sPID;
    /
    *=============================================================
    =======
    InitializePID Structure PID 参数初始化
    =============================================================
    ======*/
    void IncPIDInit(void)
    {
    sptr->SumError= 0;
    sptr->LastError= 0; //Error[-1]
    sptr->PrevError= 0; //Error[-2]
    sptr->Proportion= 0; //比例常数Proportional Const
    sptr->Integral= 0; //积分常数IntegralConst
    sptr->Derivative= 0; //微分常数Derivative Const
    sptr->SetPoint= 0;
    }
    
    /
    *=============================================================
    ======= 增量式PID 计算部分
    =============================================================
    =======*/
    int IncPIDCalc(int NextPoint)
    {
    registerint iError, iIncpid; //当前误差
    iError= sptr->SetPoint - NextPoint; //增量计算
    iIncpid= sptr->Proportion * iError //E[k]项
            -sptr->Integral * sptr->LastError //E[k-1]项                     
            +sptr->Derivative * sptr->PrevError; //E[k-2]项
    
    //存储误差,用于下次计算
    sptr->PrevError= sptr->LastError;
    sptr->LastError= iError;
    //返回增量值
    return(iIncpid);
    }

    2、PID 整定口诀

                        参数整定找最佳, 从小到大顺序查。
                        先是比例后积分, 最后再把微分加。
                        曲线振荡很频繁, 比例度盘要放大。
                        曲线漂浮绕大弯, 比例度盘往小扳。
                        曲线偏离回复慢, 积分时间往下降。
                        曲线波动周期长, 积分时间再加长。
                        曲线振荡频率快, 先把微分降下来。
                        动差大来波动慢, 微分时间应加长。
                        理想曲线两个波, 前高后低四比一。
                        一看二调多分析, 调节质量不会低。
    

    说实话整定口诀对于初学者来说,其实根本就看不懂,只有从实际整定过程中才能慢慢发觉其中的奥秘。

    3、项目原理

    学到这里对PID算法的理解只是停留在理论,那么我们来结合实际看看,这里我参考的是平衡小车之家的资料,不得不说确实浅显易懂,先从电机的简单控制开始理解吧!

    3.1直流电机

    简单来说就是,把+和-分别接到电池的正极和负极,电机即可转动;
    如果是把的+和-分别接到电池的负极和正极,则电机会反方向转动。电机的转速可以理解为和外接的电压是正相关的(实际是由电枢电流决定)。

    3.2.减速器

    一般直流电机的转速都是一分钟几千上万转的,所以一般需要安装减速器。减速器是一种相对精密的机械零件,使用它的目的是降低转速,增加转矩。减速后的直流电机力矩增大、可控性更强。按照传动级数不同可分为单级和多级减速器;按照传动类型可分为齿轮减速器、蜗杆减速器和行星齿轮减速器。

    3.3电机驱动

    要实现电机调试和换向功能,我们可以使用单片机实现的,但是单片机IO 的带负载能力较弱,而直流电机是大电流感性负载,所以我们需要功率放大器件,在这里,我们选择了 TB6612FNG。
    TB6612FNG 是东芝半导体公司生产的一款直流电机驱动器件,它具有大电流MOSFET-H桥结构,双通道电路输出,可同时驱动 2 个电机。也许大家更熟悉被用烂的L298N,其实这两者的使用基本一致的。而且,相比 L298N 的热耗性和外围二极管续流电路,它无需外加散热片,外围电路简单,只需外接电源滤波电容就可以直接驱动电机,利于减小系统尺寸。对于 PWM 信号输入频率范围,高达 100 kHz 的频率更是足以满足我们大部分的需求了。

    3.4编码器

    这里写图片描述
    编码器是一种将角位移或者角速度转换成一连串电数字脉冲的旋转式传感器,我们可以通过编码器测量到底位移或者速度信息。编码器从输出数据类型上分,可以分为增量式编码器和绝对式编码器。
    从编码器检测原理上来分,还可以分为光学式、磁式、感应式、电容式。常见的是光电编码器(光学式)和霍尔编码器(磁式)。
    这里使用增量式输出的霍尔编码器。编码器有 AB 相输出,所以不仅可以测速,还可以辨别转向。根据上图的接线说明可以看到,我们只需给编码器电源5V 供电,在电机转动的时候即可通过 AB 相输出方波信号。编码器自带了上拉电阻,所以无需外部上拉,可以直接连接到单片机IO读取。
    那么单片机如何采集编码器数据?
    因为编码器输出的是标准的方波,所以我们可以使用单片机(STM32 STM8 51等)直接读取。在软件中的处理方法是分两种,自带编码器接口的单片机如STM32,可以直接使用硬件计数。而没有编码器接口的单片机如 51 单片机,可以通过外部中断读取,比如把编码器 A 相输出接到单片机的外部中断输入口,这样就可通过跳变沿触发中断,然后在对应的外部中断服务函数里面,通过 B 相的电平来确定正反转。如当 A 相来一个跳变沿的时候,如果 B 相是高电平就认为是正转,低电平就认为是反转。

    4、电机速度闭环控制

    4.1原理

    速度闭环控制就是根据单位时间获取的脉冲数测量电机的速度信息,并与目标值进行比较,得到控制偏差,然后通过对偏差的比例、积分、微分进行控制,使偏差趋向于零的过程。
    需要说明的是,这里速度控制 20ms 一次,一般建议 10ms 或者 5ms,因为在这里电机是使用 USB 供电,速度比较慢,20ms 可以延长获取速度的单位时间,提高编码器的采值。
    首先由于需要知道速度,所以一般都需要带编码器的电机,编码器输出有ab相,可以通过单片机定时器的捕获模式来得到速度,之后在单片机内部进行PID算法的运算,得到输出所需要的速度,通过控制占空比来输出PWM波,控制电机的速度,这里用的主控是STM32c8t6。
    这里写图片描述
    这里写图片描述

    4.2核心代码

    /**************************************************************************
    函数功能:增量PI控制器
    入口参数:编码器测量值,目标速度
    返回  值:电机PWM
    根据增量式离散PID公式 
    pwm+=Kp[e(k)-e(k-1)]+Ki*e(k)+Kd[e(k)-2e(k-1)+e(k-2)]
    e(k)代表本次偏差 
    e(k-1)代表上一次的偏差  以此类推 
    pwm代表增量输出
    在我们的速度控制闭环系统里面,只使用PI控制
    pwm+=Kp[e(k)-e(k-1)]+Ki*e(k)
    **************************************************************************/
    int Incremental_PI (int Encoder,int Target)
    {   
       float Kp=20,Ki=30;   
         static int Bias,Pwm,Last_bias;         //相关内部变量的定义。
         Bias=Encoder-Target;                //求出速度偏差,由测量值减去目标值。
         Pwm+=Kp*(Bias-Last_bias)+Ki*Bias;   //使用增量 PI 控制器求出电机 PWM。
         Last_bias=Bias;                       //保存上一次偏差 
         return Pwm;                         //增量输出
    }

    这里可以看到使用的是增量式比例积分控制器,Kp和Ki的值在函数中临时设置,完全按照公式编写,简单易懂。

    4.3定时控制

    int Target_velocity=50;  //设定速度控制的目标速度为50个脉冲每10ms
    int TIM3_IRQHandler(void)  
    {    
        if(TIM3->SR&0X0001)//10ms定时中断
        {   
              TIM3->SR&=~(1<<0);                                       //===清除定时器1中断标志位         
              Encoder=Read_Encoder(2);                                 //===读取编码器的值,M法测速,输出为每10ms的脉冲数
            Led_Flash(100);                                          //===LED闪烁;指示单片机正常运行   
              Moto1=Incremental_PI(Encoder,Target_velocity);           //===速度PI控制器
            Xianfu_Pwm();                                            //===PWM限幅
            Set_Pwm(Moto1);                                          //===赋值给PWM寄存器  
        }           
         return 0;    
    } 

    这里控制周期设定的是每10ms控制一次,设置在10ms的中断中进行,得到控制量后,在经过简单的赋值和去绝对值来输出给驱动的PWM控制器。

    4.4其他代码

    
    /**************************************************************************
    函数功能:赋值给PWM寄存器
    入口参数:PWM
    返回  值:无
    **************************************************************************/
    void Set_Pwm(int moto1)
    {
                if(moto1>0)         AIN2=1,         AIN1=0;
                else              AIN2=0,           AIN1=1;
                PWMA=myabs(moto1);
    }
    
    /**************************************************************************
    函数功能:限制PWM赋值 
    入口参数:无
    返回  值:无
    **************************************************************************/
    void Xianfu_Pwm(void)
    {   
          int Amplitude=7100;    //===PWM满幅是7200 限制在7100
        if(Moto1<-Amplitude) Moto1=-Amplitude;  
            if(Moto1>Amplitude)  Moto1=Amplitude;   
    }
    
    /**************************************************************************
    函数功能:绝对值函数
    入口参数:int
    返回  值:unsigned int
    **************************************************************************/
    int myabs(int a)
    {          
          int temp;
            if(a<0)  temp=-a;  
          else temp=a;
          return temp;
    }

    主函数

    int main(void)
    { 
        Stm32_Clock_Init(9);            //系统时钟设置
        ...
        MiniBalance_PWM_Init(7199,0);   //=====初始化PWM 10KHZ 高频可以防止电机低频时的尖叫声
        Encoder_Init_TIM2();            //初始化编码器 
      Timer3_Init(99,7199);           //=====10MS进一次中断服务函数,中断服务函数在control.c
        while(1);
    
    }

    5、电机位置闭环控制

    位置闭环控制就是根据编码器的脉冲累加测量电机的位置信息,并与目标值进行比较,得到控制偏差,然后通过对偏差的比例、积分、微分进行控制,使偏差趋向于零的过程。

    5.1核心代码

    /**************************************************************************
    函数功能:位置式PID控制器
    入口参数:编码器测量位置信息,目标位置
    返回  值:电机PWM
    根据位置式离散PID公式 
    pwm=Kp*e(k)+Ki*∑e(k)+Kd[e(k)-e(k-1)]
    e(k)代表本次偏差 
    e(k-1)代表上一次的偏差  
    ∑e(k)代表e(k)以及之前的偏差的累积和;其中k为1,2,,k;
    pwm代表输出
    **************************************************************************/
    int Position_PID (int Encoder,int Target)
    {   
         float Position_KP=80,Position_KI=0.1,Position_KD=500;
         static float Bias,Pwm,Integral_bias,Last_Bias;
         Bias=Encoder-Target;                                  //求出速度偏差,由测量值减去目标值。
         Integral_bias+=Bias;                                    //求出偏差的积分
         Pwm=Position_KP*Bias+Position_KI*Integral_bias+Position_KD*(Bias-Last_Bias);       //位置式PID控制器
         Last_Bias=Bias;                                       //保存上一次偏差 
         return Pwm;                                           //增量输出
    }
    

    这里采用稍微复杂一点的PID控制,相比之前的速度控制多了个微分环节,但是由于是位置式控制,所以代码较为简单,容易理解。

    5.2控制中断函数

    int Target_position=11000;    //初始值是10000,目标值是11000
    int TIM3_IRQHandler(void)  
    {    
        if(TIM3->SR&0X0001)//10ms定时中断
        {   
              TIM3->SR&=~(1<<0);                                         //===清除定时器1中断标志位       
              Encoder=Read_Encoder(2);                                  //===读取编码器的位置数据 初始值是10000
            Led_Flash(100);                                           //===LED闪烁;指示单片机正常运行  
              Moto1=Position_PID(Encoder,Target_position);              //===位置PID控制器
              Xianfu_Pwm();                                             //===PWM限幅
            Set_Pwm(Moto1);                                          //===赋值给PWM寄存器  
        }           
         return 0;    
    } 
    

    其他代码和上面类似

    6.参数整定

    首先我们需要明确我们的控制目标,也就是满足控制系统的 3 个要求:

    • 稳定性
    • 快速性
    • 准确性

    具体的评估指标有最大超调量、上升时间、静差等。
    最大超调量是响应曲线的最大峰值与稳态值的差,是评估系统稳定性的一个重要指标;上升时间是指响应曲线从原始工作状态出发,第一次到达输出稳态值所需的时间,是评估系统快速性的一个重要指标;静差是被控量的稳定值与给定值之差,一般用于衡量系统的准确性,具体可以参考前文的讲解。
    在实践生产工程中,不同的控制系统对控制器效果的要求不一样。比如平衡车、倒立摆对系统的快速性要求很高,响应太慢会导致系统失控。智能家居里面的门窗自动开合系统,对快速性要求就不高,但是对稳定性和准确性的要求就很高,所以需要严格控制系统的超调量和静差。所以 PID 参数在不同的控制系统中是不一样的。只要我们理解了每个 PID 参数的作用,我们就可以应对工程中的各种项目的 PID 参数整定了。
    一般而言,一个控制系统的控制难度,一般取决于系统的转动惯量和对响应速度的要求等。转动惯量越小、对响应速度要求越低,PID 参数就越不敏感。比如现在我们控制电机转 90°,需要严格控制超调量、和静差。但是对响应速度无要求。因为电机处于轻载的情况下,转动惯量很小,这是一个很容易完成的工作。根据上面的理论分析和实践,因为响应速度无要求,一般 P 应该给小一点,然后加大系统的阻尼防止超调,也就是 D 参数尽量大,另外因为 P 值较小,应该加入I 控制减小静差。

    7.总结

    调试装置的过程中会遇到各种各样的问题,硬件随外界环境会不断的出现变化,会干扰我们的调试以及运行结果。整定出能适应各种环境的参数,必须对每个环境都加以测试,综合得出最合适的参数。所以在图形化的调试整定过程能够快速直观的得出结论。面对更复杂的情况如平衡车或者四旋翼飞行器,多个传感器采集的数据在复杂的情况下还要考虑滤波,限幅,权重等问题,这些将在后续文章中进行总结。

    增量式PID速度调节代码已经上传,位置式的类似可以参考改动https://download.csdn.net/download/kilotwo/10350922

    展开全文
  • Pid控制算法-增量pid算法的C++实现

    千次阅读 2017-04-10 11:47:48
    PID控制算法的C++语言实现 四 增量PID的C++语言实现 上一节中介绍了最简单的位置型PID的实现手段,这一节主要讲解增量式PID的实现方法.实现过程仍然是分为定义变量、初始化变量、实现控制算法函数、算法测试四...

    PID控制算法的C++语言实现

    四 增量型PID的C++语言实现

       上一节中介绍了最简单的位置型PID的实现手段,这一节主要讲解增量式PID的实现方法.实现过程仍然是分为定义变量、初始化变量、实现控制算法函数、算法测试四个部分,这里直接给出代码了。

    pid.h:
    #ifndef _PID_H_
    #define _PID_H_
     
    typedef struct _pid{
    float SetSpeed;
    float ActualSpeed;
    float err;
    float err_next;
    float err_last;
    float Kp, Ki, Kd;
    }Pid;
     
     
    class Pid_control
    {
    public:
     
    void PID_init();
    float PID_realize(float speed);
     
    private:
    int index;
    Pid pid;
    };
    #endif
     
    pid.cpp:
    #include <iostream>
    #include "pid.h"
     
    using namespace std;
     
    void  Pid_control::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_control::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;
    }
     
    main.cpp:
    #include "pid.h"
    #include <iostream>
     
    using namespace std;
     
    int main()
    {
    Pid_control Pid;
     
    Pid.PID_init();
     
    int count = 0;
     
    while (count<1000)
    {
    float speed = Pid.PID_realize(200.0);
     
    cout << speed << ";" << " ";
     
    count++;
    }
    cout << endl;
     
    system("pause");
     
    return 0;
    }


    运行后的1000个数据为:



     

     

     

    展开全文
  • 前面我们已经知道位置型PID和增量PID的数学表达式,我们根据这些表达式就可以实现基本的PID的C语言编程了!下面我们开始C语言的编写。 第一步:创建一个PID各项参数的变量结构体。 第二步:PID参数...
  • PID控制算法的C语言实现

    万次阅读 多人点赞 2019-12-08 13:31:51
    前言 ...在工业应用中PID及其衍生算法是应用最广泛的算法之一,是当之无愧的万能算法,如果能够熟练掌握PID算法的设计与实现过程,对于一般的研发人员来讲,应该是足够应对一般研发问题了,而难能可...
  • 上篇介绍了连续系统的PID算法,但是计算机控制是一种采样控制,他只能根据采样时刻的偏差来计算控制量,因此计算机控制系统中,必须对公式进行离散化,具体就是用求和代替积分,用向后差分来代替微分,使模拟PID...
  • 本节是PID控制算法的C语言实现系列的最后一节,前面8节中,已经分别从PID的实现到深入的过程进行了一个简要的讲解,从前面的讲解中不难看出,PID的控制思想非常简单,其主要问题点和难点在于比例、积分、微分环节上...
  • 模糊PID控制算法的C++实现

    万次阅读 多人点赞 2017-10-14 20:17:53
    了解了模糊PID的控制原理,然后开始编写C++代码,并不是什么难事。这里采用的是C++面向对象的编程思想,设计一个fuzzy_pid类,需要使用时,只需要实例化这个类即可得到一个fuzzy_pid对象,然后调用它的方法就可以...
  • 上篇介绍了连续系统的PID算法,但是计算机控制是一种采样控制,他只能根据采样时刻的偏差来计算控制量,因此计算机控制系统中,必须对公式进行离散化,具体就是用求和代替积分,用向后差分来代替微分,使模拟PID离散...
  • 蚁群算法matlab代码

    2017-12-16 13:49:37
    蚁群算法(ant colony optimization, ACO),又称蚂蚁算法,是一种用来在图中寻找优化路径的机率型算法。它由Marco Dorigo于1992年在他的博士论文中提出,其灵感来源于蚂蚁在寻找食物过程中发现路径的行为。蚁群算法是...
  • 1、PID算法离散化 在采样周期足够小时,可以作如下近似: u(t)≈u(k)u_{(t)}\approx u_{(k)}u(t)​≈u(k)​ ;e(t)≈e(k)e_{(t)}\approx e_{(k)}e(t)​≈e(k)​ ∫0te(t)dt=∑i=0ke(i)Δt=∑i=0kTe(i)\int_{0}^{t}e_{...
  • T-S模糊算法简述及FPGA的实现

    千次阅读 2019-12-03 22:27:46
    目录 0 引言 1 将清晰的数据模糊化 2、模糊推理 2.1模糊命题 2.2T-S模糊推理 ...4、使用模糊算法逼近一阶线性定常系统在MATLAB中...模糊算法是一种智能算法,也可以说它是一种非模型算法。它是一种以人类的语言为...
  • 编程算法同步入门

    千次阅读 2019-05-29 23:30:03
    而且最新版就在下载页面最显眼的地方,好找,比如下图是2019年5月的下载页头部,你读到这儿的时候,可能版本已经有所不同,不过最新版的位置总是大同小异: 注意: 不要选 Python2 因为 Python2 和 Python3 对...
  • PID控制算法的C语言实现一 PID算法原理  最近两天在考虑一般控制算法的C语言实现问题,发现网络上尚没有一套完整的比较体系的讲解。于是总结了几天,整理一套思路分享给大家。  在工业应用中PID及其衍生算法是...
  • 编写的过程中,更深刻理解了如何在实际工程中运用PID控制算法。 话不多说,先上代码https://github.com/JackJu-HIT/PID。 关于两种算法的原理,我直接粘贴我们老师上课的课件图片了,自己打字太费劲! ...
  • 小白学习日记-----arduino如何使用PID控制算法

    千次阅读 多人点赞 2020-02-14 04:52:43
    ardiuino如何使用PID控制算法 引言 PID:Proportional(比例)、Integral(积分)、Differential(微分)的缩写。顾名思义,PID控制算法是结合比例、积分和微分三种环节于一体的控制算法,PID控制的实质就是根据输入...
  • 增量式PID算法的MATLAB实现

    千次阅读 多人点赞 2019-06-22 13:27:19
    增量式PID的MATLAB实现PID控制的分类连续PID控制离散PID控制位置式PID控制增量式PID控制位置式PID与增量式PID的比较离散PID控制的MATLAB实现实现增量式PID算法绘制GUI界面,实时更改给定值 PID控制的分类 连续PID控制...
  • 算法工程师职业方向及技术要求

    千次阅读 2021-05-13 16:35:18
    点上方人工智能算法与Python大数据获取更多干货在右上方···设为星标★,第一时间获取资源仅做学术分享,如有侵权,联系删除转载于 :作者|explorer来源|知乎算法(A...
  • 疫情期间,居家隔离,时间不多,只能简单的就S速度曲线的来说,建模,写代码,然后编译,再用MATLAB来查看位置曲线、速度曲线和加速度...(论文:CNC系统S曲线加减速算法的设计与实现) 上图为S加减速的各种曲线...
  • 去中心化:是对对称性的延伸,设计应采用有利于去中心化而不是集中控制的技术。在过去,集中控制的设计造成系统中断(outages),而本目标是尽可能避免它。这最终造就一个更简单,更具扩展性,更可用的系统。异质
  • Bresenham算法在步进电机多轴控制中的应用

    千次阅读 多人点赞 2018-06-05 15:20:33
    声明:本博客文档均由我本人编写,如需转载请先联系我。  在marlin固件中借鉴了Bresenham法,转化为了步进电机多轴联动算法,这个太厉害了。。。  回归正题,现在我知道了多轴联动可以使用bresham法转化过来,...
  • STM32-步进电机S加减速控制

    万次阅读 多人点赞 2017-05-16 19:57:16
    基于STM32的步进电机S加减速控制算法STM32简介 STM32代表ARM Cortex-M内核的32位微控制器。专为要求高性能、低成本、低功耗的嵌入式应用专门设计的: STM32系列的内核主要有:Cortex-M0、Cortex-M0+、Cortex-M3、...
  • 轨道电路移频信号是用来控制列车的行驶状态.对其参数的检测需要达到较高的频率分辨率,分析了国产18信息和ZPW一2000两种制式移频轨道电路的移频信号的频谱特点...在MATLAB环境下编写CZT算法进行仿真,仿真结果表明。
  • 算法复杂度与NP问题

    千次阅读 2019-05-02 19:14:51
    引言 美剧《基本演绎法》S2E2中,两位研究 NP 问题的数学家被谋杀了,凶手是同行,因为被害者即将证明“P=NP 问题”。...一大批耳熟能详的游戏,如扫雷、俄罗斯方块、超级玛丽等,人们将为它们编写...
  • 各种PID算法——用C语言去实现

    千次阅读 2020-04-09 14:47:24
    文章目录前言PID原理简单介绍位置型PID增量式PID位置型PID——C语言增量PID——C语言积分分离的PID控制算法——C语言抗积分饱和的PID控制算法——C语言变积分的PID控制算法——C语言 前言   PID算法在工业应用中...
  • 转自 https://blog.csdn.net/u010312937/article/details/53363831PID控制算法的C语言实现一 PID算法原理 最近两天在考虑一般控制算法的C语言实现问题,发现网络上尚没有一套完整的比较体系的讲解。于是总结了几天...
  • AGV小车经典算法设计及应用

    万次阅读 多人点赞 2018-11-23 10:30:15
    机器人具有可编程、可协调作业和基于传感器控制等特点,自动导向小车(Automated Guided Vehicle 简称AGV)便是移动机器人的一种,是现代化工业物流系统中的重要设备,主要为储运各类物料,为系统柔性化、集成化、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 100,153
精华内容 40,061
关键字:

编写位置型控制算法