vqc.cpp

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

#include "stdafx.h"
#include "vqc.h"

HWND hWndScada;

void VQCSET::SameAllDeviceSet()
{
	BYTE i,j;
	for (i=1;i<VQC_ZBNUM;i++){
		ZB[i].bUseAnotherVoltageLock= ZB[0].bUseAnotherVoltageLock;
		ZB[i].ForbiddenUpValue		= ZB[0].ForbiddenUpValue;
		ZB[i].ForbiddenDownValue	= ZB[0].ForbiddenDownValue;
		ZB[i].IMaxValue				= ZB[0].IMaxValue;
		ZB[i].IMinValue				= ZB[0].IMinValue;
		ZB[i].FjtMaxActTimes		= ZB[0].FjtMaxActTimes;
		ZB[i].MaxPos				= ZB[0].MaxPos;
		ZB[i].MinPos				= ZB[0].MinPos;
		ZB[i].bUseJT				= ZB[0].bUseJT;
		ZB[i].FJTLockTime			= ZB[0].FJTLockTime;
		ZB[i].MidDwNum				= ZB[0].MidDwNum;
		for(j=0;j<VQC_FJTMIDDWNUM;j++)
			ZB[i].MidDw[j] = ZB[0].MidDw[j];
		ZB[i].DQ = ZB[0].DQ;
		ZB[i].DU = ZB[0].DU;
		ZB[i].FJTLockTime = ZB[0].FJTLockTime;
		for (j=0;j<2;j++){
			ZB[i].MX[j].U	= ZB[0].MX[0].U;
			ZB[i].MX[j].Q	= ZB[0].MX[0].Q;
			ZB[i].MX[j].bLinkQ		= ZB[0].MX[0].bLinkQ;
			ZB[i].MX[j].ActWeight	= ZB[0].MX[0].ActWeight;
			ZB[i].MX[j].JudgeTime	= ZB[0].MX[0].JudgeTime;
			ZB[i].MX[j].MaxSampleNum= ZB[0].MX[0].MaxSampleNum;
		}
	}
}

void VQCSET::ClearAllDataRecordProc()
{
	BYTE i;
	if (!globalDef.bCanUse) return;
	globalDef.runTime = 10000;
	actTotalTimes = 0;
	actDayTimes = 0;
	for (i=0;i<VQC_ZBNUM;i++)
		ZB[i].ClearAllDataRecordProc();
}

void VQCSET::InitStructProc()
{
	BYTE i;
	for (i=0;i<VQC_ZBNUM;i++){
		ZB[i].pFatherVQC = this;
		ZB[i].ZBNo = i;
		ZB[i].InitStructProc();
	}
}

VQCSET::VQCSET()
{
	ClassSize = sizeof(VQCSET);
	lockReasonStatus = 0;
	actTotalTimes = 0;
	actDayTimes   = 0;
	LocalStatRec.ReInitDataProc( DATA_TYPE_YX);
	RemoteStartRec.ReInitDataProc( DATA_TYPE_YX);
	RunStatRec.ReInitDataProc( DATA_TYPE_YX);
	globalDef.VQCGlobalDef::VQCGlobalDef();
	CheckLock.Lock_Condition::Lock_Condition();
	ZBNum = 1;
	for(BYTE i=0;i<VQC_ZBNUM;i++) ZB[i].VQCZB_DBS::VQCZB_DBS();
	InitStructProc();
}

VQCSET::~VQCSET()
{
}

void VQCSET::RecRelayMsg(WPARAM wParam, LPARAM lParam)	//wParam=RtuNO, lParam=DotNO
{
	int rtuNo,dotNo;
	int i,j,k;
	rtuNo = (int)wParam;
	dotNo = (int)lParam;
	CheckLock.SetBhStatus(rtuNo, dotNo);
	for (i=0;i<ZBNum;i++){
		ZB[i].CheckLock.SetBhStatus(rtuNo, dotNo);
		ZB[i].ZBBhRec.SetBhStatus(rtuNo, dotNo);
		for (j=0;j<ZB[i].MXNum;j++) {
			ZB[i].MX[j].CheckLock.SetBhStatus(rtuNo, dotNo);
			for (k=0;k<ZB[i].MX[j].DRQNum;k++)
				ZB[i].MX[j].DRQ[k].BhRec.SetBhStatus(rtuNo, dotNo);
			for (k=0;k<ZB[i].MX[j].DKQNum;k++)
				ZB[i].MX[j].DKQ[k].BhRec.SetBhStatus(rtuNo, dotNo);
		};
	}
}


