#include "M1PurifierClient.h"
#include "S7Command.h"
#include <sstream>
#include <bitset>
#include "../utils/DataByte.h"
#include "../global.h"
#include "../SystemInfo.h"
#include "../config/ConfigManager.h"
#include "../PLC/SignalService.h"

M1PurifierClient::M1PurifierClient(CommunicationCfg* pconfig) :S7Client(pconfig)
{
	m_RunCfg = ConfigManager::GetInstance()->GetRunCfg();
	m_ExtCfg = ConfigManager::GetInstance()->GetExtCfg();
	m_AlarmCfgWrapper = ConfigManager::GetInstance()->GetAlarmCfg();
}

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


void M1PurifierClient::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 = 20;
	items[itemFlag].Amount = 10;
	items[itemFlag].pdata = new unsigned char[10];

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

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

	itemFlag = 3;
	items[itemFlag].Area = S7AreaDB;
	items[itemFlag].WordLen = S7WLByte;
	items[itemFlag].DBNumber = 1;
	items[itemFlag].Start = 204;
	items[itemFlag].Amount = 86;
	items[itemFlag].pdata = new unsigned char[86];

	pcommand->m_Ref = this;
	pcommand->m_Fun = &M1PurifierClient::ProcReadInfo;
	pcommand->isNeedDel = false;
	m_CycleCommands.push_back(pcommand);

	//写测氧值
	S7Command* oxygenPressureCom = new S7Command(S7_COMMAND_WRITE, 2);
	TS7DataItem* dataItem = oxygenPressureCom->getDataItems();
	dataItem[0].Area = S7AreaDB;
	dataItem[0].DBNumber = 1;
	dataItem[0].Start = 240;
	dataItem[0].WordLen = S7WLByte;
	dataItem[0].Amount = 4;
	unsigned char* poxygenfloat = new unsigned char[4];
	S7FLOATDATA foxygendata;
	foxygendata.fValue = g_SystemInfo->GetOxygenRealTimeMaxValue();
	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 = 256;
	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 = &M1PurifierClient::ProcWriteValue;
	oxygenPressureCom->isNeedDel = false;
	oxygenPressureCom->m_PreWrite = &M1PurifierClient::ProcSetOxygenValue;
	m_CycleCommands.push_back(oxygenPressureCom);
}

