outctrltempthread.cpp

高精度控温算法,使用PID控制思想

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

#include "OutCtrlTempThread.h"
#include "KYCalorimeter.h"
#include <math.h>
#include "declare.h"
#include <memory.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "time.h"
#include "kyEventQueue.h"


COutCtrlTempThread::COutCtrlTempThread( CKYCalorimeter &calorimeter )
: m_calorimeter( calorimeter )
{
    //TODO: Add your source code here
	memset( aryTempDeviate , 0, sizeof( aryTempDeviate ) );
	memset( aryTempDeviateDifferential , 0, sizeof( aryTempDeviateDifferential ) );
	memset( aryTempDeviateDifferentialValid , 0, sizeof( aryTempDeviateDifferentialValid ) );
	
//	TempAim=30.0;
	
	TempDeviateLast=100;
	TempDeviateLastLast=100;
	TempDeviateLastLastLast=100;

	P_two_positive=36;     I_two=0.81;                  Cobble_two=0.42;
	P_two_negative=18;
	P_three_positive=58;   I_three=3.9;    D_three=10;  Cobble_three=0.095;
	P_three_negative=28;
	P_four_positive=75;    I_four=2.8;      D_four=20;   Cobble_four=0.03;
	P_four_negative=52;

	TempDeviateWave=0.05;////////////
	
	CycleDefault = 35;///////////////
	CycleWorkDefault = 10;//////////
	CycleWorkEndDefault = 10;/////////
	CyclePointDefault = 20;//////////
	
	DelayCycle=12;///////////////////
	
	Cycle=35;////////////////////////
	CycleWork=10;////////////////////
	CyclePoint=20;///////////////////
	
	md_Symbol=1;/////////////////////
	
	count_i=CycleWorkDefault-1;//////
	//count_m=0;
	count_n=0;///////////////////////
	count_j=0;///////////////////////
	
	CycleWorkChange=9;///////////////
	CycleWorkOccupy=0;///////////////
	regular=1;//////////////////////
	
	revision=0.4f;//////////////////
	
	DelayPlanningSign=0;////////////
	DelayTime=0;////////////////////
	
	
	CaiWenJianGe=1;////////////////
	/////////////////////////////////	
	
}

COutCtrlTempThread::~COutCtrlTempThread()
{
    //TODO: Add your source code here
}

int COutCtrlTempThread::Mathematical(int m,double TempDe,double TempAim)
{
	if(m%CaiWenJianGe==0)
	{
	   Ctrl(TempDe,TempAim);///////////////////////////////////////
	}
	if(m >= CaiWenJianGe*CycleWork)
	{
	   m=0;
	   count_i=0;
	}
	return m;
} 