BOOL VQCSET::CheckParam(char *alarmMsg)
{
	BYTE i,j,k;
	alarmMsg[0]= 0;
	strcpy(alarmMsg, "VQC参数不合法!");
	if (ClassSize != sizeof(VQCSET)) return FALSE;

	if (actDayTimes > actTotalTimes) return FALSE;

	if (!LocalStatRec.CheckYxParam()) {
		strcpy(alarmMsg, "就地启动信号设置错！");
		return FALSE;
	}
	if (!RemoteStartRec.CheckYxParam()) {
		strcpy(alarmMsg, "远方启动信号设置错！");
		return FALSE;
	}
	if (!RunStatRec.CheckYxParam()) {
		strcpy(alarmMsg, "当前运行状态信号设置错！");
		return FALSE;
	}

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

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

	if ((ZBNum<1)||(ZBNum > VQC_ZBNUM)) {
		strcpy(alarmMsg, "主变数目不对!");
		return FALSE;
	}
	for (i=0;i<ZBNum;i++) {
		wsprintf(alarmMsg, "%d#主变:", i+1);
		if (!ZB[i].CheckParam(&alarmMsg[strlen(alarmMsg)])) return FALSE;
	}

//First Init Data
	for (i=0;i<ZBNum;i++) {
		for (j=0;j<ZB[i].MXNum;j++)
			if (!ZB[i].MX[j].SetLinkDevProc(alarmMsg)) return FALSE;
	}
	for (i=0;i<VQC_ZBNUM;i++){
		if (globalDef.DevControlMode != DEVMODE_ONLY_DRQ)
			 ZB[i].fjtActNeedLockTime = ZB[i].FJTLockTime;
		else ZB[i].fjtActNeedLockTime = 0;
		ZB[i].adjustNeedLockTime = 0;
		ZB[i].bResultReturn = TRUE;
		ZB[i].ptrCheckDRDKQ = NULL;
		ZB[i].reActTimes = 0;

		for (j=0;j<2;j++){
			ZB[i].MX[j].sampleNum	= 0;
			for (k=0;k<ZB[i].MX[j].DRQNum;k++)
				ZB[i].MX[j].DKQ[k].kgNeedLockTime	= ZB[i].MX[j].DRQ[k].LockTime;
			for (k=0;k<ZB[i].MX[j].DRQNum;k++)
				ZB[i].MX[j].DKQ[k].kgNeedLockTime	= ZB[i].MX[j].DRQ[k].LockTime;
		}
	}

	return TRUE;
}

BOOL VQCSET::SaveParamFileProc(int rtuNo)
{
HFILE hFile;
CString fileName(VQC_PARAM_FILE);
UINT writeByteNum;

	char ss[6];
	if ((rtuNo>99)||(rtuNo<0)) return FALSE;
	
	ownerRtuNo = rtuNo;
	wsprintf(ss, "%02d", rtuNo);
	fileName += ss;

	hFile=_lcreat(fileName, 0);

	if (hFile==HFILE_ERROR) return FALSE;
	writeByteNum = _lwrite(hFile,(char *)this,sizeof(VQCSET));
	_lclose(hFile);
	if (writeByteNum != sizeof(VQCSET)) return FALSE;
	return (TRUE);
}

BOOL VQCSET::ReadParamFileProc(int rtuNo)
{
HFILE hFile;
CString fileName(VQC_PARAM_FILE);
UINT readByteNum;

	char ss[6];
	if ((rtuNo>99)||(rtuNo<0)) return FALSE;
	wsprintf(ss, "%02d", rtuNo);
	fileName += ss;

	ownerRtuNo = rtuNo;

	hFile=_lopen(fileName, OF_READ);

	if (hFile==HFILE_ERROR) return FALSE;
	readByteNum = _lread(hFile,(char *)this,sizeof(VQCSET));
	_lclose(hFile);
	InitStructProc();
	if (readByteNum != sizeof(VQCSET)) return FALSE;

	return (TRUE);
}