void M1PurifierClient::ProcSetOxygenValue(void* pobject, Command* pcommand)
{
	if (pobject == NULL)return;
	M1PurifierClient* ppw = (M1PurifierClient*)pobject;

	S7FLOATDATA fdata;
	S7FLOATDATA foxygen;
	g_SystemInfo->LockInfo();
	fdata.fValue = g_SystemInfo->m_EnvState.m_PrintPressureAnalog;

	g_SystemInfo->UnlockInfo();
	foxygen.fValue = g_SystemInfo->GetOxygenRealTimeMaxValue();
	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 M1PurifierClient::ProcReadInfo(void* pobject, Command* pcommand)
{
	S7Command* s7Command = (S7Command*)pcommand;
	TS7DataItem* pdataItems = s7Command->getDataItems();
	int itemcount = s7Command->getItemCount();
	if (pobject == NULL || itemcount != READ_ITEM_COUNT)return;
	M1PurifierClient* ppw = (M1PurifierClient*)pobject;
	TS7DataItem pCtrl = pdataItems[0];
	TS7DataItem item1 = pdataItems[1];
	TS7DataItem item2 = pdataItems[2];
	TS7DataItem item3 = pdataItems[3];

	EnterCriticalSection(&ppw->m_ValueCS);
	if (pCtrl.Result == 0) {
		unsigned char* arr = (unsigned char*)pCtrl.pdata;
		std::stringstream ss;
		for (int i = 0; i < pCtrl.Amount; i++) {
			if (arr[i] == 0) break;
			ss << arr[i];
		}
		ppw->m_Info.m_ShowCode = ss.str().c_str();
		ppw->m_Info.m_AppCode = arr[8];
		ppw->m_Info.m_InnerCode = arr[9];
	}

	if (item1.Result == 0) {
		unsigned char* arr = (unsigned char*)item1.pdata;
		std::bitset<8> arr0(arr[0]);
		ppw->m_Info.m_OneKeyDeoxygenCtrl = arr0[0];
		ppw->m_Info.m_DedustCtrl = arr0[1];
		ppw->m_Info.m_BlowbackCtrl = arr0[2];
		ppw->m_Info.m_UseArgon = arr0[4];
		ppw->m_Info.m_AlarmResetCtrl = arr0[5];
		ppw->m_Info.m_PrintRoomDeoxygenCtrl = arr0[7];

		std::bitset<8> arr1(arr[1]);
		ppw->m_Info.m_PurifierDeoxygenCtrl = arr1[0];
		ppw->m_Info.m_CoverWindSlowStartup = arr1[4];
		ppw->m_Info.m_CoverWindResumeStartup = arr1[5];
		ppw->m_Info.m_CoverWindSlowFinish = arr1[6];
		ppw->m_Info.m_CoverWindResumeFinish = arr1[7];

		std::bitset<8> arr2(arr[2]);
		ppw->m_Info.m_IsOneKeyDeoxygen = arr2[1];
		ppw->m_Info.m_IsPuriferDeoxygen = arr2[2];
		ppw->m_Info.m_IsPrintMachinieDeoxygen = arr2[3];
		ppw->m_Info.m_IsCycleDedust = arr2[4];
		ppw->m_Info.m_IsBlowback = arr2[5];

		std::bitset<8> arr3(arr[3]);
		ppw->m_Info.m_IsPurifierRequestBlowback = arr3[4];
		ppw->m_Info.m_IsPrintPause = arr3[5];
		ppw->m_Info.m_IsPurifierBlowbackFinish = arr3[7];

		std::bitset<8> arr4(arr[4]);
		ppw->m_Info.m_IsPowderJarClean = arr4[4];
		ppw->m_Info.m_IsHopperClean = arr4[5];
		ppw->m_Info.m_IsAddInertingAgent = arr4[7];

		std::bitset<8> arr11(arr[11]);
		ppw->m_Info.m_ProtectionTestFail = arr11[4];
		ppw->m_Info.m_MidFilterBlockAlarm = arr11[5];
		ppw->m_Info.m_MidTempOverLimitAlarm = arr11[6];
		ppw->m_Info.m_MidHighTempOverLimitAlarm = arr11[7];

		std::bitset<8> arr12(arr[12]);
		ppw->m_Info.m_InertingValveOpenAlarm = arr12[0];
		ppw->m_Info.m_InertingValveCloseAlarm = arr12[1];
		ppw->m_Info.m_InertingValveMidPos = arr12[2];
		ppw->m_Info.m_InverterAlarm = arr12[3];
		ppw->m_Info.m_UselessPowderValveOpenAlarm = arr12[4];
		ppw->m_Info.m_UselessPowderValveCloseAlarm = arr12[5];
		ppw->m_Info.m_UselessPowderValveMidPos = arr12[6];
		ppw->m_Info.m_CycleInValveOpenAlarm = arr12[7];

		std::bitset<8> arr13(arr[13]);
		ppw->m_Info.m_CycleInValveCloseAlarm = arr13[0];
		ppw->m_Info.m_CycleInValveMidPos = arr13[1];
		ppw->m_Info.m_CycleOutValueOpenAlarm = arr13[2];
		ppw->m_Info.m_CycleOutValueCloseAlarm = arr13[3];
		ppw->m_Info.m_CycleOutValueMidPos = arr13[4];
		ppw->m_Info.m_WorkGasPressureLowAlarm = arr13[5];
		ppw->m_Info.m_CompressedGasPressureLowAlarm = arr13[6];
		ppw->m_Info.m_StandbyStateExceptionAlarm = arr13[7];

		std::bitset<8> arr14(arr[14]);
		ppw->m_Info.m_InertingExhaustValveOpenAlarm = arr14[0];
		ppw->m_Info.m_InertingExhaustValveCloseAlarm = arr14[1];
		ppw->m_Info.m_InertingExhaustValveMidPos = arr14[2];
		ppw->m_Info.m_CyclonePowderValveOpenAlarm = arr14[3];
		ppw->m_Info.m_CyclonePowderValveCloseAlarm = arr14[4];
		ppw->m_Info.m_CyclonePowderValveMidPos = arr14[5];
		ppw->m_Info.m_WastePowderBucketNeedClean = arr14[6];
		ppw->m_Info.m_WastePowderBucketSetupException = arr14[7];

		std::bitset<8> arr15(arr[15]);
		ppw->m_Info.m_InertingAgentNeeedFill = arr15[1];
		ppw->m_Info.m_AnemometerExceptionAlarm = arr15[4];
		ppw->m_Info.m_HopperNeedClean = arr15[5];
		ppw->m_Info.m_FilterNeedBlowback = arr15[6];
		ppw->m_Info.m_InertizerSafetyLockSetupException = arr15[7];
	}

	if (item2.Result == 0) {
		unsigned char* arr = (unsigned char*)item2.pdata;
		int startFlag = 24;
		int flag = 24 - startFlag;
		ppw->m_Info.m_PurifierDeoxygenTargeValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 28 - startFlag;
		ppw->m_Info.m_SettingWindQuantity = FLOATDATA(false, &arr[flag]).fValue;

		flag = 36 - startFlag;
		ppw->m_Info.m_PrintRoomDeoxygenTargeValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 40 - startFlag;
		ppw->m_Info.m_PrintRoomDeoxygenAlarmValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 44 - startFlag;
		ppw->m_Info.m_PrintRoomDeoxygenWarnValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 52 - startFlag;
		ppw->m_Info.m_PuriferPressureReleaseValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 56 - startFlag;
		ppw->m_Info.m_PrintRoomPressureDownLimit = FLOATDATA(false, &arr[flag]).fValue;

		flag = 60 - startFlag;
		ppw->m_Info.m_PrintRoomPressureUpLimit = FLOATDATA(false, &arr[flag]).fValue;

		flag = 68 - startFlag;
		ppw->m_Info.m_PuriferUseTime = USHORTDATA(false, &arr[flag]).usValue;

		flag = 70 - startFlag;
		ppw->m_Info.m_FilterUseTime = USHORTDATA(false, &arr[flag]).usValue;

		flag = 72 - startFlag;
		ppw->m_Info.m_AftBlowbackFilterUseTime = USHORTDATA(false, &arr[flag]).usValue;

		flag = 74 - startFlag;
		ppw->m_Info.m_HopperUseTime = USHORTDATA(false, &arr[flag]).usValue;

		flag = 76 - startFlag;
		ppw->m_Info.m_PrintRoomDeoxygenTime = USHORTDATA(false, &arr[flag]).usValue;

		flag = 78 - startFlag;
		ppw->m_Info.m_PurifireDeoxygenTime = USHORTDATA(false, &arr[flag]).usValue;

		flag = 80 - startFlag;
		ppw->m_Info.m_FilterBlockValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 88 - startFlag;
		ppw->m_Info.m_BlowbackTimes = USHORTDATA(false, &arr[flag]).usValue;

		flag = 92 - startFlag;
		ppw->m_Info.m_FilterBlowbackNotifyTime = USHORTDATA(false, &arr[flag]).usValue;

		flag = 94 - startFlag;
		ppw->m_Info.m_CoverWindDropRate = FLOATDATA(false, &arr[flag]).fValue;

		flag = 102 - startFlag;
		ppw->m_Info.m_OffgasPressureReleaseValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 106 - startFlag;
		ppw->m_Info.m_OffgasFilterBlockValue = FLOATDATA(false, &arr[flag]).fValue;

		ppw->m_RunCfg->SetOxygenAlarmValue(ppw->m_Info.m_PrintRoomDeoxygenAlarmValue);
		ppw->m_RunCfg->SetOxygenWarnValue(ppw->m_Info.m_PrintRoomDeoxygenWarnValue);
		ppw->m_RunCfg->SetOxygenTargeValue(ppw->m_Info.m_PrintRoomDeoxygenTargeValue);

	}

	if (item3.Result == 0) {
		unsigned char* arr = (unsigned char*)item3.pdata;
		int startFlag = 204;
		int flag = 204 - startFlag;
		ppw->m_Info.m_MidPressureValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 208 - startFlag;
		ppw->m_Info.m_FilterDifValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 212 - startFlag;
		ppw->m_Info.m_WindSpeedValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 216 - startFlag;
		ppw->m_Info.m_PurifierOxygenValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 220 - startFlag;
		ppw->m_Info.m_MidTemperatureValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 228 - startFlag;
		ppw->m_Info.m_WorkGasPressureValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 232 - startFlag;
		ppw->m_Info.m_CompressedGasPressureValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 236 - startFlag;
		ppw->m_Info.m_WindQuantityValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 240 - startFlag;
		ppw->m_Info.m_PrintRoomOxygenValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 248 - startFlag;
		ppw->m_Info.m_RealFreq = FLOATDATA(false, &arr[flag]).fValue;

		flag = 252 - startFlag;
		ppw->m_Info.m_SettingWindSpeed = FLOATDATA(false, &arr[flag]).fValue;

		flag = 256 - startFlag;
		ppw->m_Info.m_PrintPressure = FLOATDATA(false, &arr[flag]).fValue;

		flag = 264 - startFlag;
		ppw->m_Info.m_KeepAlive = USHORTDATA(false, &arr[flag]).usValue;

		flag = 266 - startFlag;
		ppw->m_Info.m_OffgasPressureValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 270 - startFlag;
		ppw->m_Info.m_OffgasDifPressureValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 274 - startFlag;
		ppw->m_Info.m_BlowbackAirPocketPressureValue = FLOATDATA(false, &arr[flag]).fValue;

		flag = 278 - startFlag;
		ppw->m_Info.m_TheoryFreq = FLOATDATA(false, &arr[flag]).fValue;

		flag = 282 - startFlag;
		ppw->m_Info.m_WastePowderBucketPowderHigh = FLOATDATA(false, &arr[flag]).fValue;

		flag = 286 - startFlag;
		ppw->m_Info.m_InertingAgentWeight = FLOATDATA(false, &arr[flag]).fValue;

		if (ppw->m_AlarmCfgWrapper->m_PurifierOxygenAlarm) {
			if (ppw->m_Info.m_PurifierOxygenValue > 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_Info.m_PurifierOxygenValue);
					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);
			}
		}
	}

	LeaveCriticalSection(&ppw->m_ValueCS);
}

