关于PID控制算法基础概念在本文不再重复了，详情可参考：PID控制算法基础介绍

本文主要从PID算法代码实现，代码解析，理论进阶，PID调参等方向进行阐述。

目录

位置式PID和增量式PID

1.1 位置式PID

（1）基本的连续PID控制
公式：
在这里插入图片描述
（2）离散PID控制
将连续的进行离散化。
在这里插入图片描述
展开简化一下就是：
在这里插入图片描述
e(k): 用户设定的值（目标值） - 控制对象的当前的状态值

比例P : e(k)

积分I : ∑e(i) 误差的累加

微分D : e(k) - e(k-1) 这次误差-上次误差

也就是位置式PID是当前系统的实际位置，与你想要达到的预期位置的偏差，进行PID控制

因为有误差积分 ∑e(i)，一直累加，也就是当前的输出u(k)与过去的所有状态都有关系，用到了误差的累加值；（误差e会有误差累加），输出的u(k)对应的是执行机构的实际位置，一旦控制输出出错(控制对象的当前的状态值出现问题 )，u(k)的大幅变化会引起系统的大幅变化

并且位置式PID在积分项达到饱和时,误差仍然会在积分作用下继续累积，一旦误差开始反向变化，系统需要一定时间从饱和区退出，所以在u(k)达到最大和最小时，要停止积分作用，并且要有积分限幅和输出限幅

所以在使用位置式PID时，一般我们直接使用PD控制

而位置式 PID 适用于执行机构不带积分部件的对象，如舵机、平衡小车的直立、温控系统的控制

1.2 增量式PID

（1）公式推导过程
（a）k-1时刻的离散表示：
在这里插入图片描述（b）利用deltUk = U(k) - U(K-1)，得到本次的增量：
在这里插入图片描述
比例P : e(k)-e(k-1) 本次误差-上次误差

积分I : e(k) 本次误差

微分D : e(k) - 2e(k-1)+e(k-2) 本次误差-2*上次误差+上上次误差

增量式PID根据公式可以很好地看出，一旦确定了 KP、TI 、TD，只要使用前后三次测量值的偏差， 即可由公式求出控制增量

而得出的控制量Δu(k)对应的是近几次位置误差的增量，而不是对应与实际位置的偏差。 没有误差累加

也就是说，增量式PID中不需要累加。控制增量Δu(k)的确定仅与最近3次的采样值有关，容易通过加权处理获得比较好的控制效果，并且在系统发生问题时，增量式不会严重影响系统的工作。

1.3 位置式和增量式PID区别

1、增量式算法不需要做累加，控制量增量的确定仅与最近几次偏差采样值有关，计算误差对控制 量计算的影响较小。而位置式算法要用到过去偏差的累加值，容易产生较大的累加误差。

2、增量式算法得出的是控制量的增量，例如在阀门控制中，只输出阀门开度的变化部分，误动作 影响小，必要时还可通过逻辑判断限制或禁止本次输出，不会严重影响系统的工作。 而位置式的输出直接对应对象的输出，因此对系统影响较大。

3、增量式PID控制输出的是控制量增量，并无积分作用，因此该方法适用于执行机构带积分部件的对象，如步进电机等，而位置式PID适用于执行机构不带积分部件的对象，如电液伺服阀。

4、在进行PID控制时，位置式PID需要有积分限幅和输出限幅，而增量式PID只需输出限幅

积分限幅

积分限幅实际比较多，所以也提一下。
（1）针对问题：
在开始控制后，有一个较大误差，且有一个非常大干扰的话，例如外界阻力，阻止其误差减小，如旋翼飞机被人死死的按住。虽然他的PI都在输出，但是误差一直没变。这时候，随着时间的拉长，积分的输出值会越来越大。
这将导致以下问题：
a）这种输出可能超过了控制系统承受范围
b）而一旦这种阻力去掉，会使得这种输出很大很大，引起很大的超调和震荡。

（2）解决方法
引入积分限幅。原理给定一个积分输出的最大值限制，一旦超出，则不再增加。

位置式PID参数调试

PID调节的具体过程一般有理论计算整定法和工程整定法。对于复杂的、非线性的系统通常用工程整定法，即根据工程经验试凑出合理的参数。PID参数的设置步骤一般如下：
（1）首先选择一个合适的并且尽量短的采样时间让系统工作；
（2）首先加入比例环节，调节比例系数，直到系统的输出出现临界振荡；
（3）若单独的比例环节不能满足设计要求，则此时加入积分环节，调整好的比例系数缩小为原来的0.8，然后调节积分时间参数，使得系统能保持较小的稳态误差和较小的振荡时间，此时可以同时调整比例系数和积分时间常数，直到得到较为满意的结果；
（4）如若还不是特别满意，可以增加微分环节，从小到大逐渐增加微分时间常数，同时相应的更改比例系数和积分时间，试凑出合适参数。

