mx.cpp

电力系统无功自动补偿的操作系统程序

#include "stdafx.h"
#include "math.h"
#include "VQC.h"

VQCMONI_DBS::VQCMONI_DBS()
{
	BYTE i;
	ClassSize = sizeof(VQCMONI_DBS);
	LockUpLimit = 0;
	LockDownLimit = 0;
	oweValue = 0;
	oweWeight = 0;
	weight1 = 0;
	weight2 = 0;
	fValue1 = 0;
	fValue2 = 0;
	ctrlPercent = 0;
	sampleValue[0] = 0;
	meanValue = 0;
	dayOverUpTime		= 0;
	dayOverDownTime		= 0;
	monthOverUpTime		= 0;
	monthOverDownTime	= 0;
	lastDayOverUpTime	= 0;
	lastDayOverDownTime = 0;
	lastMonthOverUpTime = 0;
	lastMonthOverDownTime = 0;
	currUpLimit = 0;
	currDownLimit = 0;
	realValue = 0;
	zone = ZONE_NORMAL;
	for (i=0;i<UQ_SEASON_NUMBER;i++) limit[i].ST_LIMIT::ST_LIMIT();
}

VQCMONI_DBS::~VQCMONI_DBS()
{
}

VQCMONI_DBS  VQCMONI_DBS::operator=(VQCMONI_DBS op){
	LockUpLimit		= op.LockUpLimit;
	LockDownLimit	= op.LockDownLimit;
	oweValue	= op.oweValue;
	oweWeight	= op.oweWeight;
	weight1		= op.weight1;
	weight2		= op.weight2;
	fValue1		= op.fValue1;
	fValue2		= op.fValue2;
	ctrlPercent = op.ctrlPercent;
	for (BYTE i=0;i<UQ_SEASON_NUMBER;i++) limit[i] = op.limit[i];
	return *this;
}

BOOL VQCMONI_DBS::CheckParam(char * alarmMsg)
{
	BYTE i,j;
	strcpy(alarmMsg, "数据结构设置有错!");
	if (ClassSize != sizeof(VQCMONI_DBS)) return FALSE;
	strcpy(alarmMsg, "库记录设置有错!");

	strcpy(alarmMsg, "权值设置有错!");
	if ((weight2<0)||(weight1<0)) return FALSE;
	if ((fValue2<0)||(fValue1<0)) return FALSE;
	if (weight2){
		if (weight1==0) return FALSE;
		if (fValue2<0.00000001) return FALSE;
	}
	else if (weight1) if (fValue1<0.00000001) return FALSE;
	if ((oweWeight<0)||(oweValue<0)) return FALSE;
	if (oweWeight) if (oweValue<0.00000001) return FALSE;

	strcpy(alarmMsg, "封锁限值设置有错!");
	if (LockUpLimit <= LockDownLimit) return FALSE;

	strcpy(alarmMsg, "限值时间段有错!");
	for (i=0;i<pFatherMX->pGlobalDef->SeasonNum;i++){
		if (limit[i].SectNum > UQ_SECT_NUMBER) return FALSE;
		for (j=1;j<limit[i].SectNum;j++){
			if (j!=0){
				if (limit[i].EndHour[j] < limit[i].EndHour[j-1]) return FALSE;
				if (limit[i].EndHour[j] == limit[i].EndHour[j-1]) 
				   if (limit[i].EndMinute[j] < limit[i].EndMinute[j-1]) return FALSE;
			}
		}
	}

	strcpy(alarmMsg, "上下限值设置有错!");
	if ((ctrlPercent<0)||(ctrlPercent>20)) return FALSE;
	for (i=0;i<pFatherMX->pGlobalDef->SeasonNum;i++){
		for (j=0;j<limit[i].SectNum;j++){
			if (limit[i].DownLimit[j] <= LockDownLimit) return FALSE;
			if (limit[i].UpLimit[j] >= LockUpLimit) return FALSE;
			if (limit[i].DownLimit[j] >= limit[i].UpLimit[j]) return FALSE;
		}
	}
	alarmMsg[0]=0;
	return TRUE;
}