void M1PurifierClient::GetInfo(M1Info& info)
{
	EnterCriticalSection(&m_ValueCS);
	memcpy_s(&info.m_BaseStat, sizeof(BaseStat), &m_BaseStat, sizeof(BaseStat));
	info.m_ShowCode = m_Info.m_ShowCode;
	info.m_AppCode = m_Info.m_AppCode;
	info.m_InnerCode = m_Info.m_InnerCode;

	info.m_CoverWindSlowStartup = m_Info.m_CoverWindSlowStartup;
	info.m_CoverWindResumeStartup = m_Info.m_CoverWindResumeStartup;
	info.m_CoverWindSlowFinish = m_Info.m_CoverWindSlowFinish;
	info.m_CoverWindResumeFinish = m_Info.m_CoverWindResumeFinish;

	info.m_IsOneKeyDeoxygen = m_Info.m_IsOneKeyDeoxygen;
	info.m_IsPuriferDeoxygen = m_Info.m_IsPuriferDeoxygen;
	info.m_IsPrintMachinieDeoxygen = m_Info.m_IsPrintMachinieDeoxygen;
	info.m_IsCycleDedust = m_Info.m_IsCycleDedust;
	info.m_IsBlowback = m_Info.m_IsBlowback;
	info.m_IsPowderJarClean = m_Info.m_IsPowderJarClean;
	info.m_IsHopperClean = m_Info.m_IsHopperClean;
	info.m_IsAddInertingAgent = m_Info.m_IsAddInertingAgent;
	info.m_IsPurifierRequestBlowback = m_Info.m_IsPurifierRequestBlowback;
	info.m_IsPrintPause = m_Info.m_IsPrintPause;
	info.m_IsPurifierBlowbackFinish = m_Info.m_IsPurifierBlowbackFinish;

	info.m_OneKeyDeoxygenCtrl = m_Info.m_OneKeyDeoxygenCtrl;
	info.m_DedustCtrl = m_Info.m_DedustCtrl;
	info.m_BlowbackCtrl = m_Info.m_BlowbackCtrl;
	info.m_PrintRoomDeoxygenCtrl = m_Info.m_PrintRoomDeoxygenCtrl;
	info.m_PurifierDeoxygenCtrl = m_Info.m_PurifierDeoxygenCtrl;
	info.m_AlarmResetCtrl = m_Info.m_AlarmResetCtrl;

	info.m_ProtectionTestFail = m_Info.m_ProtectionTestFail;
	info.m_MidFilterBlockAlarm = m_Info.m_MidFilterBlockAlarm;
	info.m_MidTempOverLimitAlarm = m_Info.m_MidTempOverLimitAlarm;
	info.m_MidHighTempOverLimitAlarm = m_Info.m_MidHighTempOverLimitAlarm;
	info.m_InertingValveOpenAlarm = m_Info.m_InertingValveOpenAlarm;
	info.m_InertingValveCloseAlarm = m_Info.m_InertingValveCloseAlarm;
	info.m_InertingValveMidPos = m_Info.m_InertingValveMidPos;
	info.m_InverterAlarm = m_Info.m_InverterAlarm;
	info.m_UselessPowderValveOpenAlarm = m_Info.m_UselessPowderValveOpenAlarm;
	info.m_UselessPowderValveCloseAlarm = m_Info.m_UselessPowderValveCloseAlarm;
	info.m_UselessPowderValveMidPos = m_Info.m_UselessPowderValveMidPos;
	info.m_CycleInValveOpenAlarm = m_Info.m_CycleInValveOpenAlarm;
	info.m_CycleInValveCloseAlarm = m_Info.m_CycleInValveCloseAlarm;
	info.m_CycleInValveMidPos = m_Info.m_CycleInValveMidPos;
	info.m_CycleOutValueOpenAlarm = m_Info.m_CycleOutValueOpenAlarm;
	info.m_CycleOutValueCloseAlarm = m_Info.m_CycleOutValueCloseAlarm;
	info.m_CycleOutValueMidPos = m_Info.m_CycleOutValueMidPos;
	info.m_WorkGasPressureLowAlarm = m_Info.m_WorkGasPressureLowAlarm;
	info.m_CompressedGasPressureLowAlarm = m_Info.m_CompressedGasPressureLowAlarm;
	info.m_StandbyStateExceptionAlarm = m_Info.m_StandbyStateExceptionAlarm;
	info.m_InertingExhaustValveOpenAlarm = m_Info.m_InertingExhaustValveOpenAlarm;
	info.m_InertingExhaustValveCloseAlarm = m_Info.m_InertingExhaustValveCloseAlarm;
	info.m_InertingExhaustValveMidPos = m_Info.m_InertingExhaustValveMidPos;
	info.m_CyclonePowderValveOpenAlarm = m_Info.m_CyclonePowderValveOpenAlarm;
	info.m_CyclonePowderValveCloseAlarm = m_Info.m_CyclonePowderValveCloseAlarm;
	info.m_CyclonePowderValveMidPos = m_Info.m_CyclonePowderValveMidPos;
	info.m_WastePowderBucketNeedClean = m_Info.m_WastePowderBucketNeedClean;
	info.m_WastePowderBucketSetupException = m_Info.m_WastePowderBucketSetupException;
	info.m_InertingAgentNeeedFill = m_Info.m_InertingAgentNeeedFill;
	info.m_AnemometerExceptionAlarm = m_Info.m_AnemometerExceptionAlarm;
	info.m_HopperNeedClean = m_Info.m_HopperNeedClean;
	info.m_FilterNeedBlowback = m_Info.m_FilterNeedBlowback;
	info.m_InertizerSafetyLockSetupException = m_Info.m_InertizerSafetyLockSetupException;

	info.m_MidPressureValue = m_Info.m_MidPressureValue;
	info.m_FilterDifValue = m_Info.m_FilterDifValue;
	info.m_MidTemperatureValue = m_Info.m_MidTemperatureValue;
	info.m_WindSpeedValue = m_Info.m_WindSpeedValue;
	info.m_WindQuantityValue = m_Info.m_WindQuantityValue;
	info.m_PurifierOxygenValue = m_Info.m_PurifierOxygenValue;
	info.m_PrintRoomOxygenValue = m_Info.m_PrintRoomOxygenValue;
	info.m_RealFreq = m_Info.m_RealFreq;
	info.m_TheoryFreq = m_Info.m_TheoryFreq;
	info.m_PrintPressure = m_Info.m_PrintPressure;
	info.m_WorkGasPressureValue = m_Info.m_WorkGasPressureValue;
	info.m_CompressedGasPressureValue = m_Info.m_CompressedGasPressureValue;
	info.m_BlowbackAirPocketPressureValue = m_Info.m_BlowbackAirPocketPressureValue;
	info.m_WastePowderBucketPowderHigh = m_Info.m_WastePowderBucketPowderHigh;
	info.m_InertingAgentWeight = m_Info.m_InertingAgentWeight;
	info.m_OffgasPressureValue = m_Info.m_OffgasPressureValue;
	info.m_OffgasDifPressureValue = m_Info.m_OffgasDifPressureValue;
	info.m_PuriferUseTime = m_Info.m_PuriferUseTime;
	info.m_FilterUseTime = m_Info.m_FilterUseTime;
	info.m_AftBlowbackFilterUseTime = m_Info.m_AftBlowbackFilterUseTime;
	info.m_HopperUseTime = m_Info.m_HopperUseTime;
	info.m_KeepAlive = m_Info.m_KeepAlive;

	info.m_PuriferPressureReleaseValue = m_Info.m_PuriferPressureReleaseValue;
	info.m_FilterBlockValue = m_Info.m_FilterBlockValue;
	info.m_SettingWindSpeed = m_Info.m_SettingWindSpeed;
	info.m_SettingWindQuantity = m_Info.m_SettingWindQuantity;
	info.m_PurifierDeoxygenTargeValue = m_Info.m_PurifierDeoxygenTargeValue;
	info.m_PrintRoomDeoxygenTargeValue = m_Info.m_PrintRoomDeoxygenTargeValue;
	info.m_PrintRoomDeoxygenWarnValue = m_Info.m_PrintRoomDeoxygenWarnValue;
	info.m_PrintRoomDeoxygenAlarmValue = m_Info.m_PrintRoomDeoxygenAlarmValue;
	info.m_PrintRoomPressureDownLimit = m_Info.m_PrintRoomPressureDownLimit;
	info.m_PrintRoomPressureUpLimit = m_Info.m_PrintRoomPressureUpLimit;
	info.m_BlowbackTimes = m_Info.m_BlowbackTimes;
	info.m_FilterBlowbackNotifyTime = m_Info.m_FilterBlowbackNotifyTime;
	info.m_PrintRoomDeoxygenTime = m_Info.m_PrintRoomDeoxygenTime;
	info.m_PurifireDeoxygenTime = m_Info.m_PurifireDeoxygenTime;
	info.m_OffgasPressureReleaseValue = m_Info.m_OffgasPressureReleaseValue;
	info.m_OffgasFilterBlockValue = m_Info.m_OffgasFilterBlockValue;
	info.m_CoverWindDropRate = m_Info.m_CoverWindDropRate;
	LeaveCriticalSection(&m_ValueCS);
}

