QuickPID 2.0.4

Added QuickPID_AdaptiveTunings.ino, QuickPID_Basic.ino, QuickPID_PonM.ino and QuickPID_RelayOutput.ino to the examples folder. Note thatQuickPID_RelayOutput.ino has the added feature of minWindow setting that sets the minimum on time for the relay.

Author: Dlloydev

QuickPID.cpp

@@ -1,5 +1,5 @@
 /**********************************************************************************
-   QuickPID Library for Arduino - Version 2.0.3
+   QuickPID Library for Arduino - Version 2.0.4
    by dlloydev https://github.com/Dlloydev/QuickPID
    Based on the Arduino PID Library by Brett Beauregard
 
@@ -28,7 +28,6 @@ QuickPID::QuickPID(int16_t* Input, int16_t* Output, int16_t* Setpoint,
 
   QuickPID::SetOutputLimits(0, 255);  // default is same as the arduino PWM limit
   SampleTimeUs = 100000;              // default is 0.1 seconds
-
   QuickPID::SetControllerDirection(ControllerDirection);
   QuickPID::SetTunings(Kp, Ki, Kd, POn);
 
@@ -42,7 +41,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, pOn, ControllerDirection)
+  : QuickPID::QuickPID(Input, Output, Setpoint, Kp, Ki, Kd, POn, ControllerDirection)
 {
 
 }
@@ -91,6 +90,7 @@ void QuickPID::SetTunings(float Kp, float Ki, float Kd, float POn)
   if (Kp < 0 || Ki < 0 || Kd < 0) return;
 
   pOn = POn;
+
   dispKp = Kp; dispKi = Ki; dispKd = Kd;
 
   float SampleTimeSec = (float)SampleTimeUs / 1000000;
@@ -112,7 +112,7 @@ void QuickPID::SetTunings(float Kp, float Ki, float Kd, float POn)
    Set Tunings using the last remembered POn setting.
  ******************************************************************************/
 void QuickPID::SetTunings(float Kp, float Ki, float Kd) {
-  SetTunings(Kp, Ki, Kd, pOn);
+  SetTunings(Kp, Ki, Kd, POn);
 }
 
 /* SetSampleTime(...) *********************************************************

README.md

@@ -62,7 +62,7 @@ Development began with a fork of the Arduino PID Library. Some modifications and
 outputSum += (kpi * error) - (kpd * dInput);
 ```
 
-The new `kpi` and `kpd` parameters are calculated in the `SetTunings()` function. This results in a simple and fast algorithm with only two multiply operations required The POn parameter controls the setpoint weighting of Proportional on Error and Proportional on Measurement. The gains for `error` (`kpi`) and measurement `dInput` (`kpd`) are calculated in the `QuickPID::SetTunings()` function as follows:
+The new `kpi` and `kpd` parameters are calculated in the `SetTunings()` function. This results in a simple and fast algorithm with only two multiply operations required The pOn variable controls the setpoint weighting of Proportional on Error and Proportional on Measurement. The gains for `error` (`kpi`) and measurement `dInput` (`kpd`) are calculated as follows:
 
 ```c++
  kpi = kp * pOn + ki;
@@ -172,11 +172,14 @@ int QuickPID::analogReadFast(int ADCpin)
 A faster configuration of `analogRead()`where a preset of 32 is used. Works with the following defines:
 
 `__AVR_ATmega328P__`
+
 `__AVR_ATtiny_Zero_One__`
+
 `__AVR_ATmega_Zero__`
+
 `__AVR_DA__`
 
-Uses Arduino's default settings and returns `analogRead()` if the definition isn't found. 
+ If the definition isn't found, normal `analogRead()`is used to return a value.
 
 ### Original README (Arduino PID)
 

examples/QuickPID_AdaptiveTunings/QuickPID_AdaptiveTunings.ino

@@ -0,0 +1,52 @@
+/********************************************************
+   PID Adaptive Tuning Example
+   One of the benefits of the PID library is that you can
+   change the tuning parameters at any time.  this can be
+   helpful if we want the controller to be agressive at some
+   times, and conservative at others.   in the example below
+   we set the controller to use Conservative Tuning Parameters
+   when we're near setpoint and more agressive Tuning
+   Parameters when we're farther away.
+ ********************************************************/
+
+#include <QuickPID.h>
+
+#define PIN_INPUT 0
+#define PIN_OUTPUT 3
+
+//Define Variables we'll be connecting to
+int Setpoint, Input, Output;
+
+//Define the aggressive and conservative and POn Tuning Parameters
+float aggKp = 4, aggKi = 0.2, aggKd = 1;
+float consKp = 1, consKi = 0.05, consKd = 0.25;
+float aggPOn = 1.0; // Range is 0.0 to 1.0 (1.0 is 100% P on Error, 0% P on Measurement)
+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);
+
+void setup()
+{
+  //initialize the variables we're linked to
+  Input = myQuickPID.analogReadFast(PIN_INPUT);
+  Setpoint = 100;
+
+  //turn the PID on
+  myQuickPID.SetMode(AUTOMATIC);
+}
+
+void loop()
+{
+  Input = myQuickPID.analogReadFast(PIN_INPUT);
+
+  float gap = abs(Setpoint - Input); //distance away from setpoint
+  if (gap < 10) { //we're close to setpoint, use conservative tuning parameters
+    myQuickPID.SetTunings(consKp, consKi, consKd, consPOn);
+  } else {
+    //we're far from setpoint, use aggressive tuning parameters
+    myQuickPID.SetTunings(aggKp, aggKi, aggKd, aggPOn);
+  }
+  myQuickPID.Compute();
+  analogWrite(PIN_OUTPUT, Output);
+}