void VQCMONI_DBS::SetZoneProc()
{
	float tf;

	tf = currUpLimit - currDownLimit;
	tf *= (float)ctrlPercent;
	tf /= 100.0;
	currUpLimit  -= tf;
	currDownLimit+= tf;

	tf = cosq_currUpLimit - cosq_currDownLimit;
	tf *= (float)ctrlPercent;
	tf /= 100.0;
	cosq_currUpLimit  -= tf;
	cosq_currDownLimit+= tf;

	if (pFatherMX->pGlobalDef->bUseMean) tf = meanValue;
	else tf = realValue;
	if (tf >= LockUpLimit)        zone = ZONE_UP_LOCK;
	else if (tf <= LockDownLimit) zone = ZONE_DOWN_LOCK;
	else if (tf >= currUpLimit)	  zone = ZONE_UP;
	else if (tf <= currDownLimit) zone = ZONE_DOWN;
	else zone = ZONE_NORMAL;
}

//计算越限时间
void VQCMONI_DBS::CaculateOverLimitTime()
{
	if ((realValue<LockUpLimit)&&(realValue >= currUpLimit)){
		dayOverUpTime		+= pFatherMX->pGlobalDef->AdjustPeriodTime;
		monthOverUpTime		+= pFatherMX->pGlobalDef->AdjustPeriodTime;
	}
	else if ((realValue>LockDownLimit)&&(realValue <= currDownLimit)){
		dayOverDownTime		+= pFatherMX->pGlobalDef->AdjustPeriodTime;
		monthOverDownTime	+= pFatherMX->pGlobalDef->AdjustPeriodTime;
	}
}

void VQCMONI_DBS::AdjustTimeProc()
{
	int i;
	for (i=MAX_SAMPLE_NUM-1;i>0;i--) sampleValue[i] = sampleValue[i-1];
	sampleValue[0]= realValue;
	limit[pFatherMX->pGlobalDef->currSeasonNo].SetCurrTimeSectNo();
	currUpLimit   = limit[pFatherMX->pGlobalDef->currSeasonNo].GetUpLimtValue();
	currDownLimit = limit[pFatherMX->pGlobalDef->currSeasonNo].GetDownLimtValue();
	if (fabs(currUpLimit) > fabs(currDownLimit)){
		cosq_currUpLimit   = (float)fabs(currUpLimit);
		cosq_currDownLimit = (float)fabs(currDownLimit);
	}
	else {
		cosq_currUpLimit   = (float)fabs(currDownLimit);
		cosq_currDownLimit = (float)fabs(currUpLimit);
	}
}

void VQCMUXI_DBS::InitStructProc()
{
	BYTE i;
	U.pFatherMX = this;
	Q.pFatherMX = this;
	for (i=0;i<VQC_DRQNUM;i++){
		DRQ[i].pFatherMX	= this;
		DRQ[i].IsDrq		= TRUE;
		DRQ[i].kgNeedLockTime   = DRQ[i].LockTime;

		DKQ[i].pFatherMX	= this;
		DKQ[i].IsDrq		= FALSE;
		DKQ[i].kgNeedLockTime   = DKQ[i].LockTime;
	}
}