void M1PurifierClient::SetDBFloat(int dindex, float fvalue) {
	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 = dindex;
	items[0].WordLen = S7WLByte;
	items[0].Amount = 4;
	unsigned char* pfloat = new unsigned char[4];
	S7FLOATDATA fdata;
	fdata.fValue = fvalue;
	pfloat[0] = fdata.data[3];
	pfloat[1] = fdata.data[2];
	pfloat[2] = fdata.data[1];
	pfloat[3] = fdata.data[0];
	items[0].pdata = pfloat;
	pcommand->m_Ref = this;
	pcommand->m_Fun = &M1PurifierClient::ProcWriteValue;
	m_RTCommands.push(pcommand);
	LeaveCriticalSection(&m_RtcCS);
}

void M1PurifierClient::SetDBU16(int dindex, uint16_t uvalue) {
	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 = dindex;
	items[0].WordLen = S7WLByte;
	items[0].Amount = 2;
	unsigned char* pu = new unsigned char[2];
	S7WORDDATA fdata;
	fdata.wValue = uvalue;
	pu[0] = fdata.data[1];
	pu[1] = fdata.data[0];
	items[0].pdata = pu;
	pcommand->m_Ref = this;
	pcommand->m_Fun = &M1PurifierClient::ProcWriteValue;
	m_RTCommands.push(pcommand);
	LeaveCriticalSection(&m_RtcCS);
}

