GrpcPrint/PrintS/Communication/G4PurifierClient.cpp

#include "G4PurifierClient.h"
#include "S7Command.h"
#include "../SystemInfo.h"
#include "../utils/DataByte.h"
#include "../PLC/SignalService.h"

G4PurifierClient::G4PurifierClient(CommunicationCfg* pconfig) :PurifierClient(pconfig)
{
}


G4PurifierClient::~G4PurifierClient()
{
	Shutdown();
}

void G4PurifierClient::InitCommand()
{
	//PurifierClient::InitCommand();

	S7Command* pcommand = new S7Command(S7_COMMAND_READ_INFO, READ_ITEM_COUNT);
	TS7DataItem* items = pcommand->getDataItems();
	int itemFlag = 0;
	items[itemFlag].Area = S7AreaMK;
	items[itemFlag].WordLen = S7WLByte;
	items[itemFlag].Start = 0;
	items[itemFlag].Amount = 6;
	items[itemFlag].pdata = new unsigned char[6];

	//VD_中效过滤器压力实值
	itemFlag = 1;
	items[itemFlag].Area = S7AreaDB;
	items[itemFlag].WordLen = S7WLByte;
	items[itemFlag].DBNumber = 1;
	items[itemFlag].Start = 0;
	items[itemFlag].Amount = 206;
	items[itemFlag].pdata = new unsigned char[206];

	itemFlag = 2;
	items[itemFlag].Area = S7AreaDB;
	items[itemFlag].WordLen = S7WLByte;
	items[itemFlag].DBNumber = 1;
	items[itemFlag].Start = 1000;
	items[itemFlag].Amount = 1;
	items[itemFlag].pdata = new unsigned char[1];

	pcommand->m_Ref = this;
	pcommand->m_Fun = &G4PurifierClient::G4ProcReadInfoXT;
	pcommand->isNeedDel = false;


	S7Command* pcommand2 = new S7Command(S7_COMMAND_READ_INFO, READ_ITEM_COUNT_2);
	TS7DataItem* items2 = pcommand2->getDataItems();
	itemFlag = 0;
	//报警信息
	items2[itemFlag].Area = S7AreaDB;
	items2[itemFlag].WordLen = S7WLByte;
	items2[itemFlag].DBNumber = 1;
	items2[itemFlag].Start = 389;
	items2[itemFlag].Amount = 5;
	items2[itemFlag].pdata = new unsigned char[5];

	itemFlag = 1;
	//最大风速
	items2[itemFlag].Area = S7AreaDB;
	items2[itemFlag].WordLen = S7WLByte;
	items2[itemFlag].DBNumber = 1;
	items2[itemFlag].Start = 550;
	items2[itemFlag].Amount = 9;
	items2[itemFlag].pdata = new unsigned char[9];

	itemFlag = 2;
	items2[itemFlag].Area = S7AreaDB;
	items2[itemFlag].WordLen = S7WLByte;
	items2[itemFlag].DBNumber = 1;
	items2[itemFlag].Start = 600;
	items2[itemFlag].Amount = 4;
	items2[itemFlag].pdata = new unsigned char[4];

	itemFlag = 3;
	items2[itemFlag].Area = S7AreaDB;
	items2[itemFlag].WordLen = S7WLByte;
	items2[itemFlag].DBNumber = 1;
	items2[itemFlag].Start = 356;
	items2[itemFlag].Amount = 4;
	items2[itemFlag].pdata = new unsigned char[4];

	itemFlag = 4;
	items2[itemFlag].Area = S7AreaDB;
	items2[itemFlag].WordLen = S7WLByte;
	items2[itemFlag].DBNumber = 1;
	items2[itemFlag].Start = 696;
	items2[itemFlag].Amount = 4;
	items2[itemFlag].pdata = new unsigned char[4];

	itemFlag = 5;
	items2[itemFlag].Area = S7AreaDB;
	items2[itemFlag].WordLen = S7WLByte;
	items2[itemFlag].DBNumber = 1;
	items2[itemFlag].Start = 1442;
	items2[itemFlag].Amount = 4;
	items2[itemFlag].pdata = new unsigned char[4];

	itemFlag = 6;
	items2[itemFlag].Area = S7AreaDB;
	items2[itemFlag].WordLen = S7WLByte;
	items2[itemFlag].DBNumber = 1;
	items2[itemFlag].Start = 594;
	items2[itemFlag].Amount = 1;
	items2[itemFlag].pdata = new unsigned char[1];

	itemFlag = 7;
	items2[itemFlag].Area = S7AreaDB;
	items2[itemFlag].WordLen = S7WLByte;
	items2[itemFlag].DBNumber = 1;
	items2[itemFlag].Start = 658;
	items2[itemFlag].Amount = 4;
	items2[itemFlag].pdata = new unsigned char[4];

	itemFlag = 8;
	items2[itemFlag].Area = S7AreaDB;
	items2[itemFlag].WordLen = S7WLByte;
	items2[itemFlag].DBNumber = 1;
	items2[itemFlag].Start = 430;
	items2[itemFlag].Amount = 6;
	items2[itemFlag].pdata = new unsigned char[6];

	pcommand2->m_Ref = this;
	pcommand2->m_Fun = &G4PurifierClient::G4ProcReadInfoXT_2;
	pcommand2->isNeedDel = false;

	//写测氧值
	S7Command* oxygenPressureCom = new S7Command(S7_COMMAND_WRITE, 2);
	TS7DataItem* dataItem = oxygenPressureCom->getDataItems();
	dataItem[0].Area = S7AreaDB;
	dataItem[0].DBNumber = 1;
	dataItem[0].Start = 408;
	dataItem[0].WordLen = S7WLByte;
	dataItem[0].Amount = 4;
	unsigned char* poxygenfloat = new unsigned char[4];
	S7FLOATDATA foxygendata;
	foxygendata.fValue = (g_SystemInfo->m_ComPrintOxygen1 > g_SystemInfo->m_ComPrintOxygen2 ? g_SystemInfo->m_ComPrintOxygen1 : g_SystemInfo->m_ComPrintOxygen2);
	poxygenfloat[0] = foxygendata.data[3];
	poxygenfloat[1] = foxygendata.data[2];
	poxygenfloat[2] = foxygendata.data[1];
	poxygenfloat[3] = foxygendata.data[0];
	dataItem[0].pdata = poxygenfloat;
	m_OxygenWriteValue = (unsigned char*)dataItem[0].pdata;

	dataItem[1].Area = S7AreaDB;
	dataItem[1].DBNumber = 1;
	dataItem[1].Start = 20;
	dataItem[1].WordLen = S7WLByte;
	dataItem[1].Amount = 4;
	unsigned char* pfloat = new unsigned char[4];
	S7FLOATDATA fdata;
	EnterCriticalSection(&g_SystemInfo->m_InfoCs);
	fdata.fValue = g_SystemInfo->m_EnvState.m_PrintPressureAnalog;
	LeaveCriticalSection(&g_SystemInfo->m_InfoCs);
	pfloat[0] = fdata.data[3];
	pfloat[1] = fdata.data[2];
	pfloat[2] = fdata.data[1];
	pfloat[3] = fdata.data[0];
	dataItem[1].pdata = pfloat;
	m_PressureWriteValue = (unsigned char*)dataItem[1].pdata;

	oxygenPressureCom->m_Ref = this;
	oxygenPressureCom->m_Fun = &PurifierClient::ProcWriteValueXT;
	oxygenPressureCom->isNeedDel = false;
	oxygenPressureCom->m_PreWrite = &G4PurifierClient::ProcSetPressureValue;

	m_CycleCommands.push_back(pcommand);
	m_CycleCommands.push_back(pcommand2);
	m_CycleCommands.push_back(oxygenPressureCom);
}