examples/QuickPID_Basic/QuickPID_Basic.ino

@@ -0,0 +1,35 @@
+/********************************************************
+   PID Basic Example
+   Reading analog input 0 to control analog PWM output 3
+ ********************************************************/
+
+#include <QuickPID.h>
+
+#define PIN_INPUT 0
+#define PIN_OUTPUT 3
+
+//Define Variables we'll be connecting to
+int Setpoint, Input, Output;
+
+//Specify the links and initial tuning parameters
+float Kp = 2, Ki = 5, Kd = 1;
+float POn = 1.0; // Range is 0.0 to 1.0 (1.0 is 100% P on Error, 0% P on Measurement)
+
+QuickPID myQuickPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, POn, DIRECT);
+
+void setup()
+{
+  //initialize the variables we're linked to
+  Input = myQuickPID.analogReadFast(PIN_INPUT);
+  Setpoint = 100;
+
+  //turn the PID on
+  myQuickPID.SetMode(AUTOMATIC);
+}
+
+void loop()
+{
+  Input = myQuickPID.analogReadFast(PIN_INPUT);
+  myQuickPID.Compute();
+  analogWrite(PIN_OUTPUT, Output);
+}

examples/QuickPID_PonM/QuickPID_PonM.ino

@@ -0,0 +1,33 @@
+/********************************************************
+   PID Proportional on measurement Example
+   Setting the PID to use Proportional on measurement will
+   make the output move more smoothly when the setpoint
+   is changed.  In addition, it can eliminate overshoot
+   in certain processes like sous-vides.
+ ********************************************************/
+
+#include <QuickPID.h>
+
+//Define Variables we'll be connecting to
+int 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);
+
+void setup()
+{
+  //initialize the variables we're linked to
+  Input = myQuickPID.analogReadFast(0);
+  Setpoint = 100;
+
+  //turn the PID on
+  myQuickPID.SetMode(AUTOMATIC);
+}
+
+void loop()
+{
+  Input = myQuickPID.analogReadFast(0);
+  myQuickPID.Compute();
+  analogWrite(3, Output);
+}

