Update

Dlloydev · Dlloydev · commit f326bbbc1b2d · 2021-05-08T13:40:36.000-04:00
- Fixed REVERSE acting controller mode.
- now using src folder for source code
- replaced defines with enumerated types and inline functions
diff --git a/LICENSE b/LICENSE
@@ -1,4 +1,3 @@
-Copyright 2011-2017 Brett Beauregard <br3ttb@gmail.com> brettbeauregard.com
 Copyright 2021 David Lloyd <dlloydev@testcor.ca>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -16,4 +15,4 @@ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/README.md b/README.md
@@ -47,6 +47,10 @@ The new `kpi` and `kpd` parameters are calculated in the `SetTunings()` function
  kpd = kp * (1 - pOn) + kd;
 ```
 
+### Controller Action
+
+If a positive error increases the controller's output, the controller is said to be direct acting (i.e. heating process). When a positive error decreases the controller's output, the controller is said to be reverse acting (i.e. cooling process). Since the PWM and ADC peripherals on microcontrollers only operate with positive values, QuickPID only uses positive values for Input, Output and Setpoint. When the controller is set to `REVERSE` acting, the sign of the `error` and `dInput` (derivative of Input) is internally changed. All operating ranges and limits remain the same. To simulate a `REVERSE` acting process from a process that's  `DIRECT` acting, the Input value needs to be "flipped". That is, if your reading from a 10-bit ADC with 0-1023 range, the input value used is (1023 - reading). See the example [AutoTune_RC_Filter.ino](https://github.com/Dlloydev/QuickPID/blob/master/examples/AutoTune_RC_Filter/AutoTune_RC_Filter.ino) for details.
+
 ### Functions
 
 #### QuickPID_Constructor
@@ -180,6 +184,12 @@ Use this link for reference. Note that if you're using QuickPID, there's no need
 
 #### [![arduino-library-badge](https://www.ardu-badge.com/badge/QuickPID.svg?)](https://www.ardu-badge.com/QuickPID)
 
+#### Version 2.2.7
+
+- Fixed REVERSE acting controller mode.
+- now using src folder for source code 
+- replaced defines with enumerated types and inline functions
+
 #### Version 2.2.6
 
 - Changed Input, Output and Setpoint parameters to float.
diff --git a/examples/AutoTune_RC_Filter/AutoTune_RC_Filter.ino b/examples/AutoTune_RC_Filter/AutoTune_RC_Filter.ino
@@ -30,7 +30,11 @@ unsigned long timeout = 120;  // AutoTune timeout (sec)
 float Input, Output, Setpoint;
 float Kp = 0, Ki = 0, Kd = 0;
 
-QuickPID myQuickPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, POn, DIRECT);
+// choose controller direction:
+// DIRECT: Input increases when the output is increased or the error is positive (heating).
+// REVERSE: Input decreases when the output is increased or when the error is positive (cooling).
+QuickPID myQuickPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, POn, QuickPID::DIRECT);
+//QuickPID myQuickPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, POn, QuickPID::REVERSE);
 
 void setup()
 {
@@ -39,8 +43,8 @@ void setup()
 
   myQuickPID.AutoTune(inputPin, outputPin, tuningRule, Print, timeout);
   myQuickPID.SetTunings(myQuickPID.GetKp(), myQuickPID.GetKi(), myQuickPID.GetKd());
-  myQuickPID.SetSampleTimeUs(5000); // recommend 5000µs (5ms) minimum
-  myQuickPID.SetMode(AUTOMATIC);
+  myQuickPID.SetSampleTimeUs(4000); // 4ms
+  myQuickPID.SetMode(QuickPID::AUTOMATIC);
   Setpoint = 700;
 
   if (Print == 1) {
@@ -66,7 +70,11 @@ void loop()
   Serial.print("Output:");    Serial.print(Output);    Serial.print(",");
   Serial.println(",");
 
-  Input = myQuickPID.analogReadFast(inputPin);
+  if (myQuickPID.GetDirection() == QuickPID::REVERSE) {
+    Input = (1023 - myQuickPID.analogReadFast(inputPin)); // simulate reverse acting controller (cooling)
+  } else {
+    Input = (myQuickPID.analogReadFast(inputPin));
+  }
   myQuickPID.Compute();
   analogWrite(outputPin, Output);
 }
diff --git a/examples/QuickPID_AdaptiveTunings/QuickPID_AdaptiveTunings.ino b/examples/QuickPID_AdaptiveTunings/QuickPID_AdaptiveTunings.ino
@@ -24,7 +24,7 @@ float aggPOn = 1.0; // Range is 0.0 to 1.0 (1.0 is 100% P on Error, 0% P on Meas
 float consPOn = 0.0; // Range is 0.0 to 1.0 (0.0 is 0% P on Error, 100% P on Measurement)
 
 //Specify the links and initial tuning parameters
-QuickPID myQuickPID(&Input, &Output, &Setpoint, consKp, consKi, consKd, aggPOn, DIRECT);
+QuickPID myQuickPID(&Input, &Output, &Setpoint, consKp, consKi, consKd, aggPOn, QuickPID::DIRECT);
 
 void setup()
 {
@@ -33,7 +33,7 @@ void setup()
   Setpoint = 100;
 
   //turn the PID on
-  myQuickPID.SetMode(AUTOMATIC);
+  myQuickPID.SetMode(QuickPID::AUTOMATIC);
 }
 
 void loop()
diff --git a/examples/QuickPID_Basic/QuickPID_Basic.ino b/examples/QuickPID_Basic/QuickPID_Basic.ino
@@ -14,7 +14,7 @@ float Setpoint, Input, Output;
 //Specify the links and initial tuning parameters
 float Kp = 2, Ki = 5, Kd = 1;
 
-QuickPID myQuickPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);
+QuickPID myQuickPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, QuickPID::DIRECT);
 
 void setup()
 {
@@ -23,7 +23,7 @@ void setup()
   Setpoint = 100;
 
   //turn the PID on
-  myQuickPID.SetMode(AUTOMATIC);
+  myQuickPID.SetMode(QuickPID::AUTOMATIC);
 }
 
 void loop()
diff --git a/examples/QuickPID_PonM/QuickPID_PonM.ino b/examples/QuickPID_PonM/QuickPID_PonM.ino
@@ -13,7 +13,7 @@ float Setpoint, Input, Output;
 float POn = 0.0; // Range is 0.0 to 1.0 (0.0 is 0% P on Error, 100% P on Measurement)
 
 //Specify the links and initial tuning parameters
-QuickPID myQuickPID(&Input, &Output, &Setpoint, 2, 5, 1, POn, DIRECT);
+QuickPID myQuickPID(&Input, &Output, &Setpoint, 2, 5, 1, POn, QuickPID::DIRECT);
 
 void setup()
 {
@@ -22,7 +22,7 @@ void setup()
   Setpoint = 100;
 
   //turn the PID on
-  myQuickPID.SetMode(AUTOMATIC);
+  myQuickPID.SetMode(QuickPID::AUTOMATIC);
 }
 
 void loop()
diff --git a/examples/QuickPID_RelayOutput/QuickPID_RelayOutput.ino b/examples/QuickPID_RelayOutput/QuickPID_RelayOutput.ino
@@ -28,7 +28,7 @@ float Setpoint, Input, Output;
 float Kp = 2, Ki = 5, Kd = 1;
 float POn = 0.0; // Range is 0.0 to 1.0 (0.0 is 0% P on Error, 100% P on Measurement)
 
-QuickPID myQuickPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, POn, DIRECT);
+QuickPID myQuickPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, POn, QuickPID::DIRECT);
 
 unsigned int WindowSize = 5000;
 unsigned int minWindow = 500;
@@ -46,7 +46,7 @@ void setup()
   myQuickPID.SetOutputLimits(0, WindowSize);
 
   //turn the PID on
-  myQuickPID.SetMode(AUTOMATIC);
+  myQuickPID.SetMode(QuickPID::AUTOMATIC);
 }
 
 void loop()
diff --git a/keywords.txt b/keywords.txt
@@ -7,6 +7,8 @@
 ##########################################
 
 QuickPID	KEYWORD1
+mode_t	KEYWORD1
+direction_t	KEYWORD1
 analog_write_channel_t	KEYWORD1
 
 ##########################################
diff --git a/library.json b/library.json
@@ -3,7 +3,7 @@
   "keywords": "PID, controller, signal",
   "description": "A fast fixed/floating point PID controller with AutoTune and 9 tuning rules to choose from. This controller can automatically determine and set tuning parameters. Compatible with most Arduino and ESP32 boards.",
   "license": "MIT",
-  "version": "2.2.6",
+  "version": "2.2.7",
   "url": "https://github.com/Dlloydev/QuickPID",
   "include": "QuickPID",
   "authors":
diff --git a/library.properties b/library.properties
@@ -1,5 +1,5 @@
 name=QuickPID
-version=2.2.6
+version=2.2.7
 author=David Lloyd
 maintainer=David Lloyd <dlloydev@testcor.ca>
 sentence=A fast fixed/floating point PID controller with AutoTune and 9 tuning rules to choose from.
diff --git a/src/QuickPID.cpp b/src/QuickPID.cpp
@@ -1,5 +1,5 @@
 /**********************************************************************************
-   QuickPID Library for Arduino - Version 2.2.6
+   QuickPID Library for Arduino - Version 2.2.7
    by dlloydev https://github.com/Dlloydev/QuickPID
    Based on the Arduino PID Library, licensed under the MIT License
  **********************************************************************************/
@@ -17,7 +17,7 @@
    reliable defaults, so we need to have the user set them.
  **********************************************************************************/
 QuickPID::QuickPID(float* Input, float* Output, float* Setpoint,
-                   float Kp, float Ki, float Kd, float POn = 1, uint8_t ControllerDirection = 0) {
+                   float Kp, float Ki, float Kd, float POn = 1, QuickPID::direction_t ControllerDirection = DIRECT) {
 
   myOutput = Output;
   myInput = Input;
@@ -37,9 +37,8 @@ QuickPID::QuickPID(float* Input, float* Output, float* Setpoint,
    to use Proportional on Error without explicitly saying so.
  **********************************************************************************/
 QuickPID::QuickPID(float* Input, float* Output, float* Setpoint,
-                   float Kp, float Ki, float Kd, uint8_t ControllerDirection)
-  : QuickPID::QuickPID(Input, Output, Setpoint, Kp, Ki, Kd, pOn = 1, ControllerDirection = 0) {
-
+                   float Kp, float Ki, float Kd, direction_t ControllerDirection = DIRECT)
+  : QuickPID::QuickPID(Input, Output, Setpoint, Kp, Ki, Kd, pOn = 1, ControllerDirection = DIRECT) {
 }
 
 /* Compute() **********************************************************************
@@ -56,9 +55,12 @@ bool QuickPID::Compute() {
     int input = *myInput;
     int dInput = input - lastInput;
     error = *mySetpoint - input;
-
-    if (kpi < 31 && kpd < 31) outputSum += FX_MUL(FL_FX(kpi) , error) - FX_MUL(FL_FX(kpd), dInput); // fixed point
-    else outputSum += (kpi * error) - (kpd * dInput); // floating-point
+    if (controllerDirection == REVERSE) {
+      error = -error;
+      dInput = -dInput;
+    }
+      if (kpi < 31 && kpd < 31) outputSum += FX_MUL(FL_FX(kpi) , error) - FX_MUL(FL_FX(kpd), dInput); // fixed point
+      else outputSum += (kpi * error) - (kpd * dInput); // floating-point
 
     outputSum = CONSTRAIN(outputSum, outMin, outMax);
     *myOutput = outputSum;
@@ -162,12 +164,6 @@ void QuickPID::SetTunings(float Kp, float Ki, float Kd, float POn = 1) {
   kd = Kd / SampleTimeSec;
   kpi = (kp * pOn) + ki;
   kpd = (kp * (1 - pOn)) + kd;
-
-  if (controllerDirection == REVERSE) {
-    kp = (0 - kp);
-    ki = (0 - ki);
-    kd = (0 - kd);
-  }
 }
 
 /* SetTunings(...)*************************************************************
@@ -209,7 +205,7 @@ void QuickPID::SetOutputLimits(int Min, int Max) {
   when the transition from manual to auto occurs, the controller is
   automatically initialized
 ******************************************************************************/
-void QuickPID::SetMode(uint8_t Mode) {
+void QuickPID::SetMode(mode_t Mode) {
   bool newAuto = (Mode == AUTOMATIC);
   if (newAuto && !inAuto) { //we just went from manual to auto
     QuickPID::Initialize();
@@ -229,17 +225,10 @@ void QuickPID::Initialize() {
 
 /* SetControllerDirection(...)*************************************************
   The PID will either be connected to a DIRECT acting process (+Output leads
-  to +Input) or a REVERSE acting process(+Output leads to -Input.)  We need to
-  know which one, because otherwise we may increase the output when we should
-  be decreasing.  This is called from the constructor.
+  to +Input) or a REVERSE acting process(+Output leads to -Input.)
 ******************************************************************************/
-void QuickPID::SetControllerDirection(uint8_t Direction) {
-  if (inAuto && Direction != controllerDirection) {
-    kp = (0 - kp);
-    ki = (0 - ki);
-    kd = (0 - kd);
-  }
-  controllerDirection = Direction;
+void QuickPID::SetControllerDirection(direction_t ControllerDirection) {
+  controllerDirection = ControllerDirection;
 }
 
 /* Status Functions************************************************************
@@ -265,10 +254,11 @@ float QuickPID::GetTu() {
 float QuickPID::GetTd() {
   return  dispTd;
 }
-uint8_t QuickPID::GetMode() {
-  return  inAuto ? AUTOMATIC : MANUAL;
+QuickPID::mode_t QuickPID::GetMode() {
+  return  inAuto ? QuickPID::AUTOMATIC : QuickPID::MANUAL;
 }
-uint8_t QuickPID::GetDirection() {
+
+QuickPID::direction_t QuickPID::GetDirection() {
   return controllerDirection;
 }
 
diff --git a/src/QuickPID.h b/src/QuickPID.h
diff --git a/src/analogWrite.cpp b/src/analogWrite.cpp
diff --git a/src/analogWrite.h b/src/analogWrite.h

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ float aggPOn = 1.0; // Range is 0.0 to 1.0 (1.0 is 100% P on Error, 0% P on Meas`
`24`	`24`	`float consPOn = 0.0; // Range is 0.0 to 1.0 (0.0 is 0% P on Error, 100% P on Measurement)`
`25`	`25`
`26`	`26`	`//Specify the links and initial tuning parameters`
`27`		`-QuickPID myQuickPID(&Input, &Output, &Setpoint, consKp, consKi, consKd, aggPOn, DIRECT);`
	`27`	`+QuickPID myQuickPID(&Input, &Output, &Setpoint, consKp, consKi, consKd, aggPOn, QuickPID::DIRECT);`