VQCMUXI_DBS::VQCMUXI_DBS()
{
	BYTE i;
	InitStructProc();
	ClassSize = sizeof(VQCMUXI_DBS);
	LeftLinkZBNo  = -1;
	RightLinkZBNo = -1;
	LeftLinkMXNo  = -1;
	RightLinkMXNo = -1;
	LeftLinkDevNum = 0;
	RightLinkDevNum = 0;
	for (i=0;i<4;i++){
		LeftLinkDevRec[i].ReInitDataProc( DATA_TYPE_YX);
		RightLinkDevRec[i].ReInitDataProc(DATA_TYPE_YX);
	}
	LinkZbKgDevRec.ReInitDataProc(	DATA_TYPE_YX);
	LinkZbDzDevRec.ReInitDataProc(	DATA_TYPE_YX);
	AskFjtUpRec.ReInitDataProc(	DATA_TYPE_YX);
	AskFjtDownRec.ReInitDataProc(	DATA_TYPE_YX);
	AskDrqCloseRec.ReInitDataProc(	DATA_TYPE_YX);
	AskDrqOpenRec.ReInitDataProc(	DATA_TYPE_YX);
	LockStatRec.ReInitDataProc(	DATA_TYPE_YX);

	URec.ReInitDataProc( DATA_TYPE_YC);
	QRec.ReInitDataProc( DATA_TYPE_YC);
	PRec.ReInitDataProc( DATA_TYPE_YC);

	CheckLock.Lock_Condition::Lock_Condition();

	DRQNum =0;
	DKQNum =0;
	for (i=0;i<VQC_DRQNUM;i++){
		DRQ[i].pFatherMX = this;
		DKQ[i].pFatherMX = this;
		DRQ[i].IsDrq = TRUE;
		DKQ[i].IsDrq = FALSE;
		DRQ[i].VQCDRQ_DBS::VQCDRQ_DBS();
		DKQ[i].VQCDRQ_DBS::VQCDRQ_DBS();
	}

	U.pFatherMX = this;
	Q.pFatherMX = this;
	U.VQCMONI_DBS::VQCMONI_DBS();
	Q.VQCMONI_DBS::VQCMONI_DBS();
	bLinkQ = TRUE;
	ActWeight = 160;     //满值200*80% = 160
	JudgeTime = 60;      //60秒判断时间,每点3秒,满值200
	lockReasonStatus = 0;
	integrateZone = RUN_ZONE_NORMAL;
	sampleNum = 0;
	MaxSampleNum = JudgeTime/3;
	askFjtUpWeight =0;
	askFjtDownWeight =0;
	askDrqCloseWeight =0;
	askDrqOpenWeight =0;
	firstFjtNum =0;
	firstDrqNum =0;
	bLeftLink =FALSE;
	bRightLink =FALSE;
	linkMXNum =0;
	linkMX[0] = this;
	currUseDrqOnNum =0;
	currUseDkqOnNum =0;
}

VQCMUXI_DBS::~VQCMUXI_DBS()
{
}

VQCMUXI_DBS  VQCMUXI_DBS::operator=(VQCMUXI_DBS op)
{
	BYTE i;
	ZBNo	=	op.ZBNo;
	MXNo	=	op.MXNo;
    LeftLinkZBNo	= op.LeftLinkZBNo;
    RightLinkZBNo	= op.RightLinkZBNo;
    LeftLinkMXNo	= op.LeftLinkMXNo;
    RightLinkMXNo	= op.RightLinkMXNo;
    LeftLinkDevNum	= op.LeftLinkDevNum;
    RightLinkDevNum	= op.RightLinkDevNum;
    for (i=0;i<LeftLinkDevNum;i++)  LeftLinkDevRec[i]  = op.LeftLinkDevRec[i];
    for (i=0;i<RightLinkDevNum;i++) RightLinkDevRec[i] = op.RightLinkDevRec[i];

    LinkZbKgDevRec	= op.LinkZbKgDevRec;
    LinkZbDzDevRec  = op.LinkZbDzDevRec;

    AskFjtUpRec		= op.AskFjtUpRec;
    AskFjtDownRec	= op.AskFjtDownRec;
    AskDrqCloseRec	= op.AskDrqCloseRec;
    AskDrqOpenRec	= op.AskDrqOpenRec;

	URec	= op.URec;
	QRec	= op.QRec;
	LockStatRec = op.LockStatRec;
        
    DRQNum	= op.DRQNum;
    for (i=0;i<DRQNum;i++) DRQ[i] = op.DRQ[i];
    DKQNum	= op.DKQNum;
    for (i=0;i<DKQNum;i++) DKQ[i] = op.DKQ[i];
	
    U	= op.U;
    Q	= op.Q;
    PRec	  = op.PRec;
	bLinkQ	  = op.bLinkQ;
    CheckLock = op.CheckLock;

    ActWeight = op.ActWeight;
    JudgeTime = op.JudgeTime;
	MaxSampleNum = op.MaxSampleNum;
	InitStructProc();
	return *this;
}