VQCSET  VQCSET::operator=(VQCSET op)
{
	globalDef		= op.globalDef;

	LocalStatRec	= op.LocalStatRec;
	RemoteStartRec	= op.RemoteStartRec;
	RunStatRec		= op.RunStatRec;

	CheckLock		= op.CheckLock;

	ZBNum = op.ZBNum;
	if (ZBNum > VQC_ZBNUM) ZBNum = VQC_ZBNUM;
	for (BYTE i=0;i<ZBNum;i++) ZB[i].CopyDefineProc(&(op.ZB[i]));;
	InitStructProc();
	return *this;
}

void VQCSET::EveryDayInitProc()
{
	globalDef.SelectSeasonProc();   //选择季节
	actDayTimes = 0;
	for (BYTE i=0;i<ZBNum;i++)	ZB[i].EveryDayInitProc();
}

void VQCSET::ClearAllManUnlockProc()
{
	int i;
	CheckLock.ClearAllManUnlockProc();
	for (i=0;i<ZBNum;i++)	ZB[i].ClearAllManUnlockProc();
}

//定时进入函数
void VQCSET::TimingProc()
{
	BYTE i;
	static CTime oldTime=0;
	if (!globalDef.bCanUse) return;
	
	globalDef.currTime = CTime::GetCurrentTime();
	globalDef.runTime ++;
	globalDef.SelectSeasonProc();   //选择季节
	if (oldTime.GetDay() != globalDef.currTime.GetDay()){
		EveryDayInitProc();
		oldTime = globalDef.currTime;
	}

	for (i=0;i<ZBNum;i++)	ZB[i].AdjustTimeProc();
	
	CheckLockProc();   //设置闭锁条件
	GetDevLinkStatusProc();
	SetLockStatusForLinkDevProc();  //根据并列运行状况，调整闭锁状态和UQ上下限值
	SetLibValueProc();   //设置虚YX和YC的值
	DoAdjustProc();	     //VQC调节
}

void VQCSET::CheckLockProc()
{
	UINT oldLockReasonStatus;
	oldLockReasonStatus = lockReasonStatus;

	lockReasonStatus = CheckLock.GetLockStatusProc();

	//动作次数太多
    if (actDayTimes >= globalDef.MaxActTimes)
        lockReasonStatus |= LOCK_TIMES_OVER;

	//通讯错，闭锁
	hWndScada = FjLibGetFjWinHandle(FJD_WIN_ID_FJSCADA);
	if (!hWndScada) lockReasonStatus |= LOCK_LOCAL;

	//就地退出
	if (!LocalStatRec.GetStatus()) lockReasonStatus |= LOCK_LOCAL;

	//远方信号与就地信号不同，表示为远方控制
	//若远方将VQC退出,再投入，则闭锁自动清除
	if (!(LocalStatRec.CheckEqualDefineProc(&RemoteStartRec))){
		if (!RemoteStartRec.GetStatus()) {    //远方退出
			lockReasonStatus |= LOCK_REMOTE;
			if (!(oldLockReasonStatus &LOCK_REMOTE))
				VqcPutMsgProc(ownerRtuNo, "远方请求退出VQC");
		}
		else if (oldLockReasonStatus &LOCK_REMOTE){ //远方投入
			ClearAllManUnlockProc();
			VqcPutMsgProc(ownerRtuNo, "远方请求投入VQC");
		}
	}

	if ((lockReasonStatus & LOCK_LOCAL)||(lockReasonStatus & LOCK_REMOTE))
		lockReasonStatus |= LOCK_STOP;

	for (BYTE i=0;i<ZBNum;i++)	ZB[i].CheckLockProc();
}

void VQCSET::GetDevLinkStatusProc()
{
	int i,j;
	for (i=0;i<ZBNum;i++)
		for (j=0;j<ZB[i].MXNum;j++) ZB[i].MX[j].GetDevLinkStatusProc();
	for (i=0;i<ZBNum;i++)
		ZB[i].GetDevLinkStatusProc();
}

void VQCSET::SetLockStatusForLinkDevProc()
{
	for (BYTE i=0;i<ZBNum;i++)	ZB[i].SetLockStatusForLinkDevProc();
}

void  VQCSET::SetLibValueProc()
{
	if (lockReasonStatus & LOCK_STOP) RunStatRec.SetWfStatus(FALSE);
	else RunStatRec.SetWfStatus(TRUE);
	for (BYTE i=0;i<ZBNum;i++)	ZB[i].SetLibValueProc();
}

void VQCSET::DoAdjustProc()
{
//	if (lockReasonStatus) return;
	for (BYTE i=0;i<ZBNum;i++)	ZB[i].DoAdjustProc();
}