cinostempcontroller.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#ifndef INC_CINOSTEMPCONTROL_H
#define INC_CINOSTEMPCONTROL_H
 
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
//
#define DF_INOS_TEMP_CONTROLLER_NAME "CINOSTempController"  // controller name
//
#define DF_INOS_TEMP_PID_FLAG_ACTIVE    0x00000001          // pid set is active
 
// anti-windup methods
#define DF_INOS_TEMP_AWM_BACKCALCULATION  0 // back-calculation (currently not implemented)
#define DF_INOS_TEMP_AWM_CLAMPING         1 // clamping
#define DF_INOS_TEMP_AWM_SATURATION       2 // saturation
#define DF_INOS_TEMP_AWM_NONE             3 // none
 
//
// --- controller errors -------------------------------------------------------
//
#define ER_INOS_TEMP_CONTROLLER_BREAK           0x00010000  // sensor break
#define ER_INOS_TEMP_CONTROLLER_SHORT_CIRCUIT   0x00020000  // sensor short circuit
#define ER_INOS_TEMP_CONTROLLER_ALARM           0x00040000  // alarm temp reached
#define ER_INOS_TEMP_CONTROLLER_OUT_FAILURE     0x00080000  // output failure
#define ER_INOS_TEMP_CONTROLLER_DELTA           0x00100000  // max. temp delta
#define ER_INOS_TEMP_CONTROLLER_OUTPWM_SYNC     0x00200000  // outpwm sync does not toggle
#define ER_INOS_TEMP_CONTROLLER_LIMIT           0x00400000  // temperature limit reported
//
// --- controller warnings -----------------------------------------------------
//
#define WR_INOS_TEMP_CONTROLLER_LOW_TEMP        0x00010000  // temperature too low
#define WR_INOS_TEMP_CONTROLLER_HIGH_TEMP       0x00020000  // temperature too high
//
// --- tuning ------------------------------------------------------------------
 
// flags
//
#define DF_INOS_TEMP_TUNE_FLAG_ACCEPT       "Accept"    // tuning flag autoaccept
//
// types
//
#define DF_INOS_TEMP_TUNE_TYPE_HCP          "Type=Hcp"  // tuning type 'hcp'
#define DF_INOS_TEMP_TUNE_TYPE_PID          "Type=Pid"  // tuning type 'pid'
#define DF_INOS_TEMP_TUNE_TYPE_FFS          "Type=ffS"  // tuning type 'ffS'
#define DF_INOS_TEMP_TUNE_TYPE_BLZ          "Type=Blz"  // tuning type 'Blz'
//
// tune type hcp
//
#define DF_INOS_TEMP_TUNE_STATE_HCP_POWER_SET   0   // set output
#define DF_INOS_TEMP_TUNE_STATE_HCP_POWER_WAIT  1   // wait time
#define DF_INOS_TEMP_TUNE_STATE_HCP_SYSTEM_WAIT 2   // wait for system
#define DF_INOS_TEMP_TUNE_STATE_HCP_WAIT_MAX    3   // wait for max
//
// tune type pid
//
#define DF_INOS_TEMP_TUNE_STATE_PID_STEP_POWER_SET      10  // set output
#define DF_INOS_TEMP_TUNE_STATE_PID_STEP_POWER_WAIT     11  // wait time
#define DF_INOS_TEMP_TUNE_STATE_PID_STEP_SYSTEM_WAIT    12  // wait pulse time
#define DF_INOS_TEMP_TUNE_STATE_PID_STEP_WAIT_MAX       13  // wait for max
//
#define DF_INOS_TEMP_TUNE_STATE_PID_SWING_PULSE_SET     20  // set output
#define DF_INOS_TEMP_TUNE_STATE_PID_SWING_PULSE_WAIT    21  // wait pulse time
#define DF_INOS_TEMP_TUNE_STATE_PID_SWING_WAIT_MAX      22  // wait for max
#define DF_INOS_TEMP_TUNE_STATE_PID_SWING_WAIT_MIN      23  // wait for min
#define DF_INOS_TEMP_TUNE_STATE_PID_SWING_RELAX         24  // relax
#define DF_INOS_TEMP_TUNE_STATE_PID_SWING_SETTLE        25  // settle
//
// tune type ffs
//
#define DF_INOS_TEMP_TUNE_STATE_FFS_WAIT        30  // wait 2 min
//
// tune type blz
//
#define DF_INOS_TEMP_TUNE_STATE_BLZ_WAIT        40  // wait 2 min
//
// pid range indices
//
#define DF_INOS_TEMP_PID_RANGE_LOW               0
#define DF_INOS_TEMP_PID_RANGE_MEDIUM            1
#define DF_INOS_TEMP_PID_RANGE_HIGH              2
//
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//
// system
#include <cinosbasecontroller.h>
//
// C++
//
// project
//
//------------------------------------------------------------------------------
//--- structures ---------------------------------------------------------------
//------------------------------------------------------------------------------
//
struct SPidTemp
    //; structure of PID parameters
{
    real64 m_rKp;
    real64 m_rKi;
    real64 m_rKd;
    real64 m_rTi;
    real64 m_rTd;
    real64 m_rAff;
    real64 m_rVff;
    real64 m_rBff;
    real64 m_rSff;
    real64 m_rSffoffset;
    real64 m_rSignalFF;
    uint32 m_uFlags;
};
//
struct STunePoint
{
    real64 m_rTime;
    real64 m_rTemp;
    real64 m_rOut;
};
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
//
class CINOSTempController : public CINOSBaseController
{
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
 