void G4PurifierClient::G4ProcReadInfoXT(void* pobject, Command* pcommand)
{
	S7Command* s7Command = (S7Command*)pcommand;
	TS7DataItem* pdataItems = s7Command->getDataItems();
	int itemcount = s7Command->getItemCount();
	if (pobject == NULL || itemcount != READ_ITEM_COUNT)return;
	G4PurifierClient* ppw = (G4PurifierClient*)pobject;
	TS7DataItem pCtrl = pdataItems[0];
	TS7DataItem pPresure = pdataItems[1];
	TS7DataItem ppCtrl = pdataItems[2];

	TS7DataItem pKeepAlive = pdataItems[7];
	TS7DataItem pFreq = pdataItems[8];
	//TS7DataItem pUseDeoxygenLimit = pdataItems[8];
	//TS7DataItem pUseGasSupply = pdataItems[9];
	//TS7DataItem pFanFreq = pdataItems[8];


	EnterCriticalSection(&ppw->m_ValueCS);
	if (pCtrl.Result == 0) {
		unsigned char* arr = (unsigned char*)pCtrl.pdata;

		bitset<8> M0(arr[0]);
		ppw->m_Stat.isDedusting = M0[2];
		ppw->m_Stat.isBoxCleaning = M0[6];

		bitset<8> M1(arr[1]);
		ppw->m_Stat.isBlowBack = M1[1];
		ppw->m_Stat.isFilterDiscarding = M1[4];
		ppw->m_Stat.isFilterCleaning = M1[7];

		bitset<8> M2(arr[2]);
		ppw->m_Stat.isHopperCleaning = M2[5];

		bitset<8> M5(arr[5]);
		ppw->m_Stat.isPurifying = M5[0];
	}
	if (pPresure.Result == 0) {
		unsigned char* pchar = (unsigned char*)pPresure.pdata;
		ppw->m_Stat.midPressureValue = FLOATDATA(false, &pchar[0]).fValue;
		ppw->m_Stat.midPressureDifValue = FLOATDATA(false, &pchar[4]).fValue;
		ppw->m_Stat.midTemperatureValue = FLOATDATA(false, &pchar[8]).fValue;
		ppw->m_Stat.highPressureDifValue = FLOATDATA(false, &pchar[12]).fValue;
		//ppw->m_Stat.anemometerActualValue = FLOATDATA(false, &pchar[16]).fValue;
		ppw->m_Stat.printPressureValue = FLOATDATA(false, &pchar[20]).fValue;
		ppw->m_Stat.boxPressureUpLimit = FLOATDATA(false, &pchar[28]).fValue;
		ppw->m_Stat.boxPressureDownLimit = FLOATDATA(false, &pchar[32]).fValue;
		ppw->m_Stat.filterOxygenValue = FLOATDATA(false, &pchar[48]).fValue;
		ppw->m_Stat.printOxygenValue = FLOATDATA(false, &pchar[60]).fValue;
		ppw->m_Stat.midPressureDifAlarmValue = FLOATDATA(false, &pchar[64]).fValue;
		ppw->m_Stat.highPressureDifAlarmValue = FLOATDATA(false, &pchar[68]).fValue;
		ppw->m_Stat.printOxygenUpSetValue = FLOATDATA(false, &pchar[76]).fValue;
		ppw->m_RunCfg->m_WarnOxygen = ppw->m_Stat.printOxygenUpSetValue;

		ppw->m_Stat.boxWashTime = ((pchar[110] & 0xff) << 8) + (pchar[111] & 0xff);
		ppw->m_Stat.filterWashTime = ((pchar[112] & 0xff) << 8) + (pchar[113] & 0xff);
		ppw->m_Stat.boxWashDelayTime = ((pchar[114] & 0xff) << 8) + (pchar[115] & 0xff);
		ppw->m_Stat.dedustingWashDelayTime = ((pchar[116] & 0xff) << 8) + (pchar[117] & 0xff);
		ppw->m_Stat.hopperCleanRemind = ((pchar[118] & 0xff) << 8) + (pchar[119] & 0xff);

		ppw->m_Stat.printCleanOxygenSetValue = FLOATDATA(false, &pchar[142]).fValue;
		ppw->m_Stat.windSetValue = FLOATDATA(false, &pchar[146]).fValue;
		ppw->m_Stat.windActualValue = FLOATDATA(false, &pchar[150]).fValue;
		ppw->m_Stat.filterCleanOxygenSetValue = FLOATDATA(false, &pchar[158]).fValue;
		ppw->m_Stat.midTempHighSetValue = FLOATDATA(false, &pchar[166]).fValue;
		ppw->m_Stat.midTempUltraSetValue = FLOATDATA(false, &pchar[170]).fValue;
		ppw->m_Stat.oxygenAlarmValue = FLOATDATA(false, &pchar[190]).fValue;
		ppw->m_RunCfg->SetOxygenAlarmValue(ppw->m_Stat.oxygenAlarmValue);
		ppw->m_RunCfg->SetOxygenTargeValue(ppw->m_Stat.printCleanOxygenSetValue);

		FanFit* al = ppw->m_ExtCfg->m_FanWindFit[ppw->m_ExtCfg->m_SelectedFanWindFit];
		if (al->alarmWind > ppw->m_Stat.windSetValue) {
			al->alarmWind = (ppw->m_Stat.windSetValue > 50.0f) ? (ppw->m_Stat.windSetValue - 50.0f) : 1.0f;
		}

		ppw->m_Stat.filterTotalUseTime = ((pchar[194] & 0xff) << 8) + (pchar[195] & 0xff);
		ppw->m_Stat.usedTimeFromlastBowBack = ((pchar[196] & 0xff) << 8) + (pchar[197] & 0xff);
		ppw->m_Stat.bowBackTimes = ((pchar[198] & 0xff) << 8) + (pchar[199] & 0xff);
		ppw->m_Stat.hopperTimeLastClean = ((pchar[204] & 0xff) << 8) + (pchar[205] & 0xff);

		if (ppw->m_AlarmCfgWrapper->m_PurifierOxygenAlarm) {
			if (ppw->m_Stat.filterOxygenValue > ppw->m_RunCfg->m_FilterOxygenAlarmValue) {
				if (ppw->m_AlarmCfgWrapper->m_PurifierOxygenAlarm->m_AlarmContinueTick > ppw->m_AlarmCfgWrapper->m_PurifierOxygenAlarm->m_CheckAlarmSetTick) {
					ppw->m_AlarmCfgWrapper->m_PurifierOxygenAlarm->m_AlarmInfo = to_string(ppw->m_Stat.filterOxygenValue);
					SignalService::GetInstance().SetAlarm(ppw->m_AlarmCfgWrapper->m_PurifierOxygenAlarm, true);
				}
				else {
					ppw->m_AlarmCfgWrapper->m_PurifierOxygenAlarm->m_AlarmContinueTick++;
				}
			}
			else {
				ppw->m_AlarmCfgWrapper->m_PurifierOxygenAlarm->m_AlarmContinueTick = 0;
				SignalService::GetInstance().SetAlarm(ppw->m_AlarmCfgWrapper->m_PurifierOxygenAlarm, false);
			}
		}
	}
	if (ppCtrl.Result == 0) {
		unsigned char* arr = (unsigned char*)ppCtrl.pdata;
		ppw->m_Stat.ProtectionPressuring = ((arr[0] & 0x10) > 0 ? true : false);
		ppw->m_Stat.protectionPressureEnable = ((arr[0] & 0x40) > 0 ? true : false);
	}

	LeaveCriticalSection(&ppw->m_ValueCS);
}