实际使用时，PID可能不是都使用的，有：
（1）PI，D=0
有自然的阻尼的情况。如水中弹簧震荡，水有阻尼，或者阻尼能够较好的平衡掉该中情况下PI的震荡。
（2）PD，I=0
没有外界阻力情况，物理机械能够保证自平衡。
比如在水平面上小车控制运动到指定位置，且这个小车电机等没有阻力，到位置后不需要再输出就可以保持。

调整PID参数对系统的影响：
在这里插入图片描述
PID参数调整口诀：
参数整定找最佳，从小到大顺序查，
先是比例后积分，最后再把微分加，
曲线振荡很频繁，比例度盘要放大，
曲线漂浮绕大弯，比例度盘往小扳，
曲线偏离回复慢，积分时间往下降，
曲线波动周期长，积分时间再加长，
曲线振荡频率快，先把微分降下来，
动差大来波动慢，微分时间应加长，
理想曲线两个波，前高后低四比一，
一看二调多分析，调节质量不会低

注：比例度盘，kp倒数
积分时间，Ti倒数
微分时间，Td

代码实现

typedef struct PID
{ 
  float P,I,D,limit;
}PID;
 
typedef struct Error
{
  float Current_Error;//当前误差
  float Last_Error;//上一次误差
  float Previous_Error;//上上次误差
}Error;
 
/*! 
 *  @brief      位置式PID
 *  *sptr ：误差参数
 *  *pid:  PID参数
 *  NowPlace：当前位置
 *  Point：   目标位置  
 */
 
// 位置式PID控制
float PID_Realize(Error *sptr,PID *pid, int32 NowPlace, float Point)
{
	int32 iError,	// 当前误差
		 Realize;   //实际输出	
 
	iError = Point - NowPlace;	// 计算当前误差
	sptr->Current_Error += pid->I * iError;	// 误差积分
  sptr->Current_Error = sptr->Current_Error > pid->limit?pid->limit:sptr->Current_Error;//积分限幅
  sptr->Current_Error = sptr->Current_Error <-pid->limit?-pid->limit:sptr->Current_Error;
	Realize = pid->P * iError       //比例P
            + sptr->Current_Error   //积分I
			+ pid->D * (iError - sptr->Last_Error);  //微分D
	sptr->Last_Error = iError;		  	// 更新上次误差
	return Realize;	// 返回输出值
}

/*! 
 *  @brief      增量式PID
 *  *sptr ：误差参数
 *  *pid:  PID参数
 *  NowPlace：实际值
 *  Point：   期望值
 */
// 增量式PID控制
int32 PID_Increase(Error *sptr, PID *pid, int32 NowPlace, int32 Point)
{
	int32 iError,	//当前误差
		Increase;	//最后得出的实际增量
 
	iError = Point - NowPlace;	// 计算当前误差
 
	Increase =  pid->P * (iError - sptr->Last_Error)   //比例P
			  + pid->I * iError      //积分I
			  + pid->D * (iError - 2 * sptr->Last_Error + sptr->Previous_Error);  //微分D
	
	sptr->Previous_Error = sptr->Last_Error;	// 更新前次误差
	sptr->Last_Error = iError;		  	// 更新上次误差
	
	return Increase;	// 返回增量
}

实际使用时，需要定时周期性采集数据进行PID计算，需要根据场景决定合适的采样周期。

上面那套比较简单方便理解，下面这套比较完善，更实用，都可参考：

#define LimitMax(input, max)   \
    {                          \
        if (input > max)       \
        {                      \
            input = max;       \
        }                      \
        else if (input < -max) \
        {                      \
            input = -max;      \
        }                      \
    }

enum PID_MODE
{
    PID_POSITION = 0,
    PID_DELTA
};

typedef struct
{
    //PID运算模式
    uint8_t mode;
    //PID 三个基本参数
    float Kp;
    float Ki;
    float Kd;

    float max_out;  //PID最大输出  (输出限幅)
    float max_iout; //PID最大积分输出  (积分限幅)

    float set;	  //PID目标值
    float fdb;	  //PID当前值

    float out;		//三项叠加输出
    float Pout;		//比例项输出
    float Iout;		//积分项输出
    float Dout;		//微分项输出
    //微分项最近三个值 0最新 1上一次 2上上次
    float Dbuf[3];  
    //误差项最近三个值 0最新 1上一次 2上上次
    float error[3];  
} pid_type_def;

void PID_init(pid_type_def *pid, uint8_t mode, const float PID[3], float max_out, float max_iout)
{
    if (pid == NULL || PID == NULL)
    {
        return;
    }
    pid->mode = mode;
    pid->Kp = PID[0];
    pid->Ki = PID[1];
    pid->Kd = PID[2];
    pid->max_out = max_out;
    pid->max_iout = max_iout;
    pid->Dbuf[0] = pid->Dbuf[1] = pid->Dbuf[2] = 0.0f;
    pid->error[0] = pid->error[1] = pid->error[2] = pid->Pout = pid->Iout = pid->Dout = pid->out = 0.0f;
}