void M1PurifierClient::SetBit(int dindex, bool v)
{
	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 = dindex;
	items[0].WordLen = S7WLBit;
	items[0].Amount = 1;
	bool* tempv = new bool[1];
	tempv[0] = v;
	items[0].pdata = tempv;
	pcommand->m_Ref = this;
	pcommand->m_waitTime = 0;
	pcommand->m_Fun = &M1PurifierClient::ProcWriteValue;
	m_RTCommands.push(pcommand);
	LeaveCriticalSection(&m_RtcCS);
}

void M1PurifierClient::ProcWriteValue(void* pobject, Command* pcommand)
{

}

void M1PurifierClient::SetOneKeyDeoxygen(bool bvalue)
{
	if (g_isDebug) {
		m_Info.m_IsOneKeyDeoxygen = bvalue;
	}
	if (!IsServerConnected())return;
	SetBit(0, bvalue);
}

void M1PurifierClient::SetDedust(bool bvalue)
{
	if (g_isDebug) {
		m_Info.m_IsCycleDedust = bvalue;
	}
	if (!IsServerConnected())return;
	SetBit(1, bvalue);
}

void M1PurifierClient::SetBlowBack(bool bvalue)
{
	if (g_isDebug) {
		m_Info.m_IsBlowback = bvalue;
	}
	if (!IsServerConnected())return;
	SetBit(2, bvalue);
}

