Update Readme

Author: Dlloydev

QuickPID.cpp

@@ -1,34 +1,30 @@
 /**********************************************************************************
    QuickPID Library for Arduino - Version 2.2.3
    by dlloydev https://github.com/Dlloydev/QuickPID
-   Based on the Arduino PID Library by Brett Beauregard
-
-   This Library is licensed under the MIT License
+   Based on the Arduino PID Library, licensed under the MIT License
  **********************************************************************************/
 
 #if ARDUINO >= 100
 #include "Arduino.h"
 #else
 #include "WProgram.h"
 #endif
-
 #include "QuickPID.h"
 
 /* Constructor ********************************************************************
    The parameters specified here are those for for which we can't set up
    reliable defaults, so we need to have the user set them.
  **********************************************************************************/
 QuickPID::QuickPID(int* Input, int* Output, int* Setpoint,
-                   float Kp, float Ki, float Kd, float POn = 1, uint8_t ControllerDirection = 0)
-{
+                   float Kp, float Ki, float Kd, float POn = 1, uint8_t ControllerDirection = 0) {
+
   myOutput = Output;
   myInput = Input;
   mySetpoint = Setpoint;
   inAuto = false;
 
-  QuickPID::SetOutputLimits(0, 255);  // default is same as the arduino PWM limit
-  sampleTimeUs = 100000;              // default is 0.1 seconds
-
+  QuickPID::SetOutputLimits(0, 255);  // same default as Arduino PWM limit
+  sampleTimeUs = 100000;              // 0.1 sec default
   QuickPID::SetControllerDirection(ControllerDirection);
   QuickPID::SetTunings(Kp, Ki, Kd, POn);
 
@@ -39,19 +35,16 @@ QuickPID::QuickPID(int* Input, int* Output, int* Setpoint,
    To allow backwards compatability for v1.1, or for people that just want
    to use Proportional on Error without explicitly saying so.
  **********************************************************************************/
-
 QuickPID::QuickPID(int* Input, int* Output, int* Setpoint,
                    float Kp, float Ki, float Kd, uint8_t ControllerDirection)
-  : QuickPID::QuickPID(Input, Output, Setpoint, Kp, Ki, Kd, pOn = 1, ControllerDirection = 0)
-{
+  : QuickPID::QuickPID(Input, Output, Setpoint, Kp, Ki, Kd, pOn = 1, ControllerDirection = 0) {
 
 }
 
 /* Compute() **********************************************************************
-   This, as they say, is where the magic happens. This function should be called
-   every time "void loop()" executes. The function will decide whether a new
-   PID Output needs to be computed. Returns true when the output is computed,
-   false when nothing has been done.
+   This function should be called every time "void loop()" executes. The function
+   will decide whether a new PID Output needs to be computed. Returns true
+   when the output is computed, false when nothing has been done.
  **********************************************************************************/
 bool QuickPID::Compute() {
   if (!inAuto) return false;
@@ -63,7 +56,7 @@ bool QuickPID::Compute() {
     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
+    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);
@@ -99,10 +92,11 @@ void QuickPID::AutoTune(int inputPin, int outputPin, int tuningRule, int Print =
     { 333,  667, 111 },  // SOME_OVERSHOOT_PID
     { 200,  400,  67 },  // NO_OVERSHOOT_PID
   };
-  const byte ckp = 0, cki = 1, ckd = 2; // c = column
+  const byte ckp = 0, cki = 1, ckd = 2; //c = column
   peakHigh = atSetpoint;
   peakLow = atSetpoint;
   timeout *= 1000;
+
   if (Print == 1) Serial.print("Stabilizing (33%) →");
   QuickPID::Stabilize(inputPin, outputPin, timeout);
   if (Print == 1) Serial.print(" Running AutoTune ↑");
@@ -234,7 +228,7 @@ 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
+  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.
 ******************************************************************************/
@@ -282,19 +276,19 @@ uint8_t QuickPID::GetDirection() {
 int QuickPID::analogReadFast(int ADCpin) {
 #if defined(__AVR_ATmega328P__)
   byte ADCregOriginal = ADCSRA;
-  ADCSRA = (ADCSRA & B11111000) | 5; //32 prescaler
+  ADCSRA = (ADCSRA & B11111000) | 5; // 32 prescaler
   int adc = analogRead(ADCpin);
   ADCSRA = ADCregOriginal;
   return adc;
 #elif defined(__AVR_ATtiny_Zero_One__) || defined(__AVR_ATmega_Zero__)
   byte ADCregOriginal = ADC0_CTRLC;
-  ADC0_CTRLC = 0x54; //reduced cap, Vdd ref, 32 prescaler
+  ADC0_CTRLC = 0x54; // reduced cap, Vdd ref, 32 prescaler
   int adc = analogRead(ADCpin);
   ADC0_CTRLC = ADCregOriginal;
   return adc;
 #elif defined(__AVR_DA__)
   byte ADCregOriginal = ADC0.CTRLC;
-  ADC0.CTRLC = ADC_PRESC_DIV32_gc; //32 prescaler
+  ADC0.CTRLC = ADC_PRESC_DIV32_gc; // 32 prescaler
   int adc = analogRead(ADCpin);
   ADC0.CTRLC = ADCregOriginal;
   return adc;
@@ -325,9 +319,7 @@ void QuickPID::CheckPeak(int inputPin) {
 
 void QuickPID::Stabilize(int inputPin, int outputPin, uint32_t timeout) {
   // initial reading
-  for (int i = 0; i <= 16; i++) {
-    analogReadAvg(inputPin);
-  }
+  for (int i = 0; i <= 16; i++) analogReadAvg(inputPin);
   // coarse adjust
   analogWrite (outputPin, 0);
   while ((analogReadAvg(inputPin) > (atSetpoint - hysteresis)) && (millis() <= timeout));

QuickPID.h

@@ -1,8 +1,7 @@
 #ifndef QuickPID_h
 #define QuickPID_h
 
-class QuickPID
-{
+class QuickPID {
 
   public:
 
@@ -12,6 +11,9 @@ class QuickPID
 #define DIRECT  0
 #define REVERSE 1
 
+static const byte TRY_DIRECT = 0;
+static const byte TRY_AUTOMATIC = 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
 #define CONSTRAIN(x,lower,upper)    ((x)<(lower)?(lower):((x)>(upper)?(upper):(x)))
@@ -74,7 +76,7 @@ class QuickPID
     void StepDown(int, int, uint32_t);
     void Stabilize(int, int, uint32_t);
 
-    float dispKp;      // We'll hold on to the tuning parameters for display purposes.
+    float dispKp;      // tuning parameters for display purposes.
     float dispKi;
     float dispKd;
     float dispKu;
@@ -113,4 +115,4 @@ class QuickPID
 #include "utility/analogWrite.h"
 #endif
 
-#endif //QuickPID.h
+#endif // QuickPID.h

README.md

@@ -53,36 +53,36 @@ The new `kpi` and `kpd` parameters are calculated in the `SetTunings()` function
 
 ```c++
 QuickPID::QuickPID(int* Input, int* Output, int* Setpoint,
-                   float Kp, float Ki, float Kd, float POn, uint8_t ControllerDirection)
+                   float Kp, float Ki, float Kd, float POn, uint8_t ControllerDirection);
 ```
 
 - `Input`, `Output`, and `Setpoint` are pointers to the variables holding these values.
 - `Kp`, `Ki`, and `Kd` are the PID proportional, integral, and derivative gains.
 - `POn` is the Proportional on Error weighting value (0.0-1.0). This controls the mix of Proportional on Error (PonE) and  Proportional on Measurement (PonM) that's used in the compute algorithm. Note that POn controls the PonE amount, where the remainder (1-PonE) is the PonM amount. Also, the default POn is 1
 
-![POn](https://user-images.githubusercontent.com/63488701/104958919-fe3c4680-599e-11eb-851e-73f26291d3e5.gif)
+<img src="https://user-images.githubusercontent.com/63488701/104958919-fe3c4680-599e-11eb-851e-73f26291d3e5.gif" alt="POn" style="zoom: 67%;" />
 
 - `ControllerDirection` Either DIRECT or REVERSE determines which direction the output will move for a given error. DIRECT is most common.
 
 ```c++
 QuickPID::QuickPID(int* Input, int* Output, int* Setpoint,
-                   float Kp, float Ki, float Kd, uint8_t ControllerDirection)
+                   float Kp, float Ki, float Kd, uint8_t ControllerDirection);
 ```
 
 This allows you to use Proportional on Error without explicitly saying so.
 
 #### Compute
 
 ```c++
-bool QuickPID::Compute()
+bool QuickPID::Compute();
 ```
 
 This function contains the PID algorithm and it should be called once every loop(). Most of the time it will just return false without doing anything. However, at a  frequency specified by `SetSampleTime` it will calculate a new Output and return true.
 
 #### [AutoTune](https://github.com/Dlloydev/QuickPID/wiki/AutoTune)
 
 ```c++
-void QuickPID::AutoTune(int inputPin, int outputPin, int tuningRule, int Print = 0, uint32_t timeout = 30)
+void QuickPID::AutoTune(int inputPin, int outputPin, int tuningRule, int Print = 0, uint32_t timeout = 30);
 ```
 
 The `AutoTune()` function automatically determines and sets `Kp`, `Ki` and `Kd`. It also determines the critical gain `Ku` and critical period `Tu` of the control system. 
@@ -98,45 +98,45 @@ Sets the AutoTune timeout where the default is 120 seconds.
 #### SetTunings
 
 ```c++
-void QuickPID::SetTunings(float Kp, float Ki, float Kd, float POn)
+void QuickPID::SetTunings(float Kp, float Ki, float Kd, float POn);
 ```
 
 This function allows the controller's dynamic performance to be adjusted. It's called automatically from the constructor, but tunings can also be adjusted on the fly during normal operation. The parameters are as described in the constructor.
 
 ```c++
-void QuickPID::SetTunings(float Kp, float Ki, float Kd)
+void QuickPID::SetTunings(float Kp, float Ki, float Kd);
 ```
 
 Set Tunings using the last remembered POn setting.
 
 #### SetSampleTime
 
 ```c++
-void QuickPID::SetSampleTimeUs(uint32_t NewSampleTimeUs)
+void QuickPID::SetSampleTimeUs(uint32_t NewSampleTimeUs);
 ```
 
 Sets the period, in microseconds, at which the calculation is performed. The default is 100ms.
 
 #### SetOutputLimits
 
 ```c++
-void QuickPID::SetOutputLimits(int Min, int Max)
+void QuickPID::SetOutputLimits(int Min, int Max);
 ```
 
 The PID controller is designed to vary its output within a given range.  By default this range is 0-255, the Arduino PWM range.
 
 #### SetMode
 
 ```c++
-void QuickPID::SetMode(uint8_t Mode)
+void QuickPID::SetMode(uint8_t Mode);
 ```
 
 Allows the controller Mode to be set to `MANUAL` (0) or `AUTOMATIC` (non-zero). when the transition from manual to automatic occurs, the controller is automatically initialized.
 
 #### Initialize
 
 ```c++
-void QuickPID::Initialize()
+void QuickPID::Initialize();
 ```
 
 Does all the things that need to happen to ensure a bump-less transfer from manual to automatic mode.
@@ -152,14 +152,14 @@ The PID will either be connected to a DIRECT acting process (+Output leads to +I
 #### Display_Functions
 
 ```c++
-float QuickPID::GetKp()
-float QuickPID::GetKi()
-float QuickPID::GetKd()
-float QuickPID::GetKu()
-float QuickPID::GetTu()
-float QuickPID::GetTd()
-uint8_t QuickPID::GetMode()
-uint8_t QuickPID::GetDirection()
+float QuickPID::GetKp();
+float QuickPID::GetKi();
+float QuickPID::GetKd();
+float QuickPID::GetKu();
+float QuickPID::GetTu();
+float QuickPID::GetTd();
+uint8_t QuickPID::GetMode();
+uint8_t QuickPID::GetDirection();
 ```
 
 These functions query the internal state of the PID. They're here for display purposes.
@@ -174,6 +174,8 @@ A faster configuration of `analogRead()`where a preset of 32 is used.  If the ar
 
 #### [AnalogWrite (PWM and DAC) for ESP32](https://github.com/Dlloydev/ESP32-ESP32S2-AnalogWrite)
 
+Use this link for reference. Note that if you're using QuickPID, there's no need to install the AnalogWrite library as this feature is already included.
+
 #### Change Log
 
 #### [![arduino-library-badge](https://www.ardu-badge.com/badge/QuickPID.svg?)](https://www.ardu-badge.com/QuickPID)

examples/AutoTune_RC_Filter/AutoTune_RC_Filter.ino

@@ -24,7 +24,7 @@ const byte outputPin = 3;
 
 int Print = 0;                // on(1) monitor, off(0) plotter
 int tuningRule = 1;           // see above table
-float POn = 1.0;              // Mix of PonE to PonM (0.0-1.0)
+float POn = 1.0;              // mix of PonE to PonM (0.0-1.0)
 unsigned long timeout = 120;  // AutoTune timeout (sec)
 
 int Input, Output, Setpoint;
@@ -52,7 +52,7 @@ void setup()
     Serial.print("  Kp: "); Serial.print(myQuickPID.GetKp());
     Serial.print("  Ki: "); Serial.print(myQuickPID.GetKi());
     Serial.print("  Kd: "); Serial.println(myQuickPID.GetKd());
-    delay(6000);
+    delay(3000);
   }
 }