Update

Assorted minor updates

Author: Dlloydev

README.md

@@ -2,6 +2,8 @@
 
 QuickPID is an updated implementation of the Arduino PID library with a built-in [AutoTune](https://github.com/Dlloydev/QuickPID/wiki/AutoTune) class as a dynamic object  to reduce memory if not used, thanks to contributions by [gnalbandian (Gonzalo)](https://github.com/gnalbandian). This controller can automatically determine and set parameters `Kp, Ki, Kd`. Additionally the Ultimate Gain `Ku`, Ultimate Period `Tu`, Dead Time `td` and determine how easy the process is to control. There are 10 tuning rules available to choose from. Also available are POn and DOn settings where POn controls the mix of Proportional on Error to Proportional on Measurement and DOn controls the mix of Derivative on Error to Derivative on Measurement.
 
+#### [QuickPID WiKi ...](https://github.com/Dlloydev/QuickPID/wiki)
+
 ### Features
 
 Development began with a fork of the Arduino PID Library. Modifications and new features have been added as described in the [change log](https://github.com/Dlloydev/QuickPID/wiki/Change-Log).
@@ -27,15 +29,15 @@ Development began with a fork of the Arduino PID Library. Modifications and new
 - [x] Determines how easy the process is to control
 - [x] Determines ultimate period `Tu`, dead time `td`, ultimate gain `Ku`, and tuning parameters `Kp, Ki, Kd`
 
-### [AutoTune RC Filter](https://github.com/Dlloydev/QuickPID/wiki/AutoTune_RC_Filter)
+### [AutoTune](https://github.com/Dlloydev/QuickPID/wiki/AutoTune)
 
-This example allows you to experiment with the AutoTunePID class, various tuning rules and the POn and DOn controls using ADC and PWM with RC filter. It automatically determines and sets the tuning parameters and works with both DIRECT and REVERSE acting controllers.
+#### [AutoTune Filter Examples](https://github.com/Dlloydev/QuickPID/wiki/AutoTune-Filter-Examples)
 
-#### [QuickPID WiKi ...](https://github.com/Dlloydev/QuickPID/wiki)
+The examples [AutoTune_Filter_DIRECT.ino](https://github.com/Dlloydev/QuickPID/blob/master/examples/AutoTune_Filter_DIRECT/AutoTune_Filter_DIRECT.ino) and [AutoTune_Filter_REVERSE.ino](https://github.com/Dlloydev/QuickPID/blob/master/examples/AutoTune_Filter_REVERSE/AutoTune_Filter_REVERSE.ino) allow you to experiment with the AutoTunePID class, various tuning rules and the POn and DOn controls using ADC and PWM with RC filter. It automatically determines and sets the tuning parameters and works with both `DIRECT` and `REVERSE` acting controllers.
 
-### Direct and Reverse Controller Action
+#### Direct and Reverse 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). 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 examples  [AutoTune_Filter_DIRECT.ino](https://github.com/Dlloydev/QuickPID/blob/master/examples/AutoTune_Filter_DIRECT/AutoTune_Filter_DIRECT.ino) and [AutoTune_Filter_REVERSE.ino](https://github.com/Dlloydev/QuickPID/blob/master/examples/AutoTune_Filter_REVERSE/AutoTune_Filter_REVERSE.ino) for details.
+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). 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). 
 
 ### Functions
 
@@ -70,10 +72,6 @@ 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)
-
-For examples using AutoTune, please refer to the examples folder.
-
 #### SetTunings
 
 ```c++

examples/AutoTune_AVR_Interrupt_TIMER/AutoTune_AVR_Interrupt_TIMER.ino

@@ -24,7 +24,7 @@ int output = 85;          // 1/3 of range for symetrical waveform
 float Input, Output, Setpoint;
 float Kp = 0, Ki = 0, Kd = 0;
 bool pidLoop = false;
-static boolean computeNow = false;
+volatile bool computeNow = false;
 
 QuickPID _myPID = QuickPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, POn, DOn, QuickPID::DIRECT);
 

examples/PID_AVR_Basic_Interrupt_TIMER/PID_AVR_Basic_Interrupt_TIMER.ino

@@ -8,7 +8,7 @@
 #define PIN_INPUT 0
 #define PIN_OUTPUT 3
 const uint32_t sampleTimeUs = 100000; // 100ms
-static boolean computeNow = false;
+volatile bool computeNow = false;
 
 //Define Variables we'll be connecting to
 float Setpoint, Input, Output;

library.json

@@ -1,21 +1,27 @@
 {
   "name": "QuickPID",
+  "version": "2.4.2",
+  "description": "A fast PID controller with an AutoTune dynamic object, 10 tunung rules, Integral anti-windup, TIMER Mode, variable Proportional and Derivative on Error to Measurement and full-featured Arduino analogWrite compatibility for ESP32 and ESP32-S2.",
   "keywords": "PID, controller, signal",
-  "description": "A fast PID controller with AutoTune and 10 tuning rules. Compatible with most Arduino and ESP32 boards.",
-  "license": "MIT",
-  "version": "2.4.1",
-  "url": "https://github.com/Dlloydev/QuickPID",
-  "include": "QuickPID",
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/Dlloydev/QuickPID"
+  },
   "authors":
   [
     {
       "name": "David Lloyd"
+      "email": "[email protected]",
+      "url": "https://github.com/Dlloydev/QuickPID",
+      "maintainer": true
     }
   ],
-  "repository":
-  {
-    "type": "git",
-    "url": "https://github.com/Dlloydev/QuickPID"
+  "license": "MIT",
+  "homepage": "https://github.com/Dlloydev/QuickPID",
+  "dependencies": {
+    "QuickPID": "~2.4.2"
   },
-  "frameworks": "arduino"
+  "frameworks": "*",
+  "platforms": "*"
 }

library.properties

@@ -1,10 +1,10 @@
 name=QuickPID
-version=2.4.1
+version=2.4.2
 author=David Lloyd
 maintainer=David Lloyd <[email protected]>
-sentence=A fast PID controller with AutoTune and 10 tuning rules.
-paragraph=This controller can automatically determine and set tuning parameters. Compatible with most Arduino and ESP32 boards.
+sentence=A fast PID controller with AutoTune, integral anti-windup and variable controls for Proportional and Derivative on Error to Measurement.
+paragraph=A fast PID controller with an AutoTune dynamic object, 10 tunung rules, Integral anti-windup, TIMER Mode, variable Proportional and Derivative on Error to Measurement and full-featured Arduino analogWrite compatibility for ESP32 and ESP32-S2.
 category=Signal Input/Output
 url=https://github.com/Dlloydev/QuickPID
 architectures=*
-includes=QuickPID.h
+includes=QuickPID.h,analogWrite.h

src/QuickPID.cpp

@@ -1,5 +1,5 @@
 /**********************************************************************************
-   QuickPID Library for Arduino - Version 2.4.1
+   QuickPID Library for Arduino - Version 2.4.2
    by dlloydev https://github.com/Dlloydev/QuickPID
    Based on the Arduino PID Library and work on AutoTunePID class
    by gnalbandian (Gonzalo). Licensed under the MIT License.
@@ -66,7 +66,7 @@ bool QuickPID::Compute() {
     deTerm = -kde * error;
 
     outputSum += iTerm;
-    if (outputSum > outMax) iTerm -= outputSum - outMax; // prevent integral windup
+    if (outputSum > outMax) iTerm -= outputSum - outMax; // integral anti-windup
     else if (outputSum < outMin) iTerm += outMin - outputSum;
 
     float output = peTerm;
@@ -358,9 +358,9 @@ byte AutoTunePID::autoTuneLoop() {
         _ki = _kp / Ti;
         _kd = Td * _kp;
       } else { //other rules
-        _kp = RulesContants[static_cast<uint8_t>(_tuningRule)][0] / 1000.0 * _Ku;
-        _ki = RulesContants[static_cast<uint8_t>(_tuningRule)][1] / 1000.0 * _Ku / _Tu;
-        _kd = RulesContants[static_cast<uint8_t>(_tuningRule)][2] / 1000.0 * _Ku * _Tu;
+        _kp = (float)(RulesContants[static_cast<uint8_t>(_tuningRule)][0] / 1000.0) * _Ku;
+        _ki = (float)(RulesContants[static_cast<uint8_t>(_tuningRule)][1] / 1000.0) * (_Ku / _Tu);
+        _kd = (float)(RulesContants[static_cast<uint8_t>(_tuningRule)][2] / 1000.0) * (_Ku * _Tu);
       }
       if (_printOrPlotter == 1) {
         // Controllability https://blog.opticontrols.com/wp-content/uploads/2011/06/td-versus-tau.png

src/QuickPID.h

@@ -57,7 +57,7 @@ class AutoTunePID {
       {   0,    0,   0 },  // AMIGOF_PID
       { 700, 1750, 105 },  // PESSEN_INTEGRAL_PID
       { 333,  667, 111 },  // SOME_OVERSHOOT_PID
-      { 200,  400,  67 },  // NO_OVERSHOOT_PID
+      { 333,  100,  67 }   // NO_OVERSHOOT_PID
     };
 
 }; // class AutoTunePID