void G4PurifierClient::G4ProcReadInfoXT_2(void* pobject, Command* pcommand)
{
	S7Command* s7Command = (S7Command*)pcommand;
	TS7DataItem* pdataItems = s7Command->getDataItems();
	int itemcount = s7Command->getItemCount();
	if (pobject == NULL || itemcount != READ_ITEM_COUNT_2)return;
	G4PurifierClient* ppw = (G4PurifierClient*)pobject;

	TS7DataItem pAlarm = pdataItems[0];
	TS7DataItem pMaxWind = pdataItems[1];
	TS7DataItem pCoverWindOffset = pdataItems[2];
	TS7DataItem pWindAct = pdataItems[3];
	TS7DataItem pKeepAlive = pdataItems[4];
	TS7DataItem pFreq = pdataItems[5];
	TS7DataItem pSignal = pdataItems[6];
	TS7DataItem testRel = pdataItems[7];
	TS7DataItem pBlowRel = pdataItems[8];

	EnterCriticalSection(&ppw->m_ValueCS);
	if (pAlarm.Result == 0) {
		unsigned char* arr = (unsigned char*)pAlarm.pdata;
		unsigned char pdata1 = arr[0];
		unsigned char pdata2 = arr[1];
		unsigned char pdata3 = arr[2];

		bitset<8> V389(arr[0]);
		ppw->m_Stat.midTempOverLimitAlarm = V389[0];			//中效高温报警,请注意
		ppw->m_Stat.midHighTempOverLimitAlarm = V389[1];		//中效超高温报警,已经很危险请停机检查
		ppw->m_Stat.hopperUseLongTimeAlarm = V389[2];	//料斗使用时间过长,请进行清理
		ppw->m_Stat.highPressureLackValveAlarm = V389[3]; 	//高压气气压不足，导致阀门异常关闭，请使用稳定气压
		ppw->m_Stat.protectionTestFail = V389[4];
		ppw->m_Stat.inverterAlarm = V389[5];			//变频器报警,请检查电机是否正常
		ppw->m_Stat.whirlwindJarIsFull = V389[6];
		ppw->m_Stat.midInValveOpenAlarm = V389[7];

		bitset<8> V390(arr[1]);
		ppw->m_Stat.cycleInValveOpenAlarm = V390[0];		//循环进气阀打开异常,请检查阀门与感应器是否正常
		ppw->m_Stat.cycleOutValueOpenAlarm = V390[1]; 	//循环出气阀打开异常，请检查阀门与感应器是否正常
		ppw->m_Stat.highPressureLackAlarm = V390[2];	//高压气气压不足，无法启动设备请补充压力
		ppw->m_Stat.protectedPressureLackAlarm = V390[3]; 	//保护气气压不足，无法启动设备请补充压力
		ppw->m_Stat.midConnectException = V390[4]; 		//中效室连接异常，请检查是否连接完毕
		ppw->m_Stat.carbinDoorOpenException = V390[5]; 	//舱门打开异常,请检查关闭好舱门与舱门感应器
		ppw->m_Stat.midFilterBlockAlarm = V390[6];			//中效滤芯堵塞严重,请执行清理工作
		ppw->m_Stat.busOutValveNotOpenAlarm = V390[7]; 	//总排气阀未打开，请检查总排气阀工作状态

		bitset<8> V391(arr[2]);
		ppw->m_Stat.busOutValveNotCloseAlarm = V391[0];		//总排气阀未关闭，请检查总排气阀工作状态
		ppw->m_Stat.busOutValveNotInPosAlarm = V391[1];			//总排气阀处于不到位状态，请检查总排气阀工作状态
		ppw->m_Stat.printOutValveNotOpenAlarm = V391[2];		//打印室排气阀未打开，请检查打印室排气阀工作状态
		ppw->m_Stat.printOutValveNotCloseAlarm = V391[3];		//打印室排气阀未关闭，请检查打印室排气阀工作状态
		ppw->m_Stat.printOutValveNotInPosAlarm = V391[4];			//打印室排气阀处于不到位状态，请检查打印室排气阀工作状态
		ppw->m_Stat.inverterComException = V391[5];
		ppw->m_Stat.anemometerException = V391[6];
		ppw->m_Stat.midOutValveOpenAlarm = V391[7];	

		bitset<8> V393(arr[4]);
		ppw->m_Stat.oxygenSelfTestFail = V393[0];
		ppw->m_Stat.purifierSevereAbnormalExhaust = V393[1];
		if (ppw->m_AlarmCfgWrapper->m_PurifierMidTempAlarm)
			SignalService::GetInstance().SetAlarm(ppw->m_AlarmCfgWrapper->m_PurifierMidTempAlarm, ppw->m_Stat.midTempOverLimitAlarm);
	}

	if (pMaxWind.Result == 0) {
		unsigned char* pchar = (unsigned char*)pMaxWind.pdata;
		ppw->m_Stat.maxWindSetValue = FLOATDATA(false, &pchar[0]).fValue;

		bitset<8> V557(pchar[7]);
		ppw->m_Stat.shieldMonitorPrintPressure = V557[0];
		
		ppw->m_Stat.useArgon = V557[1];
		ppw->m_ExtCfg->m_SelectedFanWindFit = ppw->m_Stat.useArgon ? 1 : 0;
		ppw->m_Stat.isCoverWind = V557[4];

		bitset<8> V558(pchar[8]);
		ppw->m_Stat.inverterDonotWorkWhenDedust = V558[0];
		ppw->m_Stat.printOxygenExceptWhenDedust = V558[1];
		ppw->m_Stat.tempExceptWhenDedust = V558[2];
		ppw->m_Stat.highPressureExceptWhenDedust = V558[3];
		ppw->m_Stat.windExceptWhenDedust = V558[4];

	}

	if (pCoverWindOffset.Result == 0) {
		unsigned char* pchar = (unsigned char*)pCoverWindOffset.pdata;
		ppw->m_Stat.coverWindSpeedOffset = FLOATDATA(false, &pchar[0]).fValue;
	}

	if (pWindAct.Result == 0)
	{
		unsigned char* pchar = (unsigned char*)pWindAct.pdata;
		ppw->m_Stat.anemometerActualValue = FLOATDATA(false, &pchar[0]).fValue;
	}

	if (pKeepAlive.Result == 0)
	{
		char* pchar = (char*)pKeepAlive.pdata;
		ppw->m_Stat.purifierType = ((pchar[0] & 0xff) << 8) + (pchar[1] & 0xff);
		ppw->m_Stat.keepAlive = ((pchar[2] & 0xff) << 8) + (pchar[3] & 0xff);
	}

	if (pFreq.Result == 0)
	{
		unsigned char* pchar = (unsigned char*)pFreq.pdata;
		ppw->m_Stat.fanFreq = FLOATDATA(false, &pchar[0]).fValue;
	}

	if (pSignal.Result == 0)
	{
		char* pchar = (char*)pSignal.pdata;
		bitset<8> V594(pchar[0]);
		ppw->m_Stat.coverWindSlowFinish = V594[6];
		ppw->m_Stat.coverWindResumeFinish = V594[7];
	}

	if (testRel.Result == 0)
	{
		unsigned char* arr = (unsigned char*)testRel.pdata;
		ppw->m_Stat.ProtectionPressureSetTime = ((arr[0] & 0xff) << 8) + (arr[1] & 0xff);
		if (arr[2] == 2) {
			ppw->m_Stat.ProtectionPressureTestRelFail = true;
		}
		else ppw->m_Stat.ProtectionPressureTestRelFail = false;

		if (arr[3] == 2) {
			ppw->m_Stat.oxygenSelfTestRelFail = true;
		}
		else ppw->m_Stat.oxygenSelfTestRelFail = false;

	}

	if (pBlowRel.Result == 0)
	{
		unsigned char* arr = (unsigned char*)pBlowRel.pdata;
		ppw->m_Stat.blowBackBlowTime = ((arr[0] & 0xff) << 8) + (arr[1] & 0xff);
		ppw->m_Stat.blowBackSetTimes = ((arr[4] & 0xff) << 8) + (arr[5] & 0xff);
	}
	LeaveCriticalSection(&ppw->m_ValueCS);
}


