include/a/pid.h

   1 /*!
   2  @file pid.h
   3  @brief proportional integral derivative controller
   4  @details
   5  A proportional integral derivative controller (PID controller or three-term controller) is
   6  a control loop mechanism employing feedback that is widely used in industrial control systems
   7  and a variety of other applications requiring continuously modulated control.
   8  \f[
   9   u(t) = K_p\left[e(t)+\frac{1}{T_i}\int{e(t)}\text{dt}+T_d\frac{\text{d}e(t)}{\text{d}t}\right]
  10  \f]
  11  \f[
  12   u(k) = K_p\left[e(k)+\frac{T}{T_i}\sum^k_{i=0}e(i)+\frac{T_d}{T}[e(k)-e(k-1)]\right]
  13  \f]
  14  - positional PID controller
  15  \f{aligned}{
  16   u(k) &= K_p e(k) + q\sum^k_{i=0} K_i e(i) + K_d [e(k)-e(k-1)] \\
  17        &= (K_p+K_d) e(k) + q\sum^k_{i=0}K_i e(i) + (-K_d) e(k-1) \\
  18        &\begin{cases}q=0&|\sum\limits^{k-1}_{i=0}K_ie(i)|>E \bigvee
  19        [\sum\limits^{k-1}_{i=0}K_ie(i)]K_ke(k)>0 \\ q=1\end{cases}
  20  \f}
  21  - incremental PID controller
  22  \f{aligned}{
  23   \Delta u(k) &= K_p [e(k)-e(k-1)] + K_i e(k) + K_d [e(k)+e(k-2)-2e(k-1)] \\
  24               &= (K_p+K_i+K_d) e(k) + (-K_p-2K_i) e(k-1) + K_d e(k-2)
  25  \f}
  26  https://en.wikipedia.org/wiki/PID_controller
  27 */
  28
  29 #ifndef LIBA_PID_H
  30 #define LIBA_PID_H
  31
  32 #include "a.h"
  33
  34 /*!
  35  @ingroup A
  36  @addtogroup A_PID proportional integral derivative controller
  37  @{
  38 */
  39
  40 typedef struct a_pid a_pid;
  41
  42 #if defined(__cplusplus)
  43 extern "C" {
  44 #endif /* __cplusplus */
  45
  46 /*!
  47  @brief initialize for PID controller
  48  @param[in,out] ctx points to an instance of PID controller
  49 */
  50 #define a_pid_init(ctx) a_pid_zero(ctx)
  51
  52 /*!
  53  @brief set proportional integral derivative constant for PID controller
  54  @param[in,out] ctx points to an instance of PID controller
  55  @param[in] kp proportional constant
  56  @param[in] ki integral constant
  57  @param[in] kd derivative constant
  58 */
  59 A_EXTERN void a_pid_kpid(a_pid *ctx, a_float kp, a_float ki, a_float kd);
  60
  61 /*!
  62  @brief calculate for PID controller
  63  @param[in,out] ctx points to an instance of PID controller
  64  @param[in] set setpoint value
  65  @param[in] fdb feedback value
  66  @return setpoint value
  67 */
  68 A_EXTERN a_float a_pid_run(a_pid *ctx, a_float set, a_float fdb);
  69
  70 /*!
  71  @brief calculate for positional PID controller
  72  @param[in,out] ctx points to an instance of PID controller
  73  @param[in] set setpoint value
  74  @param[in] fdb feedback value
  75  @return output value
  76 */
  77 A_EXTERN a_float a_pid_pos(a_pid *ctx, a_float set, a_float fdb);
  78
  79 /*!
  80  @brief calculate for incremental PID controller
  81  @param[in,out] ctx points to an instance of PID controller
  82  @param[in] set setpoint value
  83  @param[in] fdb feedback value
  84  @return output value
  85 */
  86 A_EXTERN a_float a_pid_inc(a_pid *ctx, a_float set, a_float fdb);
  87
  88 /*!
  89  @brief zeroing for PID controller
  90  @param[in,out] ctx points to an instance of PID controller
  91 */
  92 A_EXTERN void a_pid_zero(a_pid *ctx);
  93
  94 #if defined(__cplusplus)
  95 } /* extern "C" */
  96 namespace a
  97 {
  98 typedef struct a_pid pid;
  99 } /* namespace a */
 100 #endif /* __cplusplus */
 101
 102 /*!
 103  @brief instance structure for PID controller
 104 */
 105 struct a_pid
 106 {
 107     a_float kp; //!< proportional constant
 108     a_float ki; //!< integral constant
 109     a_float kd; //!< derivative constant
 110     a_float summax; //!< maximum integral output
 111     a_float summin; //!< minimum integral output
 112     a_float sum; //!< controller integral output
 113     a_float outmax; //!< maximum final output
 114     a_float outmin; //!< minimum final output
 115     a_float out; //!< controller final output
 116     a_float var; //!< cache variable
 117     a_float fdb; //!< cache feedback
 118     a_float err; //!< cache error
 119 #if defined(__cplusplus)
 120     A_INLINE void init() { a_pid_init(this); }
 121     A_INLINE void kpid(a_float _kp, a_float _ki, a_float _kd)
 122     {
 123         a_pid_kpid(this, _kp, _ki, _kd);
 124     }
 125     A_INLINE a_float run(a_float set, a_float _fdb)
 126     {
 127         return a_pid_run(this, set, _fdb);
 128     }
 129     A_INLINE a_float pos(a_float set, a_float _fdb)
 130     {
 131         return a_pid_pos(this, set, _fdb);
 132     }
 133     A_INLINE a_float inc(a_float set, a_float _fdb)
 134     {
 135         return a_pid_inc(this, set, _fdb);
 136     }
 137     A_INLINE void zero() { a_pid_zero(this); }
 138 #endif /* __cplusplus */
 139 };
 140
 141 /*! @} A_PID */
 142
 143 #endif /* a/pid.h */