`28`	`28`
`29`	`29`	`void setup()`
`30`	`30`	`{`
`@@ -33,7 +33,7 @@ void setup()`
`33`	`33`	`Setpoint = 100;`
`34`	`34`
`35`	`35`	`//turn the PID on`
`36`		`- myQuickPID.SetMode(AUTOMATIC);`
	`36`	`+ myQuickPID.SetMode(QuickPID::AUTOMATIC);`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`void loop()`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ float Setpoint, Input, Output;`
`14`	`14`	`//Specify the links and initial tuning parameters`
`15`	`15`	`float Kp = 2, Ki = 5, Kd = 1;`
`16`	`16`
`17`		`-QuickPID myQuickPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);`
	`17`	`+QuickPID myQuickPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, QuickPID::DIRECT);`
`18`	`18`
`19`	`19`	`void setup()`
`20`	`20`	`{`
`@@ -23,7 +23,7 @@ void setup()`
`23`	`23`	`Setpoint = 100;`
`24`	`24`
`25`	`25`	`//turn the PID on`
`26`		`- myQuickPID.SetMode(AUTOMATIC);`
	`26`	`+ myQuickPID.SetMode(QuickPID::AUTOMATIC);`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`void loop()`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ float Setpoint, Input, Output;`
`13`	`13`	`float POn = 0.0; // Range is 0.0 to 1.0 (0.0 is 0% P on Error, 100% P on Measurement)`
`14`	`14`
`15`	`15`	`//Specify the links and initial tuning parameters`
`16`		`-QuickPID myQuickPID(&Input, &Output, &Setpoint, 2, 5, 1, POn, DIRECT);`
	`16`	`+QuickPID myQuickPID(&Input, &Output, &Setpoint, 2, 5, 1, POn, QuickPID::DIRECT);`
`17`	`17`
`18`	`18`	`void setup()`
`19`	`19`	`{`
`@@ -22,7 +22,7 @@ void setup()`
`22`	`22`	`Setpoint = 100;`
`23`	`23`
`24`	`24`	`//turn the PID on`
`25`		`- myQuickPID.SetMode(AUTOMATIC);`
	`25`	`+ myQuickPID.SetMode(QuickPID::AUTOMATIC);`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`void loop()`