增量式PID与位置式PID的理解与代码实现

一、PID控制算法概述

PID 实指“比例 proportional”、“积分 integral”、“微分 derivative”，这三项构 成 PID 基本要素。每一项完成不同任务，对系统功能产生不同的影响。它的结构简单，参数易 于调整，是控制系统中经常采用的控制算法。

PID：比例单元（P）、积分单元（I）和微分单元（D）组成

一、增量式PID

比例P : e(k)-e(k-1) 这次误差-上次误差
积分I : e(i) 误差
微分D : e(k) - 2e(k-1)+e(k-2) 这次误差-2*上次误差+上上次误差
         增量式PID根据公式可以很好地看出，一旦确定了 KP、TI 、TD，只要使用前后三次测量值的偏差， 即可由公式求出控制增量而得出的控制量▲u(k)对应的是近几次位置误差的增量，而不是对应与实际位置的偏差没有误差累加也就是说，增量式PID中不需要累加。控制增量Δu(k)的确定仅与最近3次的采样值有关，容易通过加权处理获得比较好的控制效果，并且在系统发生问题时，增量式不会严重影响系统的工作
         总结：增量型 PID，是对位置型 PID 取增量，这时控制器输出的是相邻两次采样时刻所计算的位置值
之差，得到的结果是增量，即在上一次的控制量的基础上需要增加（负值意味减少）控制量。

struct inc_pid_controller
{
    struct controller   controller;
    
    float               kp;
    float               ki;
    float               kd;

    float               minimum;
    float               maximum;

    float               p_error;
    float               i_error;
    float               d_error;

    float               error;
    float               error_l;
    float               error_ll;

    float               last_out;
    rt_tick_t           last_time;
};

static rt_err_t inc_pid_controller_update(void *pid, float current_point)
{
    inc_pid_controller_t inc_pid = (inc_pid_controller_t)pid;
    // TODO
    if((rt_tick_get() - inc_pid->last_time) < rt_tick_from_millisecond(inc_pid->controller.sample_time))
    {
        LOG_D("PID waiting ... ");
        return RT_EBUSY;
    }
    inc_pid->last_time = rt_tick_get();

    inc_pid->error = inc_pid->controller.target - current_point;

    inc_pid->p_error = inc_pid->kp * (inc_pid->error - inc_pid->error_l);
    inc_pid->i_error = inc_pid->ki * inc_pid->error;
    inc_pid->d_error = inc_pid->kd * (inc_pid->error - 2 * inc_pid->error_l + inc_pid->error_ll);

    inc_pid->last_out += inc_pid->p_error + inc_pid->i_error + inc_pid->d_error;

    if (inc_pid->last_out > inc_pid->maximum)
    {
        inc_pid->last_out = inc_pid->maximum;
    }
    if (inc_pid->last_out < inc_pid->minimum)
    {
        inc_pid->last_out = inc_pid->minimum;
    }

    inc_pid->error_ll = inc_pid->error_l;
    inc_pid->error_l = inc_pid->error;

    inc_pid->controller.output = inc_pid->last_out;

    return RT_EOK;
}

二、位置式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 适用于执行机构不带积分部件的对象，如舵机和平衡小车的直立和温控系统的控制

struct pos_pid_controller
{
    struct controller   controller;
    
    float               kp;
    float               ki;
    float               kd;

    float               minimum;
    float               maximum;
    float               anti_windup_value;

    float               p_error;
    float               i_error;
    float               d_error;

    float               integral;
    float               error;
    float               error_l;

    float               last_out;
    rt_tick_t           last_time;
};

static rt_err_t pos_pid_controller_update(void *pid, float current_point)
{
    pos_pid_controller_t pos_pid = (pos_pid_controller_t)pid;

    if((rt_tick_get() - pos_pid->last_time) < rt_tick_from_millisecond(pos_pid->controller.sample_time))
    {
        LOG_D("PID waiting ... ");
        return RT_EBUSY;
    }
    pos_pid->last_time = rt_tick_get();

    pos_pid->error = pos_pid->controller.target - current_point;

    pos_pid->integral += pos_pid->ki * pos_pid->error;

    //Perform integral value capping to avoid internal PID state to blows up
    //when controllertuators saturate:
    if(pos_pid->integral > pos_pid->anti_windup_value) {
        pos_pid->integral = pos_pid->anti_windup_value;
    } else if (pos_pid->integral < -pos_pid->anti_windup_value) {
        pos_pid->integral = -pos_pid->anti_windup_value;
    }

    pos_pid->p_error = pos_pid->kp * pos_pid->error;
    pos_pid->i_error = pos_pid->integral;
    pos_pid->d_error = pos_pid->kd * (pos_pid->error - pos_pid->error_l);

    pos_pid->last_out = pos_pid->p_error + pos_pid->i_error + pos_pid->d_error;
    if (pos_pid->last_out > pos_pid->maximum)
    {
        pos_pid->last_out = pos_pid->maximum;
    }
    if (pos_pid->last_out < pos_pid->minimum)
    {
        pos_pid->last_out = pos_pid->minimum;
    }

    pos_pid->error_l = pos_pid->error;

    pos_pid->controller.output = pos_pid->last_out;

    return RT_EOK;
}