        // constructor/destructor
 
        CINOSTempController(const char* apInpName, const char* apOutName);
            //; constructor
        virtual ~CINOSTempController();
            //; destructor
        virtual void SetCycleTime(real64 arCycleTime) override;
            //; set controller cycle time [sec]
        
        virtual void Activate(bool abCheckVal = true, bool abSimulateVal = false,
            bool abSimulateOut = false, bool abSimulateAct = false) override;
            //; overwritten to handle m_bIgnoreAlarmTemp 
 
        // Tune
        
        virtual uint32 Tune(const char* apParam) override;
            //; tune controller
        virtual uint32 TuneAccept(const char* apParam) override;
            //; accept tune results
 
        virtual CINCOObject* GetRegister() override;
            //; do inco registration and return pointer to it
 
        bool SetPidRunParamKp(uint32 auRangeIndex, real64 arKp);
        bool SetPidRunParamKi(uint32 auRangeIndex, real64 arKi);
        bool SetPidRunParamKd(uint32 auRangeIndex, real64 arKd);
            //; set specific run PID parameter of given temperature range
        virtual bool SetPidRunParam(uint32 auRangeIndex, uint32 auParamIndex, real64 arParamValue);
            //; set generic run PID parameter of given temperature range
 
        bool SetPidHaltParamKp(uint32 auRangeIndex, real64 arKp);
        bool SetPidHaltParamKi(uint32 auRangeIndex, real64 arKi);
        bool SetPidHaltParamKd(uint32 auRangeIndex, real64 arKd);
            //; set specific run PID parameter of given temperature range
        virtual bool SetPidHaltParam(uint32 auRangeIndex, uint32 auParamIndex, real64 arParamValue);
            //; set generic run PID parameter of given temperature range
 
    //--- internals --------------------------------------------------------
 
    friend class CINCOTempCtrPar;
    friend class CINCOTempBlzPar;
    
    // protected member functions
    protected:
        virtual void Reset() override;
            //; reset controller values (called whenever the controller is 
            //; switched on)
        virtual void Jump(real64 arSrc, real64 arDst) override;
            //; jump detected
        virtual void StopJump() override;
            //; stop controller jump
        virtual void StopTune() override;
            //; stop controller tune
        virtual void PreControl() override;
            //; called before control
        virtual bool IsSettled(bool abAdjAllowed=false) override;
            //; return  true if settled
        ICACHE virtual void Control() override;
            //; do a control cycle
        ICACHE void SetActPidSet();
            //; set pointer to actual pid set
        void CalcBoltzmann();
            //; calc boltzmann internals
        real64 GetBoltzmann(real64 arT);
            //; calc boltzmann radiant power of temperature arT
        real64 GetffS(real64 arT);
            //; calc feed forward 
        void iFeedForward();
            //; internal standard feed forward
        void iControl();
            //; internal standard control
        void iJumpCalcPolynom();
            //; calc polynom of 3rd degree
        void iJumpPrepareForHalt();
            //; prepare jump for halt
        void iJumpFeedForward();
            //; internal jump feed forward
        void iJumpControl();
            //; internal jump control
        bool iTuning();
            //; internal tuning method
        bool iTuningWaitTime(real64 arTime);
            //; internal tuning method
        bool iTuningWaitTmax();
            //; internal tuning method
        bool iTuningWaitTmin();
            //; internal tuning method
        bool iTuningSupervision();
            //; tuning supervision
        bool iTuningCheckResult();
            //; check tuning result
        uint32 iTuningGetPidIndex();
            //; internal tuning method
        void SetPid(SPidTemp* apSet, uint32 auIndex, real64 arValue);
            //; set pid value
        virtual const char* GetStateText() override;
            //; get pointer to actual state text
 