void M1PurifierClient::SetPrintRoomDeoxygen(bool bvalue)
{
	if (g_isDebug) {
		m_Info.m_IsPrintMachinieDeoxygen = bvalue;
	}
	if (!IsServerConnected())return;
	SetBit(7, bvalue);
}

void M1PurifierClient::SetPurifierDeoxygen(bool bvalue)
{
	if (g_isDebug) {
		m_Info.m_IsPuriferDeoxygen = bvalue;
	}
	if (!IsServerConnected())return;
	SetBit(8, bvalue);
}

void M1PurifierClient::SetUseArgon(bool bvalue)
{
	if (g_isDebug) {
		m_Info.m_UseArgon = bvalue;
	}
	if (!IsServerConnected())return;
	SetBit(4, bvalue);
}

void M1PurifierClient::SetPuriferPressureReleaseValue(float fvalue)
{
	if (g_isDebug) {
		m_Info.m_PuriferPressureReleaseValue = fvalue;
	}
	if (!IsServerConnected())return;
	SetDBFloat(52, fvalue);
}

void M1PurifierClient::SetFilterBlockValue(float fvalue)
{
	if (g_isDebug) {
		m_Info.m_FilterBlockValue = fvalue;
	}
	if (!IsServerConnected())return;
	SetDBFloat(80, fvalue);
}

