doxygen/inos/cinostempcontroller_8h_source.html

//******************************************************************************

//******************************************************************************


#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

//

// --- controller warnings -----------------------------------------------------

//

#define WR_INOS_TEMP_CONTROLLER_LOW_TEMP        0x00010000  // temperature to low

#define WR_INOS_TEMP_CONTROLLER_HIGH_TEMP       0x00020000  // temperature to 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_SYSTEM_WAIT    11  // wait pulse time

#define DF_INOS_TEMP_TUNE_STATE_PID_STEP_WAIT_MAX       12  // 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);

            //; set controller cycle time [sec]


        virtual void Activate(bool abCheckVal = true, bool abSimulateVal = false,

            bool abSimulateOut = false, bool abSimulateAct = false);

            //; overwritten to handle m_bIgnoreAlarmTemp


        // Tune


        virtual uint32 Tune(const char* apParam);

            //; tune controller


        virtual CINCOObject* GetRegister();

            //; 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();

            //; reset controller values (called whenever the controller is

            //; switched on)

        virtual void Jump(real64 arSrc, real64 arDst);

            //; jump detected

        virtual void StopJump();

            //; stop controller jump

        virtual void StopTune();

            //; stop controller tune

        virtual void PreControl();

            //; called before control

        virtual bool IsSettled(bool abAdjAllowed=false);

            //; return  true if settled

        ICACHE virtual void Control();

            //; 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();

            //; get pointer to actual state text


    // 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


        inosName32 m_cSignalName;

            //; signal name (analog input or analog output)

        CINOSAdcChannel* m_pAdcSignal;

            //; analog input

        CINOSDacChannel* m_pDacSignal;

            //; analog output


    // allow dynamic object handling (new/delete)

    DECLARE_DYNAMIC_CACHE(CINOSTempController);

};


//------------------------------------------------------------------------------

// end of file

//------------------------------------------------------------------------------


#endif  // INC_CINOSTEMPCONTROLLER_H

cinosbasecontroller.h
Short comment.

CINOSAdcChannel
Definition cinosadcchannel.h:53

CINOSBaseController
Definition cinosbasecontroller.h:110

CINOSBit
Definition cinosbit.h:54

CINOSDacChannel
Definition cinosdacchannel.h:52

CINOSMcModuleWaitVar
Definition cinosmcmodule.h:1900

CINOSProcessImageChannel
Definition cinosprocessimagechannel.h:111

CINOSTempController
Definition cinostempcontroller.h:155

CINOSTempController::m_pOutPwm
class CINOSOutPwm * m_pOutPwm
pointer to output channel if bit
Definition cinostempcontroller.h:467

SPidTemp
Definition cinostempcontroller.h:129

STunePoint
Definition cinostempcontroller.h:145