void  VQCMUXI_DBS::CopyDefineProc(VQCMUXI_DBS *op)
{
	BYTE i;
	ZBNo	=	op->ZBNo;
	MXNo	=	op->MXNo;
    LeftLinkZBNo	= op->LeftLinkZBNo;
    RightLinkZBNo	= op->RightLinkZBNo;
    LeftLinkMXNo	= op->LeftLinkMXNo;
    RightLinkMXNo	= op->RightLinkMXNo;
    LeftLinkDevNum	= op->LeftLinkDevNum;
    RightLinkDevNum	= op->RightLinkDevNum;
    for (i=0;i<LeftLinkDevNum;i++)  LeftLinkDevRec[i]  = op->LeftLinkDevRec[i];
    for (i=0;i<RightLinkDevNum;i++) RightLinkDevRec[i] = op->RightLinkDevRec[i];

    LinkZbKgDevRec	= op->LinkZbKgDevRec;
    LinkZbDzDevRec  = op->LinkZbDzDevRec;

    AskFjtUpRec		= op->AskFjtUpRec;
    AskFjtDownRec	= op->AskFjtDownRec;
    AskDrqCloseRec	= op->AskDrqCloseRec;
    AskDrqOpenRec	= op->AskDrqOpenRec;

	URec	= op->URec;
	QRec	= op->QRec;
	LockStatRec = op->LockStatRec;
        
    DRQNum	= op->DRQNum;
    for (i=0;i<DRQNum;i++) DRQ[i] = op->DRQ[i];
    DKQNum	= op->DKQNum;
    for (i=0;i<DKQNum;i++) DKQ[i] = op->DKQ[i];
	
    U	= op->U;
    Q	= op->Q;
    PRec	  = op->PRec;
	bLinkQ	  = op->bLinkQ;
    CheckLock = op->CheckLock;

    ActWeight = op->ActWeight;
    JudgeTime = op->JudgeTime;
	MaxSampleNum = op->MaxSampleNum;
	InitStructProc();
}

BOOL VQCMUXI_DBS::FindLeftLinkDevProc()
{
	BYTE zbNo,mxNo,i;
	VQCMUXI_DBS *pmx;
	bLeftLink = FALSE;
	if (LeftLinkDevNum==0) return TRUE;
	for (zbNo=0;zbNo<pFatherZB->pFatherVQC->ZBNum;zbNo++)
		for (mxNo=0;mxNo<pFatherZB->pFatherVQC->ZB[zbNo].MXNum;mxNo++){
			pmx = &(pFatherZB->pFatherVQC->ZB[zbNo].MX[mxNo]);
			if ((pmx->ZBNo==ZBNo)&&(pmx->MXNo==MXNo)) continue;
			if (LeftLinkDevNum != pmx->RightLinkDevNum) continue;
			for (i=0;i<LeftLinkDevNum;i++)
				if (!LeftLinkDevRec[i].CheckEqualDefineProc(&(pmx->RightLinkDevRec[i]))) return FALSE;
			LeftLinkZBNo = zbNo;
			LeftLinkMXNo = mxNo;
			bLeftLink = TRUE;
			return TRUE;
		}
	return FALSE;
}

BOOL VQCMUXI_DBS::FindRightLinkDevProc()
{
	BYTE zbNo,mxNo,i;
	VQCMUXI_DBS *pmx;
	bRightLink = FALSE;
	if (RightLinkDevNum==0) return TRUE;
	for (zbNo=0;zbNo<pFatherZB->pFatherVQC->ZBNum;zbNo++)
		for (mxNo=0;mxNo<pFatherZB->pFatherVQC->ZB[zbNo].MXNum;mxNo++){
			pmx = &(pFatherZB->pFatherVQC->ZB[zbNo].MX[mxNo]);
			if ((pmx->ZBNo==ZBNo)&&(pmx->MXNo==MXNo)) continue;
			if (RightLinkDevNum != pmx->LeftLinkDevNum) continue;
			for (i=0;i<RightLinkDevNum;i++)
				if (!RightLinkDevRec[i].CheckEqualDefineProc(&(pmx->LeftLinkDevRec[i]))) return FALSE;
			RightLinkZBNo = zbNo;
			RightLinkMXNo = mxNo;
			bRightLink = TRUE;
			return TRUE;
		}
	return FALSE;
}