void M1PurifierClient::SetSettingWindSpeed(float fvalue)
{
	if (g_isDebug) {
		m_Info.m_SettingWindSpeed = fvalue;
	}
	if (!IsServerConnected())return;
	SetDBFloat(252, fvalue);
}

void M1PurifierClient::SetSettingWindQuantity(float fvalue)
{
	if (g_isDebug) {
		m_Info.m_SettingWindQuantity = fvalue;
	}
	if (!IsServerConnected())return;
	SetDBFloat(28, fvalue);
}

void M1PurifierClient::SetPurifierDeoxygenTargeValue(float fvalue)
{
	if (g_isDebug) {
		m_Info.m_PurifierDeoxygenTargeValue = fvalue;
	}
	if (!IsServerConnected())return;
	SetDBFloat(24, fvalue);
}

void M1PurifierClient::SetPrintRoomDeoxygenTargeValue(float fvalue)
{
	if (g_isDebug) {
		m_Info.m_PrintRoomDeoxygenTargeValue = fvalue;
	}
	if (!IsServerConnected())return;
	SetDBFloat(36, fvalue);
}

void M1PurifierClient::SetPrintRoomDeoxygenWarnValue(float fvalue)
{
	if (g_isDebug) {
		m_Info.m_PrintRoomDeoxygenWarnValue = fvalue;
	}
	if (!IsServerConnected())return;
	SetDBFloat(44, fvalue);
}