        void iTuneAcceptHcp();
            //; accept hcp tuning results
        void iTuneAcceptPid(uint8 auSet);
            //; accept pid tuning results
        void iTuneAcceptffS();
            //; accept ffS tuning results
        void iTuneAcceptBlz();
            //; accept Blz tuning results
 
    // protected members
    protected:
        // controller flag mask
        uint32 m_uFlagMask;
        
        // pid parameter ranges
        real64 m_rMedium;
            //; begin of medium range (ends at begin of high range)
        real64 m_rHigh;
            //; begin of high range
 
        // controller parameters (0-low, 1-medium, 2-high)
        SPidTemp m_PidHalt[3];
            //; pid parameters during halt and jump
        SPidTemp m_PidRun[3];
            //; pid parameters during ramping
        SPidTemp m_PidTune;
            //; pid parameters during tuning
        SPidTemp* m_pActSet;
            //; pointer to actual set
        real64 m_rSint;
            //; actual value integrator
        real64 m_rSintMin;
            //; min. allowed value integrator
        real64 m_rSintMax;
            //; max. allowed value integrator
        uint16 m_uAwMethod;
            //; anti-windup method
        real64 m_rOutact_1;
            //; actual output of the previous cycle, i.e. after actuator saturation is considered
        real64 m_rOutlin;
            //; output in the linear range (i.e. before actuator saturation is considered)
        real64 m_rSerr_1;
            //; error of the previous control cycle
        
        // temperatures
        real64 m_rTmin;
            // min temperature
        real64 m_rTmax;
            // max temperature
        real64 m_rTalarm;
            // alarm temperature
        real64 m_rTalarmHyst;
            // alarm temperature hysteresis
        bool m_bIgnoreAlarmTemp;
            // whether the alarm temperature must be ignored  undershoot since last
            // activation. See also comments on
            // DF_INOS_BASE_CONTROLLER_FLAG_IGN_ALM_ACT. Note that the
            // hysteresis is also taken into account. Means that the
            // temperature must be below (m_rTalarm-m_rTalarmHyst) until the
            // alarm temperature will be checked.
        real64 m_rTbreak;
            // break temperature 
        real64 m_rThalt;
            // halt temperature (if fabs(Scmd-Sact)<=thalt -> settle)
 
        // output
        real64 m_rOutSff;
            // feed forward S
        real64 m_rOutAff;
            // feed forward A
        real64 m_rOutVff;
            // feed forward V
        real64 m_rOutBlz;
            // feed forward Boltzmann
        real64 m_rOutTune;
            // feed forward tuning
 
        // Boltzmann compensation
        real64 m_rBlzTmin;
            //; min. temp
        real64 m_rBlzTmax;
            //; max. temp
        real64 m_rBlzPmax;
            //; power at Tmax 
        double m_dBlzTmin4;
            //; min. temp ^ 4
        double m_dBlzFactor;
            //; d*e*A
 
        real64 m_rHeatFactor;
            //; measured 'm*c'  [J/K] 
 
        real64 m_rOutDelta; 
            //; [°C] min. delta to be reached within outtimeout time 
            //; otherwise -> output failure
        real64 m_rOutTimeout;
            //; [ms] max. allowed time
 
        // jump handling
        uint16 m_uJmpType;
            //; jumping type (0-forward, 1-backward)
        uint16 m_uJmpStatePff;
            //; jumping subsstate feed forward P
        uint16 m_uJmpStateCtr;
            //; jumping subsstate control
        real64 m_rJmpTimer;
            //; time since start of jump
        real64 m_rJmpVmax;
            //; max. V ever reached
        real64 m_rJmpTp;
            //; time base of polynom
        real64 m_rJmpTpe;
            //; Te part of polynom
        real64 m_rJmpOut;
            //; jump output
        real64 m_rJmpTc;
            //; time base of polynom
        real64 m_rJmpTce;
            //; Te part of polynom
        real64 m_rJmpSe;
            //; jump end
        real64 m_rJmpA;
            //; a part of polynom
        real64 m_rJmpB;
            //; b part of polynom
        real64 m_rJmpC;
            //; c part of polynom
        real64 m_rJmpD;
            //; d part of polynom
        