void COutCtrlTempThread::Ctrl(double TempDe,double TempAim)
{
    int Parting=1;////////////////////////////////////////////////////////
    
    /////////////////////////////////////////
    if(Cycle>=temp_n)
    {
        Cycle=CycleDefault;
    }
        if(CycleWork>Cycle)
    {
        CycleWork=CycleWorkDefault;
    }
        if(CyclePoint>Cycle)
    {
        CyclePoint=CyclePointDefault;
    }
    ////////////////////////////////////////
	TempDeviate=TempDe;
	if(md_Symbol==1) 
	{ 
		for(int i=0;i<temp_n;i++) 
		{ 
			aryTempDeviate[i]=TempDeviate; 
		} 
		md_Symbol=0; 
	}
	//////////////////////////////////
	TempDeviateDifferential=TempDeviate-aryTempDeviate[Parting-1]; 
	////////////////////////////////
	double Sun = 0;
	for (int j=0;j<CyclePoint;j++) 
	{ 
		Sun+=aryTempDeviateDifferential[j]; 
	} 
	TempDeviateDifferentialValid=0.75*TempDeviateDifferential+0.15*aryTempDeviateDifferentialValid[0]+0.1*Sun/CyclePoint; 
	////////////////////////
	TempDeviateDifferentialVariance=TempDeviateDifferentialValid-aryTempDeviateDifferentialValid[0]; 	
	
    ////////////////////////The function solve the CyclePoint
	if(TempDeviate<12*TempDeviateWave) 
	{
        count_n++;
        if(count_n>=Cycle)
        {
            count_n=0;
            double aryTempDeviateConvex[temp_n]={0},aryTempDeviateConcave[temp_n]={0};
			int c_n;
            for(c_n=0;c_n<temp_n;c_n++)
            {
                aryTempDeviateConvex[c_n] = -100;
                aryTempDeviateConcave[c_n] = 100;
            }
            for(c_n=0;c_n<Cycle;c_n++)
            {
                if((10000*aryTempDeviateDifferentialValid[c_n])*(10000*aryTempDeviateDifferentialValid[c_n+1])<0)
                {
                    if(((100*aryTempDeviateDifferentialValid[c_n])-(100*aryTempDeviateDifferentialValid[c_n+1]))<0)
                    {
                        aryTempDeviateConvex[c_n]=aryTempDeviate[c_n+1];
                    }
                    else
                    {
                        aryTempDeviateConcave[c_n]=aryTempDeviate[c_n+1];
                    }
                }
            }
            double TempDeviateConvex=aryTempDeviateConvex[Cycle-1];
            double TempDeviateConcave=aryTempDeviateConcave[Cycle-1];
            int TD_convex=0,TD_concave=0;
            for(c_n=Cycle-2;c_n>=0;c_n--)
            {
                if(TempDeviateConvex < aryTempDeviateConvex[c_n])
                {
                    TempDeviateConvex=aryTempDeviateConvex[c_n];
                    TD_convex=c_n;
                }
                if(TempDeviateConcave > aryTempDeviateConcave[c_n])
                {
                    TempDeviateConcave=aryTempDeviateConcave[c_n];
                    TD_concave=c_n;
                }
            }
            
			if(TD_convex>0 && TD_concave>0 && abs(TD_convex-TD_concave)>4 && abs(TD_convex-TD_concave)<Cycle) 
			{ 
				CyclePoint=abs(TD_convex-TD_concave)+1; 
			}
//			else CyclePoint= CyclePointDefault;
        }
        ////////////////////////////////////////
	}
    else
    {
        count_n=0;
    }
	
    ///////////////////////////////	The function solve the CyclePoint.
    if(DelayPlanningSign==1)
    {
        count_j++;
    }
    else
    {
        count_j=0;
    }
    if(count_j>=DelayCycle)
    {
        count_j=0;
        double aryTempDeviateDelayPlaning[temp_n]={0};
		int c_j;
        for(c_j=0;c_j<DelayCycle;c_j++)
        {
            aryTempDeviateDelayPlaning[c_j]=-100;
        }
        for(c_j=0;c_j<DelayCycle;c_j++)
        {
            if((10000*aryTempDeviateDifferentialValid[c_j])*(10000*aryTempDeviateDifferentialValid[c_j+1])<0 &&
                ((100*aryTempDeviateDifferentialValid[c_j])-(100*aryTempDeviateDifferentialValid[c_j+1]))<0)
            {
                aryTempDeviateDelayPlaning[c_j]=aryTempDeviate[c_j+1];
            }
        }
        double TempDeviateDelayPlaning=aryTempDeviateDelayPlaning[DelayCycle-1];
        for(c_j=DelayCycle-2;c_j>=0;c_j--)
        {
            if(aryTempDeviateDelayPlaning[c_j]>TempDeviateDelayPlaning)
            {
                TempDeviateDelayPlaning=aryTempDeviateDelayPlaning[c_j];
                DelayTime = DelayCycle-c_j;
            }
        }
        
        if(DelayTime>=3 && DelayTime<=CycleWorkEndDefault)
        {
            CycleWorkChange=DelayTime+2;
        }
        if(DelayTime<3)
        {
            CycleWorkChange = CycleWorkEndDefault-3;
        }
        if(DelayTime>CycleWorkDefault)
        {
            CycleWorkChange = CycleWorkEndDefault+3;
        }
    }
    /////////////////////////////////////////////
    double TempDecrease=0,TempDecreaseSum=0;
    int TDJ=0;
    for(;TDJ<8;TDJ++)
    {
        if(aryTempDeviate[TDJ]<revision*TempDeviateWave && aryTempDeviateDifferentialValid[TDJ]>0)
//        if(aryTempDeviateDifferentialValid[TDJ]>0)
        {
            TempDecreaseSum += aryTempDeviateDifferentialValid[TDJ];
        }
        else break;
    }
    if(TDJ==7)
    {
        TempDecrease=TempDecreaseSum/8;
  //      fprintf(fp,"%4d ",count_record);
  //      fprintf(fp,"Decrease=%.6f\n",TempDecrease);
        /**////////////////////////////////////////////////////////////////////////////
        if(TempDecrease>=0.0005&&TempDecrease<0.001)
        {
            P_four_positive=60;
        }
        if(TempDecrease>=0.001&&TempDecrease<0.002)
        {
            P_four_positive=70;
        }
        if(TempDecrease>=0.002&&TempDecrease<0.005)
        {
            P_four_positive=85;
        }
        //////////////////////////////////////////////////////////////////////////////////
    }
    /////////////////////////
    double TempRise=0,TempRiseSum=0;
    for(TDJ=0;TDJ<16;TDJ++)
    {
        if(aryTempDeviate[TDJ]>12*TempDeviateWave && aryTempDeviateDifferentialValid[TDJ]<0)
        {
            TempRiseSum += aryTempDeviateDifferentialValid[TDJ];
        }
        else break;
    }
    if(TDJ==15)
    {
        TempRise=TempRiseSum/16;
 //       fprintf(fp,"%4d ",count_record);
 //       fprintf(fp,"Rise=%.6f\n",TempRise);
        /**////////////////////////////////////////////////////////////////////////////
        if(TempRise>=0.005 && TempRise<0.01)
        {
            P_three_negative=20;
            P_four_negative=40;
        }
        if(TempRise>=0.01 && TempRise<0.03)
        {
            P_three_negative=35;
            P_four_negative=58;
        }
        ///////////////////////////////////////////////////////////////////////////////
    }
    //////////////////////////////////////////////
    count_i++;
    if(count_i>= CycleWork)
    {
        CtrlTempParting();
    }
    //////////////////////////////////////////////
    for(int i=temp_n;i>1;i--)
    {
        aryTempDeviate[i-1]=aryTempDeviate[i-2];
        aryTempDeviateDifferential[i-1]=aryTempDeviateDifferential[i-2];
        aryTempDeviateDifferentialValid[i-1]=aryTempDeviateDifferentialValid[i-2];
    }
    aryTempDeviate[0]=TempDeviate;
    aryTempDeviateDifferential[0]=TempDeviateDifferential;
    aryTempDeviateDifferentialValid[0]=TempDeviateDifferentialValid;
    ////////////////////////////////////////////
    /*
    if(count_record<5000)
    {
        if((count_record%10)==0)
        {
            fprintf(fp,"%4d ",count_record);
            fprintf(fp,"                  Deviate=%0 .4f ",TempDeviate);
            fprintf(fp,"CyclePoint=%2d ",CyclePoint);
            fprintf(fp,"CycleWork=%2d ",CycleWork);
            fprintf(fp,"DelayTime=%2d ",DelayTime);
            fprintf(fp,"CycleWorkChange=%2d\n\n",CycleWorkChange);
        }
    }
       
    count_record++;*/ 
    /////////////////////////////////////////////
}

void COutCtrlTempThread::CtrlTempParting()
{
    double proportion=0;
    if(TempDeviate>12*TempDeviateWave)/////100%
    {
        CycleWork=CycleWorkDefault;
        CycleWorkOccupy=CycleWork*CaiWenJianGe;//
        count_i=0;
        ///////////////
        DelayPlanningSign=0;
        ///////////////
        return;
    }