PIDControl.h

00001 #include "mbed.h"
00002 
00003 #ifndef PIDControl_h
00004 #define PIDControl_h
00005 
00006 /*! Diese Klasse erstellt einen PID-Regler. die einzelnen Regeranteile können bei der Initialisierung seperat einsgestellt werden.
00007     Bei der Initialisierung des Reglers bzw. der Klasse wird der Statusvektor resettet und die einzelnen Anteile werden auf null gesetzt und gesperrt.
00008     Solange die Variable Lock nicht wahr ist, kann über die Funktionen setKP(), setKI() und setKD() der Regler parametriert werden.
00009     Es ist zudem möglich die Regelgrenzen des Regelers festzulegen. Bei Überschreiten der Regelgrenzen wird ein Eintrag in dem Statusvektor erzeugt.
00010     Bei einer Änderung im Statusvektor kann eine externe Funktion aufgerufen werden, die dann den Statusvektor auswertet. 
00011     Der Regeltask ctrltask sollte in regelmäßigen Abständen aufgerufen werden. Wichtig dabei ist eine Stänige Übergabe des Ist und Soll-Werts sowie die Regelzeit.
00012     \image html http://developer.mbed.org/media/uploads/ChrisselH/pid-controller.jpg "Schematischer Regleraufbau ohne Statusvektoren und Fehlermeldungen"
00013  * @code
00014  * #include "mbed.h"
00015  * #include "PIDControl.h"        
00016  *
00017  * int16_t ist_value;                                   // Ist-Wert der Strecke
00018  * int16_t soll_value;                                  // Soll-Wert der Strecke
00019  * int16_t stell_value;                                 // Stell-Wert der Strecke
00020  *
00021  * uint8_t statusvektor;                                // Statusvektor des Reglers
00022  *
00023  * int main() {
00024  *    
00025  *     PIDControl PIregler(1,50.8,1,0.5,0,0);          // PI-Regler mit KP = 50,8 und KI = 0,5
00026  *
00027  *     PIregler.setIlimits(1,6000,1000);                // Aktivierung der maximale und minimale Größe des I-Anteils
00028  *
00029  *     PIregler.setAWU(5);                              // Die Differenz zwischen I-Anteil und Limit wird mit 
00030  *                                                      // Verstärkung zurückgeführt
00031  *
00032  *     PIregler.setUlimits(7000,500);                   // Limitierung der Stellgröße
00033  *
00034  *     PIregler.lock();                                 // Sperrt weitere Einstellung an dem Regler
00035  * 
00036  *      while(1){
00037  *      
00038  *          stell = PIregler.ctrltask(ist, soll, 1000); // Die Schleife wiederholt sich alle 1kHz  
00039  * 
00040  *          statusvektor = PIregler.getStatus();        // Status des Reglers wird ausgelesen
00041  *
00042  *        wait(0.001);                                  // Regler wird alle 1kHz aufgerufen
00043  *      }
00044  *    }
00045  *
00046  * @endcode
00047  */
00048 
00049 class PIDControl 
00050 {
00051     public:
00052 
00053         /*! Konstruktor zum Erstellen einer Instanz mit einer vom User festgelegten Größe */
00054         /*!
00055             \param P <b>P-Anteil</b> Aktivert den P-Anteil, wenn der Wert 1 ist
00056             \param KP <b>P-Anteil</b> Verstärkung des P-Anteils
00057             \param I <b>I-Anteil</b> Aktivert den I-Anteil, wenn der Wert 1 ist
00058             \param KI <b>I-Anteil</b> Verstärkung des I-Anteils
00059             \param D <b>D-Anteil</b> Aktivert den D-Anteil, wenn der Wert 1 ist
00060             \param KD <b>D-Anteil</b> Verstärkung des D-Anteils
00061         */      
00062         PIDControl (bool P_usr, float KP_usr, bool I_usr, float KI_usr, bool D_usr, float KD_usr);
00063         
00064         /*! Destruktor entfernt den Regler */
00065         ~PIDControl (){};
00066             
00067         /*! Reglerprozess. Rückgabewert ist die Führungsgröße */
00068         /*!
00069             \param usoll <b>SOLL-Wert</b> Soll-Wert der Regelstrecke
00070             \param yist <b>IST-Wert</b> Ist-Wert der Regelstrecke
00071             \param time <b>Zeitkonstatnte</b> vergangene Zeit seit dem letzen Regeltask in ganzen Mirkosekunden (1ms = 1000µs)
00072         */ 
00073         int16_t ctrltask  (int16_t wsoll, int16_t yist, uint16_t time);
00074         
00075     
00076         /*! Ermöglich Zugriff auf die Reglerparameter des P-Anteils. Rückgabe Wert ist eins, wenn die Reglerwerte gespeichert worden sind.*/
00077         /*!
00078             \param P <b>P-Anteil</b> Aktivert den P-Anteil, wenn der Wert 1 ist
00079             \param KP <b>P-Anteil</b> Verstärkung des P-Anteils
00080         */
00081         bool setKP (bool P_usr, float KP_usr);
00082     
00083         /*! Ermöglich Zugriff auf die Reglerparameter des I-Anteils. Rückgabe Wert ist eins, wenn die Reglerwerte gespeichert worden sind.*/
00084         /*!
00085             \param I <b>I-Anteil</b> Aktivert den I-Anteil, wenn der Wert 1 ist
00086             \param KI <b>I-Anteil</b> Verstärkung des I-Anteils
00087         */
00088         bool setKI (bool I_usr, float KI_usr);
00089         
00090         /*! Ermöglich Zugriff auf die Reglerparameter des D-Anteils. Rückgabe Wert ist eins, wenn die Reglerwerte gespeichert worden sind.*/
00091         /*!
00092             \param D <b>D-Anteil</b> Aktivert den D-Anteil, wenn der Wert 1 ist
00093             \param KD <b>D-Anteil</b> Verstärkung des D-Anteils
00094         */
00095         bool setKD (bool D_usr, float KD_usr);    
00096         
00097         /*! Ermöglich Zugriff auf den Anti-Windup zum begrenzen des I-Anteils*/
00098         /*!
00099             \param awu_gain <b>Anti-Windup Verstärkung</b> Rückführung der Differenz zwischen Stellgröße und Begrenzung mit einer Verstärkung in den I-Anteil
00100         */
00101         bool setAWU (float awu_gain_usr);
00102                 
00103         /*! Setzt die Limits der Stellgröße U bzw. des Ausgangs des Reglers*/
00104         /*!
00105             \param u_max <b>maximales Limit</b> maximale Ausgangsgröße
00106             \param u_min <b>minimales Limit</b> minimale Ausgangsgröße
00107         */
00108         void setUlimits (int16_t u_max_usr, int16_t u_min_usr);
00109         
00110         /*! Setzt die Limits des Integralanteils */
00111         /*!
00112             \param integrallimiter <b>Aktiviert den Limiter</b> aktiviert eine seperate Begrenzung des I-Anteils
00113             \param i_max <b>maximales Limit</b> maximaler I-Anteil
00114             \param i_min <b>minimsler Limit</b> minimaler I-Anteil
00115         */
00116         void setIlimits (bool integrallimiter_usr, int16_t i_max_usr, int16_t i_min_usr);
00117         
00118         /*! Sperrt den Zugriff auf die Reglerparameter */
00119         void lock ();
00120         
00121         /*! Erlaubt den Zugriff auf die Reglerparameter */
00122         void unlock ();
00123         
00124         /*! Liest den Status des Reglers aus */    
00125         uint8_t getStatus ();
00126         
00127         /*! Setzt eine Routine die verwendet wird, wenn ein schwerwiegender Fehler im Statusvektor gesetzt wird.*/ 
00128         /*!
00129             \param BUFFER_HANDLER Adresse zur weiteren Routine
00130          */ 
00131         void setERFFCT (void (*CTRL_HANDLER)(void));  
00132            
00133         private: 
00134         /*! Setzt ein Bit im Statusvektor. Wenn der Rückgabewert True ist, würde der Wert übernommen*/
00135         /*!
00136             \param bit  Welches Bit der Zelle gesetzt werden soll
00137         */     
00138         void setStatus(int bit);
00139      
00140         /*!ResSetzt ein Bit im Statusvektor. Wenn der Rückgabewert True ist, würde der Wert übernommen*/
00141         /*!
00142             \param bit  Welches Bit der Zelle zurück gesetzt werden soll
00143         */     
00144         void resetStatus(int bit);
00145         
00146         //! Zeitwert der letztes Berechnung des Verschiebungswerts
00147         int16_t time_last;
00148         //! Dazugehöriger Verschiebungswert
00149         int16_t time_last_result;
00150          //! Führungsgröße und Rückgabe des Reglertasks
00151         int16_t u; 
00152         //! Freigabe zur Verwendung externer Funktionen 
00153         bool extfct;
00154         //! Externe Funktion bei schwerwiegenden Fehlern
00155         void (*CTRL_HANDLER)(void);
00156         //! Reglereinstellungen können nicht mehr verändert werden.
00157         bool lockctrl;
00158         //! Limits für den Integralanteil aktiv
00159         bool integrallimiter;
00160         //! Vorheriger Ístwert des Regelfehlers
00161         int16_t e_last;
00162         //! Integral über alle bisherigern Werte
00163         int16_t e_sum;
00164         //! Antiwindup Wert mit Verstärkung awu_gain
00165         int16_t awu_value; 
00166         //! Regleranteil des P-Regler
00167         int16_t P_var;
00168         //! Regleranteil des I-Regler
00169         int16_t I_var;
00170         //! Regleranteil des D-Regler
00171         int16_t D_var;  
00172     
00173         //! Funktion zum bestimmen der zweier Potenz
00174         /*!
00175             \param a  16-Bit Integer bei der die Zweierpotenz bestimmt werden soll
00176         */
00177         int16_t log2(int16_t a);
00178         
00179     
00180     protected:
00181     
00182         //! Aktiviert den Proportional-Anteil
00183         bool P;
00184         //! Aktiviert den Integral-Anteil
00185         bool I;
00186         //! Aktiviert den Differnetial-Anteil
00187         bool D;  
00188         
00189         //! Verstärkung für den Proportional-Anteil
00190         float KP;
00191         //! Verstärkung für den Integral-Anteil
00192         float KI;
00193         //! Verstärkung für den Differnetial-Anteil
00194         float KD;
00195         
00196         //! Maximale Führungsgröße
00197         int16_t u_max;
00198         //! Minimale Führungsgröße
00199         int16_t u_min;
00200         //! Maximaler Integralanteil
00201         int16_t i_max;
00202         //! Minimaler Integralanteil
00203         int16_t i_min;
00204         //! Anti-Windup Verstärkung
00205         float awu_gain;
00206         
00207 
00208         /*! 8-Bit Statusvektor:
00209                 -  [7] Regelgrenze max überschritten (<b>EXTFCT</b>)<br>
00210                 -  [6] Regelgrenze min unterschritten (<b>EXTFCT</b>)<br>
00211                 -  [5] Fehler bei der Berechnung (<b>EXTFCT</b>)<br>
00212                 -  [4] aktueller IST-Wert < Soll-Wert<br>
00213                 -  [3] aktueller IST-Wert > Soll-Wert<br>
00214                 -  [2] Regelabweichung ist null<br>
00215                 -  [1] I-Anteil Limit erreicht<br>
00216                 -  [0] Reglertask aktiv<br> 
00217             Bei schwerwiegenden Fehlern wird eine externe Routine (<b>EXTFCT</b>) aufgerufen, falls diese angegeben wurde.          
00218         */
00219         uint8_t status ;
00220  
00221     };
00222     
00223     
00224 
00225 
00226 #endif