        // tuning handling
        
        bool m_bTuneAccept;
            //; true if autoaccept requested
        uint16 m_uTuneState;
            //; actual tune state
        uint16 m_uTunePid;
            //; actual pid index to be tuned
        real64 m_rTuneTimer;
            //; tuning timer        
        real64 m_rTuneMin;
            //; tuning min
        real64 m_rTuneMax;
            //; tuning max
        real64 m_rTuneTemp;
            //; tuning temp
        real64 m_rTuneTime;
            //; tuning time
        real64 m_rTuneTimePoint;
            //; tuning time of last point
        real64 m_rTuneOut;
            //; tuning out
        real64 m_rTunePulseOut;
            //; tuning pulse out       
        real64 m_rTunePulseTime;
            //; tuning pulse time       
        real64 m_rTunePulseTimeout;
            //; tuning pulse timeout
        int32 m_iTunePulseStart;
            //; pulse starting ticks
        real64 m_rTuneWaveActTime;
            //; tuning wave act time       
        real64 m_rTuneWaveMinTime;
            //; tuning wave min time       
        real64 m_rTuneWaveMaxTime;
            //; tuning wave max time       
        real64 m_rTuneWaveMinAmpl;
            //; tuning wave min ampl       
        real64 m_rTuneWaveMaxAmpl;
            //; tuning wave max ampl       
        real64 m_rTuneWaveMinPower;
            //; tuning wave min power
        real64 m_rTuneWaveMaxPower;
            //; tuning wave max power
        uint16 m_uTuneWaveMinCnt;
            //; requested number of tuning waves
        uint16 m_uTuneWaveReqCnt;
            //; requested additional number of tuning waves
        uint16 m_uTuneWaveCnt;
            //; actual number of tuning waves
        STunePoint m_TuneHigh[2];
            //; tuning peak points
        STunePoint m_TuneLow[2];
            //; tuning low points
        char m_cTuneState[16];
            //; tuning state
        char m_cTuneResultState[16];
            //; tune result state
        char m_cTuneParam[64];
            //; tune params
        uint16 m_uTuneCavg;
            //; internal counter
        real64 m_rTunePavg;
            //; tuning P average
        real64 m_rTuneTavg;
            //; tuning T average
        real64 m_rTuneHcpFactor;
            //; calculated hcp factor
        real64 m_rTuneffSoffset;
            //; ffS offset
        real64 m_rTuneffS;
            //; ffS 
        real64 m_rTuneBlzTmin;
            //; blz tmin
        real64 m_rTuneBlzTmax;
            //; blz tmax
        real64 m_rTuneBlzPmax;
            //; blz pmax
        real64 m_rTuneVmax;
            //; vmax
        real64 m_rTuneVmaxTime;
            //; time at vmax
        real64 m_rTuneVmaxSact;
            //; Sact at vmax
 
        CINOSProcessImageChannel* m_pCmpChannel;
            //; pointer to compensation element channel or nullptr
        CINOSBit* m_pOutChannelBit;
        class CINOSOutPwm* m_pOutPwm;
            //; pointer to outpwm handler or nullptr
        uint32 m_uOutPwmSyncCount{};
            //; last sync count
        int32 m_iOutPwmTicks{};
            //; got pwm sync count at this 1ms ticks
 
        // signal feed forward
 
        inosName64 m_cSignalName;
            //; signal name (analog input or analog output)
        CINOSAdcChannel* m_pAdcSignal;
            //; analog input
        CINOSDacChannel* m_pDacSignal;
            //; analog output
 
        // external temperatur limit supervision
 
        inosName64 m_cLimInput{};
            //; name of external temperature limit supervision digital input
        CINOSBit* m_pLimInput{};
            //; digital input
 
    // allow dynamic object handling (new/delete)
    DECLARE_DYNAMIC_CACHE(CINOSTempController);
};
 
 
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSTEMPCONTROLLER_H