proper c++-Style with many changes

- used constness wherever possible
- cleaner constructor with proper initialized variables
- replaced defines (preprocessor) by const type to get better
compiler-errors
- inlined the display-functions --> typically found in the header
- made the class uncopyable to get no strange undefined behavior if
someone tries it
- controllerDirection and Mode have been int-type, but char will suffice

PID_v1.cpp

@@ -17,20 +17,13 @@
  *    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.
  ***************************************************************************/
-PID::PID(double* Input, double* Output, double* Setpoint,
+PID::PID(double* const Input, double* const Output, double* const Setpoint,
-        double Kp, double Ki, double Kd, int ControllerDirection)
+        const double Kp, const double Ki, const double Kd, const char ControllerDirection)
+        : myOutput(Output), myInput(Input), mySetpoint(Setpoint), inAuto(false), SampleTime(100) //default Controller Sample Time is 0.1 seconds
 {
-	
-    myOutput = Output;
-    myInput = Input;
-    mySetpoint = Setpoint;
-	inAuto = false;
-	
 	PID::SetOutputLimits(0, 255);				//default output limit corresponds to
 												//the arduino pwm limits
 
-    SampleTime = 100;							//default Controller Sample Time is 0.1 seconds
-
     PID::SetControllerDirection(ControllerDirection);
     PID::SetTunings(Kp, Ki, Kd);
 
@@ -80,7 +73,7 @@ bool PID::Compute()
  * it's called automatically from the constructor, but tunings can also
  * be adjusted on the fly during normal operation
  ******************************************************************************/
-void PID::SetTunings(double Kp, double Ki, double Kd)
+void PID::SetTunings(const double Kp, const double Ki, const double Kd)
 {
    if (Kp<0 || Ki<0 || Kd<0) return;
 
@@ -102,7 +95,7 @@ void PID::SetTunings(double Kp, double Ki, double Kd)
 /* SetSampleTime(...) *********************************************************
  * sets the period, in Milliseconds, at which the calculation is performed
  ******************************************************************************/
-void PID::SetSampleTime(int NewSampleTime)
+void PID::SetSampleTime(const int NewSampleTime)
 {
    if (NewSampleTime > 0)
    {
@@ -122,7 +115,7 @@ void PID::SetSampleTime(int NewSampleTime)
  *  want to clamp it from 0-125.  who knows.  at any rate, that can all be done
  *  here.
  **************************************************************************/
-void PID::SetOutputLimits(double Min, double Max)
+void PID::SetOutputLimits(const double Min, const double Max)
 {
    if(Min >= Max) return;
    outMin = Min;
@@ -143,7 +136,7 @@ void PID::SetOutputLimits(double Min, double Max)
  * when the transition from manual to auto occurs, the controller is
  * automatically initialized
  ******************************************************************************/
-void PID::SetMode(int Mode)
+void PID::SetMode(const char Mode)
 {
     bool newAuto = (Mode == AUTOMATIC);
     if(newAuto == !inAuto)
@@ -157,7 +150,7 @@ void PID::SetMode(int Mode)
  *	does all the things that need to happen to ensure a bumpless transfer
  *  from manual to automatic mode.
  ******************************************************************************/
-void PID::Initialize()
+inline void PID::Initialize()
 {
    ITerm = *myOutput;
    lastInput = *myInput;
@@ -171,7 +164,7 @@ void PID::Initialize()
  * know which one, because otherwise we may increase the output when we should
  * be decreasing.  This is called from the constructor.
  ******************************************************************************/
-void PID::SetControllerDirection(int Direction)
+void PID::SetControllerDirection(const char Direction)
 {
    if(inAuto && Direction !=controllerDirection)
    {
@@ -182,14 +175,3 @@ void PID::SetControllerDirection(int Direction)
    controllerDirection = Direction;
 }
 
-/* Status Funcions*************************************************************
- * Just because you set the Kp=-1 doesn't mean it actually happened.  these
- * functions query the internal state of the PID.  they're here for display 
- * purposes.  this are the functions the PID Front-end uses for example
- ******************************************************************************/
-double PID::GetKp(){ return  dispKp; }
-double PID::GetKi(){ return  dispKi;}
-double PID::GetKd(){ return  dispKd;}
-int PID::GetMode(){ return  inAuto ? AUTOMATIC : MANUAL;}
-int PID::GetDirection(){ return controllerDirection;}
-

PID_v1.h

@@ -2,58 +2,65 @@
 #define PID_v1_h
 #define LIBRARY_VERSION	1.1.1
 
+  //Constants used in some of the functions below
+  const char AUTOMATIC    {1}; // gives better compiler-errors than #defines
+  const char MANUAL	    {0};
+  const char DIRECT       {0};
+  const char REVERSE      {1};
+
 class PID
 {
 
-
   public:
 
-  //Constants used in some of the functions below
-  #define AUTOMATIC	1
-  #define MANUAL	0
-  #define DIRECT  0
-  #define REVERSE  1
-
   //commonly used functions **************************************************************************
-    PID(double*, double*, double*,        // * constructor.  links the PID to the Input, Output, and 
+    PID( double* const, double* const, double* const,        // * constructor.  links the PID to the Input, Output, and
-        double, double, double, int);     //   Setpoint.  Initial tuning parameters are also set here
+        const double, const double, const double, const char);     //   Setpoint.  Initial tuning parameters are also set here
 
-    void SetMode(int Mode);               // * sets PID to either Manual (0) or Auto (non-0)
+    void SetMode(const char Mode);               // * sets PID to either Manual (0) or Auto (non-0)
 
     bool Compute();                       // * performs the PID calculation.  it should be
                                           //   called every time loop() cycles. ON/OFF and
                                           //   calculation frequency can be set using SetMode
                                           //   SetSampleTime respectively
 
-    void SetOutputLimits(double, double); //clamps the output to a specific range. 0-255 by default, but
+    void SetOutputLimits(const double, const double); //clamps the output to a specific range. 0-255 by default, but
 										  //it's likely the user will want to change this depending on
 										  //the application
 
 
 
   //available but not commonly used functions ********************************************************
-    void SetTunings(double, double,       // * While most users will set the tunings once in the 
+    void SetTunings(const double, const double,       // * While most users will set the tunings once in the
-                    double);         	  //   constructor, this function gives the user the option
+                    const double);         	  //   constructor, this function gives the user the option
                                           //   of changing tunings during runtime for Adaptive control
-	void SetControllerDirection(int);	  // * Sets the Direction, or "Action" of the controller. DIRECT
+	void SetControllerDirection(const char);	  // * Sets the Direction, or "Action" of the controller. 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.
-    void SetSampleTime(int);              // * sets the frequency, in Milliseconds, with which 
+    void SetSampleTime(const int);              // * sets the frequency, in Milliseconds, with which
                                           //   the PID calculation is performed.  default is 100
 
 
 
   //Display functions ****************************************************************
-	double GetKp();						  // These functions query the pid for interal values.
+/* Just because you set the Kp=-1 doesn't mean it actually happened.  these
-	double GetKi();						  //  they were created mainly for the pid front-end,
+ * functions query the internal state of the PID.  they're here for display
-	double GetKd();						  // where it's important to know what is actually 
+ * purposes.  this are the functions the PID Front-end uses for example
-	int GetMode();						  //  inside the PID.
+ ******************************************************************************/
-	int GetDirection();					  //
+    inline double GetKp()       { return  dispKp; };
+    inline double GetKi()       { return  dispKi;};
+    inline double GetKd()       { return  dispKd;};
+    inline char   GetMode()     { return  inAuto ? AUTOMATIC : MANUAL;};
+    inline char   GetDirection(){ return controllerDirection;};
+
 
   private:
 	void Initialize();
 
+	PID(const PID&);                    // declaration only for copy constructor
+	PID& operator=(const PID&);         // declaration only for copy assignment --> make it uncopyable
+
 	double dispKp;				// * we'll hold on to the tuning parameters in user-entered
 	double dispKi;				//   format for display purposes
 	double dispKd;				//
@@ -62,7 +69,7 @@ class PID
     double ki;                  // * (I)ntegral Tuning Parameter
     double kd;                  // * (D)erivative Tuning Parameter
 
-	int controllerDirection;
+	char  controllerDirection;
 
     double *myInput;              // * Pointers to the Input, Output, and Setpoint variables
     double *myOutput;             //   This creates a hard link between the variables and the