BOOL VQCMUXI_DBS::SetLinkDevProc(char * alarmMsg)
{
	alarmMsg[0] = 0;
	if (!FindLeftLinkDevProc()){
		wsprintf(alarmMsg, "找不到与%d#主变%d#母线左边连接的母线!",ZBNo+1,MXNo+1);
		return FALSE;
	}
	if (!FindRightLinkDevProc()){
		wsprintf(alarmMsg, "找不到与%d#主变%d#母线右边连接的母线!",ZBNo+1,MXNo+1);
		return FALSE;
	}
	return TRUE;
}

BOOL VQCMUXI_DBS::CheckParam(char * alarmMsg)
{
	BYTE i;
	alarmMsg[0] = 0;

	strcpy(alarmMsg, "结构类型不合法或无效的参数!");
	if (ClassSize != sizeof(VQCMUXI_DBS)) return FALSE;

	if (!CheckLock.CheckParam(&alarmMsg[strlen(alarmMsg)])) return FALSE;

	strcpy(alarmMsg, "左右连接设备设置错!");
	if ((LeftLinkDevNum >4)||(LeftLinkDevNum<0)) return FALSE;
	if ((RightLinkDevNum >4)||(RightLinkDevNum<0)) return FALSE;
	for(i=0;i<LeftLinkDevNum;i++)
		if (!LeftLinkDevRec[i].CheckYxParam()) return FALSE;
	for(i=0;i<RightLinkDevNum;i++)
		if (!RightLinkDevRec[i].CheckYxParam()) return FALSE;

/*
	if (LeftLinkDevNum>0){
		if ((LeftLinkZBNo<0)||(LeftLinkMXNo<0)) return FALSE;
		if ((LeftLinkZBNo>VQC_ZBNUM)||(LeftLinkMXNo>2)) return FALSE;
	}
	if (RightLinkDevNum>0){
		if ((RightLinkZBNo<0)||(RightLinkMXNo<0)) return FALSE;
		if ((RightLinkZBNo>VQC_ZBNUM)||(RightLinkMXNo>2)) return FALSE;
	}
*/
		
	wsprintf(alarmMsg, "与主变连接设备设置错!");
	if (!LinkZbKgDevRec.CheckYxParam()) return FALSE;
	if (!LinkZbDzDevRec.CheckYxParam()) return FALSE;
	
	wsprintf(alarmMsg, "动作请求信号设置错!");
	if (!AskFjtUpRec.CheckYxParam()) return FALSE;
	if (!AskFjtDownRec.CheckYxParam()) return FALSE;
	if (!AskDrqCloseRec.CheckYxParam()) return FALSE;
	if (!AskDrqOpenRec.CheckYxParam()) return FALSE;

	if (!URec.CheckYcParam()) {
		wsprintf(alarmMsg, "电压定义错!");
		return FALSE;
	}
	if (!QRec.CheckYcParam())  {
		wsprintf(alarmMsg, "无功定义错!");
		return FALSE;
	}

	if (!LockStatRec.CheckYxParam()) {
		wsprintf(alarmMsg, "VQC子模块闭锁信号设置错!");
		return FALSE;
	}

	if (pGlobalDef->bUseCos)
		if (!PRec.CheckYcParam()) {
			wsprintf(alarmMsg, "有功定义错!");
			return FALSE;
		}
	if ((JudgeTime>1000)||(JudgeTime<30)) {
		wsprintf(alarmMsg, "判越限时间太短!");
		return FALSE;
	}
	if (pGlobalDef->AdjustPeriodTime>0)
		MaxSampleNum = JudgeTime/pGlobalDef->AdjustPeriodTime;
	else MaxSampleNum = 0;

	if ((ActWeight > (MaxSampleNum*10))||(ActWeight <=0)){
		wsprintf(alarmMsg, "动作值设置有错!");
		return FALSE;
	}

	wsprintf(alarmMsg, "电压:");
	if (!U.CheckParam(&alarmMsg[strlen(alarmMsg)])) return FALSE;