examples/QuickPID_RC_Filter/QuickPID_RC_Filter.ino

@@ -6,9 +6,9 @@
    https://github.com/Dlloydev/QuickPID/wiki/QuickPID_RC_Filter
  **************************************************************/
 
-#include "QuickPID.h"
+#include <QuickPID.h>
 
-#define PIN_INPUT  A0
+#define PIN_INPUT   0
 #define PIN_OUTPUT  3
 
 //Define Variables
@@ -20,14 +20,15 @@ unsigned long before, after;
 int cnt = 0;
 
 //Specify the initial tuning parameters
-float Kp = 2.0, Ki = 15.0, Kd = 0.05, POn = 1.0;
+float Kp = 2.0, Ki = 15.0, Kd = 0.05;
+float POn = 1.0; // Range is 0.0 to 1.0 (1.0 is 100% P on Error, 0% P on Measurement)
 
-QuickPID myQuickPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);
+QuickPID myQuickPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, POn, DIRECT);
 
 void setup()
 {
   Serial.begin(115200);
-  myQuickPID.SetTunings(Kp, Ki, Kd, POn);
+  myQuickPID.SetTunings(Kp, Ki, Kd);
   myQuickPID.SetMode(AUTOMATIC);
   analogWrite(PIN_OUTPUT, 0); // discharge capacitor
   delay(1000);

examples/QuickPID_RelayOutput/QuickPID_RelayOutput.ino

@@ -0,0 +1,66 @@
+/********************************************************
+   PID RelayOutput Example
+   Same as basic example, except that this time, the output
+   is going to a digital pin which (we presume) is controlling
+   a relay.  the pid is designed to Output an analog value,
+   but the relay can only be On/Off.
+
+     to connect them together we use "time proportioning
+   control"  it's essentially a really slow version of PWM.
+   first we decide on a window size (5000mS say.) we then
+   set the pid to adjust its output between 0 and that window
+   size.  lastly, we add some logic that translates the PID
+   output into "Relay On Time" with the remainder of the
+   window being "Relay Off Time"
+   The minWindow setting is a floor so that the relay would
+   be on for a minimum amount of time.
+ ********************************************************/
+
+#include <QuickPID.h>
+
+#define PIN_INPUT 0
+#define RELAY_PIN 6
+
+//Define Variables we'll be connecting to
+int Setpoint, Input, Output;
+
+//Specify the links and initial tuning parameters
+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);
+
+unsigned int WindowSize = 5000;
+unsigned int minWindow = 500;
+unsigned long windowStartTime;
+
+void setup()
+{
+  pinMode(RELAY_PIN, OUTPUT);
+  windowStartTime = millis();
+
+  //initialize the variables we're linked to
+  Setpoint = 100;
+
+  //tell the PID to range between 0 and the full window size
+  myQuickPID.SetOutputLimits(0, WindowSize);
+
+  //turn the PID on
+  myQuickPID.SetMode(AUTOMATIC);
+}
+
+void loop()
+{
+  Input = analogRead(PIN_INPUT);
+
+  /************************************************
+     turn the output pin on/off based on pid output
+   ************************************************/
+  if (millis() - windowStartTime > WindowSize)
+  { //time to shift the Relay Window
+    windowStartTime += WindowSize;
+    myQuickPID.Compute();
+  }
+  if (((unsigned int)Output > minWindow) && ((unsigned int)Output < (millis() - windowStartTime))) digitalWrite(RELAY_PIN, HIGH);
+  else digitalWrite(RELAY_PIN, LOW);
+}

library.properties

@@ -1,5 +1,5 @@
 name=QuickPID
-version=2.0.3
+version=2.0.4
 author=dlloydev
 maintainer=David Lloyd <[email protected]>
 sentence=QuickPID controller - a faster hybrid fixed/floating point implementation of the Arduino PID Library with more features.