void G4PurifierClient::ProcSetPressureValue(void* pobject, Command* pcommand)
{
	if (pobject == NULL)return;
	G4PurifierClient* ppw = (G4PurifierClient*)pobject;
	S7FLOATDATA fdata;
	S7FLOATDATA foxygen;
	g_SystemInfo->LockInfo();
	EnterCriticalSection(&g_SystemInfo->m_InfoCs);
	foxygen.fValue = (g_SystemInfo->m_ComPrintOxygen1 > g_SystemInfo->m_ComPrintOxygen2 ? g_SystemInfo->m_ComPrintOxygen1 : g_SystemInfo->m_ComPrintOxygen2);
	fdata.fValue = g_SystemInfo->m_EnvState.m_PrintPressureAnalog;

	LeaveCriticalSection(&g_SystemInfo->m_InfoCs);
	g_SystemInfo->UnlockInfo();
	ppw->m_PressureWriteValue[0] = fdata.data[3];
	ppw->m_PressureWriteValue[1] = fdata.data[2];
	ppw->m_PressureWriteValue[2] = fdata.data[1];
	ppw->m_PressureWriteValue[3] = fdata.data[0];

	ppw->m_OxygenWriteValue[0] = foxygen.data[3];
	ppw->m_OxygenWriteValue[1] = foxygen.data[2];
	ppw->m_OxygenWriteValue[2] = foxygen.data[1];
	ppw->m_OxygenWriteValue[3] = foxygen.data[0];
}

void G4PurifierClient::SetCoverWind(bool bvalue)
{
	EnterCriticalSection(&m_RtcCS);
	S7Command* pcommand = new S7Command(S7_COMMAND_WRITE, 1);
	TS7DataItem* items = pcommand->getDataItems();
	items[0].Area = S7AreaDB;
	items[0].DBNumber = 1;
	items[0].Start = 557 * 8 + 4;
	items[0].WordLen = S7WLBit;
	items[0].Amount = 1;
	bool* tempv = new bool[1];
	tempv[0] = bvalue;
	items[0].pdata = tempv;
	pcommand->m_Ref = this;
	pcommand->m_waitTime = 0;
	pcommand->m_Fun = &PurifierClient::ProcWriteValueXT;
	m_RTCommands.push(pcommand);
	LeaveCriticalSection(&m_RtcCS);
}

void G4PurifierClient::SetCoverWindOffset(float offset)
{
	if (!IsServerConnected())return;
	SetDBFloat(600, offset);
}

void G4PurifierClient::SetProtectionPressure(bool bvalue)
{
	if (!IsServerConnected())return;
	SetBit(1000 * 8 + 4, bvalue);
}