void M1PurifierClient::SetPrintRoomDeoxygenAlarmValue(float fvalue)
{
	if (g_isDebug) {
		m_Info.m_PrintRoomDeoxygenAlarmValue = fvalue;
	}
	if (!IsServerConnected())return;
	SetDBFloat(40, fvalue);
}

void M1PurifierClient::SetPrintRoomPressureDownLimit(float fvalue)
{
	if (g_isDebug) {
		m_Info.m_PrintRoomPressureDownLimit = fvalue;
	}
	if (!IsServerConnected())return;
	SetDBFloat(56, fvalue);
}

void M1PurifierClient::SetPrintRoomPressureUpLimit(float fvalue)
{
	if (g_isDebug) {
		m_Info.m_PrintRoomPressureUpLimit = fvalue;
	}
	if (!IsServerConnected())return;
	SetDBFloat(60, fvalue);
}

void M1PurifierClient::SetBlowbackTimes(uint16_t uvlaue)
{
	if (g_isDebug) {
		m_Info.m_BlowbackTimes = uvlaue;
	}
	if (!IsServerConnected())return;
	SetDBU16(88, uvlaue);
}

void M1PurifierClient::SetFilterBlowbackNotifyTime(uint16_t uvalue)
{
	if (g_isDebug) {
		m_Info.m_FilterBlowbackNotifyTime = uvalue;
	}
	if (!IsServerConnected())return;
	SetDBU16(92, uvalue);
}

void M1PurifierClient::SetOffgasPressureReleaseValue(float fvalue)
{
	if (g_isDebug) {
		m_Info.m_OffgasPressureReleaseValue = fvalue;
	}
	if (!IsServerConnected())return;
	SetDBFloat(102, fvalue);
}

void M1PurifierClient::SetOffgasFilterBlockValue(float fvalue)
{
	if (g_isDebug) {
		m_Info.m_OffgasFilterBlockValue = fvalue;
	}
	if (!IsServerConnected())return;
	SetDBFloat(106, fvalue);
}

void M1PurifierClient::SetCoverWindSlow(bool bvalue)
{
	if (!IsServerConnected())return;
	SetBit(1 * 8 + 4, bvalue);
}

void M1PurifierClient::SetCoverWindResume(bool bvalue)
{
	if (!IsServerConnected())return;
	SetBit(1 * 8 + 5, bvalue);
}

void M1PurifierClient::ResetCoverWindSlowFinish()
{
	if (!IsServerConnected())return;
	SetBit(1 * 8 + 6, false);
}

void M1PurifierClient::ResetCoverWindResumeFinish()
{
	if (!IsServerConnected())return;
	SetBit(1 * 8 + 7, false);
}

void M1PurifierClient::SetCoverWindDropRate(float fvalue)
{
	if (g_isDebug) {
		m_Info.m_CoverWindDropRate = fvalue;
	}
	if (!IsServerConnected())return;
	SetDBFloat(94, fvalue);
}