void PID_clear(pid_type_def *pid)
{
    if (pid == NULL)
    {
        return;
    }
	  //当前误差清零
    pid->error[0] = pid->error[1] = pid->error[2] = 0.0f;
    //微分项清零
    pid->Dbuf[0] = pid->Dbuf[1] = pid->Dbuf[2] = 0.0f;
    //输出清零
    pid->out = pid->Pout = pid->Iout = pid->Dout = 0.0f;
    //目标值和当前值清零
    pid->fdb = pid->set = 0.0f;
}

float PID_calc(pid_type_def *pid, float ref, float set)
{
    //判断传入的PID指针不为空
    if (pid == NULL)
    {
        return 0.0f;
    }
    //存放过去两次计算的误差值
    pid->error[2] = pid->error[1];
    pid->error[1] = pid->error[0];
    //设定目标值和当前值到结构体成员
    pid->set = set;
    pid->fdb = ref;
    //计算最新的误差值
    pid->error[0] = set - ref;
    //判断PID设置的模式
    if (pid->mode == PID_POSITION)//位置式PID
    {
        //比例项计算输出
        pid->Pout = pid->Kp * pid->error[0];
        //积分项计算输出
        pid->Iout += pid->Ki * pid->error[0];
        //存放过去两次计算的微分误差值
        pid->Dbuf[2] = pid->Dbuf[1];
        pid->Dbuf[1] = pid->Dbuf[0];
        //当前误差的微分用本次误差减去上一次误差来计算
        pid->Dbuf[0] = (pid->error[0] - pid->error[1]);
        //微分项输出
        pid->Dout = pid->Kd * pid->Dbuf[0];
        //对积分项进行限幅
        LimitMax(pid->Iout, pid->max_iout);
        //叠加三个输出到总输出
        pid->out = pid->Pout + pid->Iout + pid->Dout;
        //对总输出进行限幅
        LimitMax(pid->out, pid->max_out);
    }
    else if (pid->mode == PID_DELTA)//增量式PID
    {
        //以本次误差与上次误差的差值作为比例项的输入带入计算
        pid->Pout = pid->Kp * (pid->error[0] - pid->error[1]);
        //以本次误差作为积分项带入计算
        pid->Iout = pid->Ki * pid->error[0];
        //迭代微分项的数组
        pid->Dbuf[2] = pid->Dbuf[1];
        pid->Dbuf[1] = pid->Dbuf[0];
        //以本次误差与上次误差的差值减去上次误差与上上次误差的差值作为微分项的输入带入计算
        pid->Dbuf[0] = (pid->error[0] - 2.0f * pid->error[1] + pid->error[2]);
        pid->Dout = pid->Kd * pid->Dbuf[0];
        //叠加三个项的输出作为总输出  注意这里的符号是+=
        pid->out += pid->Pout + pid->Iout + pid->Dout;
        //对总输出限幅
        LimitMax(pid->out, pid->max_out);
	}
	return pid->out;
}

参考和推荐：
https://blog.csdn.net/kevinshift/article/details/124753170

https://blog.csdn.net/as480133937/article/details/89508034

https://zhuanlan.zhihu.com/p/85020348?utm_source=qq
https://zhuanlan.zhihu.com/p/84767869

https://blog.csdn.net/kevinshift/article/details/124753170

# 嵌入式
Logo
开放原子开发者工作坊

开放原子开发者工作坊旨在鼓励更多人参与开源活动，与志同道合的开发者们相互交流开发经验、分享开发心得、获取前沿技术趋势。工作坊有多种形式的开发者活动，如meetup、训练营等，主打技术交流，干货满满，真诚地邀请各位开发者共同参与！

更多推荐

【入坑ORB-SLAM3系列2】未标定的realsense D435i试运行ORB-SLAM3（手把手教学，含realsense d435i一些错误的解决）

文章目录前言一、前奏1. Error 12. Error 2二、正文1. 查看自己相机的可用的分辨率与频率2. 配置rs_camera.launch（realsense-ros文件夹中）3. 修改.yaml配置文件4. 修改源文件（只修改订阅的相机话题即可）三、尾声总结Reference前言我之前刚编译成功ORB-SLAM3的时候试跑了一下demo（数据集），但是效果其实很一般，甚至想说拉垮，在R

avatar 开放原子开发者工作坊

中级软考-软件设计师（四）

数据结构1.霍夫曼数构造霍夫曼树，左大右小，左1右0。下列为某文件中字符的出现频率，采用霍夫曼编码对下列字符编码，则字符序列“bee”的编码为101 1101 1101。2.

avatar 开放原子开发者工作坊
cover

ROS2快速入门Python篇-版本梳理、环境搭建、源码架构介绍

avatar 开放原子开发者工作坊