Add setpoint weighting feature

Author: Dlloydev

QuickPID.cpp

@@ -19,7 +19,7 @@
    reliable defaults, so we need to have the user set them.
  **********************************************************************************/
 QuickPID::QuickPID(int16_t* Input, int16_t* Output, int16_t* Setpoint,
-                   float Kp, float Ki, float Kd, bool POn, bool ControllerDirection)
+                   float Kp, float Ki, float Kd, float POn, bool ControllerDirection)
 {
   myOutput = Output;
   myInput = Input;
@@ -42,7 +42,7 @@ QuickPID::QuickPID(int16_t* Input, int16_t* Output, int16_t* Setpoint,
 
 QuickPID::QuickPID(int16_t* Input, int16_t* Output, int16_t* Setpoint,
                    float Kp, float Ki, float Kd, bool ControllerDirection)
-  : QuickPID::QuickPID(Input, Output, Setpoint, Kp, Ki, Kd, P_ON_E, ControllerDirection)
+  : QuickPID::QuickPID(Input, Output, Setpoint, Kp, Ki, Kd, pOn, ControllerDirection)
 {
 
 }
@@ -65,17 +65,9 @@ bool QuickPID::Compute()
     int16_t dInput = input - lastInput;
     error = *mySetpoint - input;
 
-    /*Working error, Proportional on Measurement and Remaining PID output*/
-    if (!pOnE) {
-      if (ki < 31 && kpd < 31) outputSum += FX_MUL(FL_FX(ki) , error) - FX_MUL(FL_FX(kpd), dInput);
-      else outputSum += (ki * error) - (kpd * dInput);
-    }
-
-    /*Working error, Proportional on Error and remaining PID output*/
-    if (pOnE) {
-      if (kpi < 31 && kd < 31) outputSum += FX_MUL(FL_FX(kpi) , error) - FX_MUL(FL_FX(kd), dInput);
-      else outputSum += (kpi * error) - (kd * dInput);
-    }
+    /*Working error, Proportional distribution and Remaining PID output*/
+    if (kpi < 31 && kpd < 31) outputSum += FX_MUL(FL_FX(kpi) , error) - FX_MUL(FL_FX(kpd), dInput);
+    else outputSum += (kpi * error) - (kpd * dInput);
 
     if (outputSum > outMax) outputSum = outMax;
     if (outputSum < outMin) outputSum = outMin;
@@ -94,20 +86,19 @@ bool QuickPID::Compute()
    it's called automatically from the constructor, but tunings can also
    be adjusted on the fly during normal operation
  ******************************************************************************/
-void QuickPID::SetTunings(float Kp, float Ki, float Kd, bool POn)
+void QuickPID::SetTunings(float Kp, float Ki, float Kd, float POn)
 {
   if (Kp < 0 || Ki < 0 || Kd < 0) return;
 
   pOn = POn;
-  pOnE = POn == P_ON_E;
   dispKp = Kp; dispKi = Ki; dispKd = Kd;
 
   float SampleTimeSec = (float)SampleTimeUs / 1000000;
   kp = Kp;
   ki = Ki * SampleTimeSec;
   kd = Kd / SampleTimeSec;
-  kpd = kp + kd;
-  kpi = kp + ki;
+  kpi = kp * pOn + ki;
+  kpd = kp * (1 - pOn) + kd;
 
   if (controllerDirection == REVERSE)
   {
@@ -228,9 +219,6 @@ bool QuickPID::GetDirection() {
 int16_t QuickPID::GetError() {
   return  error;
 }
-bool QuickPID::GetpOnE() {
-  return pOnE;
-}
 
 // Utility functions **********************************************************
 

QuickPID.h

@@ -11,8 +11,6 @@ class QuickPID
 #define MANUAL	0
 #define DIRECT  0
 #define REVERSE 1
-#define P_ON_M  0
-#define P_ON_E  1
 
 #define FL_FX(a) (int32_t)(a*256.0)  // float to fixed point
 #define FX_MUL(a,b) ((a*b)>>8)       // fixed point multiply
@@ -21,7 +19,7 @@ class QuickPID
     // commonly used functions ************************************************************************************
 
     // Constructor. Links the PID to Input, Output, Setpoint and initial Tuning Parameters.
-    QuickPID(int16_t*, int16_t*, int16_t*, float, float, float, bool, bool);
+    QuickPID(int16_t*, int16_t*, int16_t*, float, float, float, float, bool);
 
     // Overload constructor with proportional mode. Links the PID to Input, Output, Setpoint and Tuning Parameters.
     QuickPID(int16_t*, int16_t*, int16_t*, float, float, float, bool);
@@ -44,7 +42,7 @@ class QuickPID
     void SetTunings(float, float, float);
 
     // Overload for specifying proportional mode.
-    void SetTunings(float, float, float, bool);
+    void SetTunings(float, float, float, float);
 
     // Sets the Direction, or "Action" of control. DIRECT means the output will increase when error is positive.
     // REVERSE means the opposite. It's very unlikely that this will be needed once it is set in the constructor.
@@ -60,26 +58,25 @@ class QuickPID
     bool GetMode();
     bool GetDirection();
     int16_t GetError();
-    bool GetpOnE();
 
     // Utility functions ******************************************************************************************
     int analogReadFast(int);
 
   private:
     void Initialize();
 
-    float dispKp;          // We'll hold on to the tuning parameters in user-entered format for display purposes.
+    float dispKp;          // We'll hold on to the tuning parameters for display purposes.
     float dispKi;
     float dispKd;
 
+    float pOn;             // proportional mode (0-1) default 1 (100% on Error, 0% on Measurement)
     float kp;              // (P)roportional Tuning Parameter
     float ki;              // (I)ntegral Tuning Parameter
     float kd;              // (D)erivative Tuning Parameter
-    float kpd = kp + kd;
-    float kpi = kp + ki;
+    float kpi;             // proportional on error amount
+    float kpd;             // proportional on measurement amount
 
     bool controllerDirection;
-    bool pOn;
 
     int16_t *myInput;      // Pointers to the Input, Output, and Setpoint variables. This creates a
     int16_t *myOutput;     // hard link between the variables and the PID, freeing the user from having
@@ -88,7 +85,7 @@ class QuickPID
     uint32_t SampleTimeUs, lastTime;
     int16_t outMin, outMax, error;
     int16_t lastInput, outputSum;
-    bool inAuto, pOnE;
+    bool inAuto;
 };
 
 #endif

README.md

@@ -2,8 +2,8 @@
 
 This API (version 2.03) follows the [ArduinoPID](https://github.com/br3ttb/Arduino-PID-Library) library, however there have been some significant updates as follows:
 
-- This library named as **QuickPID** and can run alongside with Arduino **PID** if needed
-- Quicker fixed point math in compute function for small tuning values, floating point math used for large tuning values
+- Quicker hybrid fixed/floating point math in compute function
+-  POn parameter controls the setpoint weighting of Proportional on Error (PonE) to Proportional on Measurement (PonM)
 - Reorganized and more efficient PID algorithm
 - micros() timing resolution
 - Faster analog read function
@@ -14,15 +14,15 @@ This API (version 2.03) follows the [ArduinoPID](https://github.com/br3ttb/Ardui
 
 | Compute                              | Kp   | Ki   | Kd   | Step Time (µS) |
 | :----------------------------------- | ---- | ---- | ---- | -------------- |
-| QuickPID                             | 2.0  | 15.0 | 0.05 | 68             |
+| QuickPID                             | 2.0  | 15.0 | 0.05 | 72             |
 | Arduino PID                          | 2.0  | 15.0 | 0.05 | 104            |
 | **analogRead, Compute, analogWrite** |      |      |      |                |
 | QuickPID                             | 2.0  | 5.0  | 0.2  | 96             |
 | Arduino PID                          | 2.0  | 5.0  | 0.2  | 224            |
 
 #### Self Test Example (RC Filter):
 
-This example allows you to set an output voltage, then view the result of your tuning parameters. The mode of the P-Term automatically toggles from Proportional on Error to [Proportional on Measurement.](http://brettbeauregard.com/blog/2017/06/introducing-proportional-on-measurement/)
+[This example](https://github.com/Dlloydev/QuickPID/wiki/QuickPID_RC_Filter) allows you to experiment with the four tuning parameters.
 
 ![pid_self_test_pom](https://user-images.githubusercontent.com/63488701/104389509-a66a8f00-5509-11eb-927b-1190231a1ee9.gif)
 

examples/QuickPID_Self_Test/QuickPID_Self_Test.ino renamed to examples/QuickPID_RC_Filter/QuickPID_RC_Filter.ino

@@ -1,9 +1,10 @@
-/************************************************************
-   PID RC Filter Self Test Example:
-   One 47µF capacitor connected from GND to a 27K resistor
+/**************************************************************
+   PID RC Filter Example:
+   One 47µF capacitor connected from GND to a 10K resistor
    terminated at pwm pin 3. Junction point of the RC filter
    is connected to A0. Use Serial Plotter to view results.
- ************************************************************/
+   https://github.com/Dlloydev/QuickPID/wiki/QuickPID_RC_Filter
+ **************************************************************/
 
 #include "QuickPID.h"
 
@@ -19,14 +20,14 @@ unsigned long before, after;
 int cnt = 0;
 
 //Specify the initial tuning parameters
-float Kp = 2.0, Ki = 15.0, Kd = 0.05;
+float Kp = 2.0, Ki = 15.0, Kd = 0.05, POn = 1.0;
 
 QuickPID myQuickPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);
 
 void setup()
 {
   Serial.begin(115200);
-  myQuickPID.SetTunings(Kp, Ki, Kd, P_ON_E);
+  myQuickPID.SetTunings(Kp, Ki, Kd, POn);
   myQuickPID.SetMode(AUTOMATIC);
   analogWrite(PIN_OUTPUT, 0); // discharge capacitor
   delay(1000);
@@ -59,6 +60,5 @@ void loop()
     analogWrite(PIN_OUTPUT, 0);
     delay(1000); // discharge capacitor
     cnt = 0;
-    myQuickPID.SetTunings(Kp, Ki, Kd, !(myQuickPID.GetpOnE())); //toggle P-Term mode
   }
 }

keywords.txt

@@ -23,7 +23,6 @@ GetKi	KEYWORD2
 GetKd	KEYWORD2
 GetMode	KEYWORD2
 GetError	KEYWORD2
-GetpOnE	KEYWORD2
 GetDirection	KEYWORD2
 analogReadFast	KEYWORD2
 
@@ -35,5 +34,3 @@ AUTOMATIC	LITERAL1
 MANUAL	LITERAL1
 DIRECT	LITERAL1
 REVERSE	LITERAL1
-P_ON_E	LITERAL1
-P_ON_M	LITERAL1

library.json

@@ -1,7 +1,7 @@
 {
   "name": "QuickPID",
   "keywords": "PID, controller, signal",
-  "description": "A fast, fixed point PID controller that seeks to keep an input variable close to a desired setpoint by adjusting an output. The way in which it does this can be 'tuned' by adjusting three parameters (P,I,D).",
+  "description": "QuickPID controller - a faster implementation of the Arduino PID Library with more features. This hybrid fixed/floating point controller seeks to keep an output close to a desired setpoint  by adjusting four parameters (P,I,D) and POn (PonE, PonM setpoint weighting).",
   "url": "https://github.com/Dlloydev/QuickPID",
   "include": "QuickPID",
   "authors":

library.properties

@@ -1,9 +1,9 @@
 name=QuickPID
 version=2.0.3
-author=dlloydev 
-maintainer=dlloydev
-sentence=QuickPID controller
-paragraph=A fast, fixed point PID controller that seeks to keep an input variable close to a desired setpoint by adjusting an output. The way in which it does this can be 'tuned' by adjusting three parameters (P,I,D).
+author=dlloydev
+maintainer=David Lloyd <dlloydev@testcor.ca>
+sentence=QuickPID controller - a faster hybrid fixed/floating point implementation of the Arduino PID Library with more features.
+paragraph=This controller seeks to keep an output close to a desired setpoint  by adjusting four parameters (P,I,D) and POn (PonE, PonM setpoint weighting).
 category=Signal Input/Output
 url=https://github.com/Dlloydev/QuickPID
-architectures=* 
+architectures=avr