#include "ScannerCtrl.h"
#include "../config/ConfigManager.h"
#include "../Toast.h"
#include "../LanguageManager.h"
#include "../SystemInfo.h"
#include "RTC5Scanner.h"
#include "../Logger.h"
#include "../global.h"
#include "../PLC/SignalService.h"
#include "ScannerPair.h"
#include "../utils/StringHelper.h"
#include "../Remote/RemoteClient.h"
#include "../utils/TimeHelper.h"

ScannerCtrl::ScannerCtrl()
	:m_print_thread(INVALID_HANDLE_VALUE)
	, m_RedPrintTestThread(INVALID_HANDLE_VALUE)
	, m_PressureCtrlFlag(false)
	, m_PressureThread(INVALID_HANDLE_VALUE)
	, m_HeatingMotionThread(INVALID_HANDLE_VALUE)
	, m_HeatingMotionFlag(false)
{
	InitializeCriticalSection(&m_LayerTestCs);
	//m_PowderEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	m_DownSkinStopFlag = 1;
	m_IsDownSkinContinue = false;
	time(&m_LastSendFinishReportTime);
}

ScannerCtrl::~ScannerCtrl()
{
	m_PressureCtrlFlag = false;
	if (m_print_thread!= INVALID_HANDLE_VALUE) {
		BaseCtrl::SetState(BaseCtrl::STOP);
		if (WaitForSingleObject(m_print_thread, 5000)==WAIT_TIMEOUT) {
			TerminateThread(m_print_thread, 1);
		}
		CloseHandle(m_print_thread);
		m_print_thread = INVALID_HANDLE_VALUE;
	}
	WaitForSingleObject(m_PressureThread, 1000);
	//if (m_UpScannerPair)delete m_UpScannerPair;
	//if (m_DownScannerPair)delete m_DownScannerPair;

	DeleteCriticalSection(&m_LayerTestCs);

	for (unsigned int i = 0; i < m_scan.size(); i++)
	{
		delete m_scan[i];
	}
	m_scan.clear();

	RTC5Scanner::Uninit();
	
	//CloseHandle(m_PowderEvent);
}

bool ScannerCtrl::Init() {
//	m_UpScannerPair = new ScannerPair();
	//m_DownScannerPair = new ScannerPair();
	m_RunCfg = ConfigManager::GetInstance()->GetRunCfg();
	m_MachineCfg = ConfigManager::GetInstance()->GetMachineCfg();
	m_Machine = ConfigManager::GetInstance()->GetMachine();
	m_IOCfgWrapper = ConfigManager::GetInstance()->GetIoCfgWrapper();
	m_ExtCfg = ConfigManager::GetInstance()->GetExtCfg();
	m_CoverCfg = ConfigManager::GetInstance()->GetCoverCfg();
	m_PowderEstimateCfg = ConfigManager::GetInstance()->GetPowderEstimateCfg();
	m_AlarmCfgWrapper = ConfigManager::GetInstance()->GetAlarmCfg();
	m_RecoatCheckCfg = ConfigManager::GetInstance()->GetRecoatCheckCfg();
	map<int, ScannerControlCfg*>* scannerControlCfgsMap = ConfigManager::GetInstance()->GetScannerControlCfg();
	bool rel = false;
	unsigned int card_num = 0;
	RTC5Scanner::PreInit(card_num);

	

	int difSize = Scanner::m_CurrentSerio.size() - scannerControlCfgsMap->size();
	if (difSize > 0) {
		int flag = 0;
		for (map<int, unsigned int>::iterator s = Scanner::m_CurrentSerio.begin(); s != Scanner::m_CurrentSerio.end(); s++) {
			bool find = false;
			for (map<int, ScannerControlCfg*>::iterator scc = scannerControlCfgsMap->begin(); scc != scannerControlCfgsMap->end(); scc++)
			{
				ScannerControlCfg* cfg = scc->second;
				if (cfg->m_SerialNo == s->second)
				{
					find = true;
					break;
				}
			}
			if (!find && flag < difSize)
			{
				ScannerControlCfg* cfg = new ScannerControlCfg();
				cfg->m_SeqNo = scannerControlCfgsMap->size() + 1;
				cfg->m_CardName = "Laser" + to_string(cfg->m_SeqNo);
				cfg->m_ControlNo = s->first;
				cfg->m_ControlType = m_MachineCfg->m_ScanControl;
				cfg->m_SerialNo = s->second;
				cfg->m_HadMatch = false;
				cfg->m_IsEnable = true;
				cfg->Init();
				//m_Machine->InitScanParamBeforeFind(&cfg->m_ScanCfgWrapper);   //wxxtest
				ConfigManager::GetInstance()->GetScannerControlCfgDao()->Add(cfg);
				ConfigManager::GetInstance()->GetScannerControlCfgDao()->Maintain(cfg);
				ConfigManager::GetInstance()->GetScannerControlCfgs()->push_back(cfg);
				(*scannerControlCfgsMap)[cfg->m_SeqNo] = cfg;
				flag++;
			}
		}
	}

	if (card_num == 0)
	{
		g_log->TraceError(_(u8"没有振镜控制卡").c_str());
		m_InitErrorInfos.push_back(_(u8"没有振镜控制卡").c_str());
		return false;
	}
	

	for (map<int, ScannerControlCfg*>::iterator sit = scannerControlCfgsMap->begin(); sit != scannerControlCfgsMap->end(); sit++) {
		ScannerControlCfg* cfg = sit->second;
		if (m_IOCfgWrapper->m_LaserIOMap.find(cfg->m_SeqNo) != m_IOCfgWrapper->m_LaserIOMap.end()) {
			cfg->m_LaserRed = m_IOCfgWrapper->m_LaserIOMap[cfg->m_SeqNo]->m_LaserRed;
			cfg->m_LaserStart = m_IOCfgWrapper->m_LaserIOMap[cfg->m_SeqNo]->m_LaserStart;
			cfg->m_LaserEnable = m_IOCfgWrapper->m_LaserIOMap[cfg->m_SeqNo]->m_LaserEnable;
		}
		Scanner* scanner = new RTC5Scanner(cfg);

	
		if (scanner->Init())
		{
			ConfigManager::GetInstance()->GetMatchScannerControlCfg()->push_back(cfg);
			m_scan.push_back(scanner);
		}
		else
		{
			delete scanner;
			scanner = NULL;
			char buffer[256];
			sprintf_s(buffer, sizeof(buffer), _(u8"振镜卡 %d 初始化失败").c_str(), cfg->m_SeqNo);
			g_log->TraceError(buffer);
			m_InitErrorInfos.push_back(buffer);
		}
		LaserParam* param = new LaserParam();
		g_SystemInfo->m_StateBean.laserParams.push_back(param);
	}


	if (m_scan.empty())
	{
		g_log->TraceError(_(u8"配置有误，不能生成振镜控制模块").c_str());
		m_InitErrorInfos.push_back(_(u8"配置有误，不能生成振镜控制模块").c_str());
		rel = false;
	}
	else {
		if (m_scan.size() == 4)
		{
			m_scan[0]->SetPairScan(m_scan[1]);
			m_scan[1]->SetPairScan(m_scan[0]);
			m_scan[2]->SetPairScan(m_scan[3]);
			m_scan[3]->SetPairScan(m_scan[2]);
		}
	}
	
	//#endif

	return rel;
}

DWORD WINAPI ScannerCtrl::PrintProc(thisClass* _this)
{
	if (_this != nullptr) {
		_this->PrintRun();
		_this->CtrlIoWhenExit();
		if (!BaseCtrl::IsPauseStanBy()) {
			_this->m_IOCfgWrapper->m_PrintDoorLock->SetActive(false);
		}
	}
	return 0;
}

void ScannerCtrl::PrintRun()
{
	bool startAfterPause = false;
	if (BaseCtrl::IsPauseStanBy()) {
		startAfterPause = true;
	}
	if (!startAfterPause) {
		m_job_controller->GetJob()->m_TaskId = StringHelper::GenerateUUID();
	}
	BaseCtrl::SetState(BaseCtrl::PREPRINT);
	BaseCtrl::SetPauseState(BaseCtrl::NoPause);
	BaseCtrl::SetPreState(BaseCtrl::CheckIO);


	m_IOCfgWrapper->m_PrintDoorLock->SetActive(true);

	IOCfg* servoMotor = m_IOCfgWrapper->m_ServoMotor;
	if (!servoMotor->IsActive()) {
		servoMotor->SetActive(true);
		g_Toast->AddToast(new ToastBean(_(u8"正在打开伺服驱动").c_str(), 3000, ImVec4(1, 0.4f, 0, 1)));
		Sleep(3000);
	}

	SignalService& alarmService = SignalService::GetInstance();

	//if (!m_Machine->CheckPrintMoldReady() && !g_isDebug) {    //wxxtest
	//	g_Toast->AddToast(new ToastBean(_(u8"执行失败：缸体未在打印位装载").c_str(), 3000, Toast::COLOR_RED));
	//	BaseCtrl::SetState(BaseCtrl::STANDBY);
	//	return;
	//}

	//检测振镜检测红光
	vector<ScannerControlCfg*>* laserCfgs = ConfigManager::GetInstance()->GetMatchScannerControlCfg();
	for (size_t laserIndex = 0; laserIndex < laserCfgs->size();laserIndex++) {
		ScannerControlCfg* laserCfg = (*laserCfgs)[laserIndex];
		if (laserCfg->m_LaserRed && laserCfg->m_LaserRed->IsActive()) {
			laserCfg->m_LaserRed->SetActive(false);
		}
	}

	bool isHeatingActive = false;
	if (m_IOCfgWrapper->m_Heating) {
		isHeatingActive = m_IOCfgWrapper->m_Heating->IsActive();
	}
	if (!m_job_controller->GetJob()->m_IsAutoCtrl && m_job_controller->GetJob()->m_AutoHeatingScanner) {
		if (m_IOCfgWrapper->m_Heating) {
			m_IOCfgWrapper->m_Heating->SetActive(true);
		}
		Sleep(500);
		m_MachineCtrl->StopLaser(true);
		if (!m_IOCfgWrapper->m_Laser->IsActive()) {
			m_IOCfgWrapper->m_Laser->SetActive(true);
			Sleep(10000);
		}
		vector<ScannerControlCfg*>* laserCfgs = ConfigManager::GetInstance()->GetMatchScannerControlCfg();
		for (size_t laserIndex = 0; laserIndex < laserCfgs->size(); laserIndex++) {
			ScannerControlCfg* laserCfg = (*laserCfgs)[laserIndex];
			if (laserCfg->m_LaserRed && !laserCfg->m_LaserRed->IsActive()) {
				laserCfg->m_LaserRed->SetActive(true);
			}
		}
		Sleep(500);
		for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
			Scanner* scanner = m_scan[scanIndex];
			scanner->StartHeatingScannerTest();
		}
	}


	if (!m_RunCfg->m_IsDebugMode) {
		if (!ReadyPrint(startAfterPause)) {
			for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
				Scanner* scanner = m_scan[scanIndex];
				scanner->WaitHeatingScanner();
			}

			for (size_t laserIndex = 0; laserIndex < laserCfgs->size(); laserIndex++) {
				ScannerControlCfg* laserCfg = (*laserCfgs)[laserIndex];
				if (laserCfg->m_LaserRed && laserCfg->m_LaserRed->IsActive()) {
					laserCfg->m_LaserRed->SetActive(false);
				}
			}
			if (!isHeatingActive) {
				if (m_IOCfgWrapper->m_Heating) {
					m_IOCfgWrapper->m_Heating->SetActive(false);
					Sleep(500);
				}
			}
			BaseCtrl::SetState(BaseCtrl::STANDBY);

			return;
		}
		
		if (alarmService.CheckAlarmAfterDeoxygen())
		{
			for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
				Scanner* scanner = m_scan[scanIndex];
				scanner->WaitHeatingScanner();
			}

			for (size_t laserIndex = 0; laserIndex < laserCfgs->size(); laserIndex++) {
				ScannerControlCfg* laserCfg = (*laserCfgs)[laserIndex];
				if (laserCfg->m_LaserRed && laserCfg->m_LaserRed->IsActive()) {
					laserCfg->m_LaserRed->SetActive(false);
				}
			}
			if (!isHeatingActive) {
				if (m_IOCfgWrapper->m_Heating) {
					m_IOCfgWrapper->m_Heating->SetActive(false);
					Sleep(500);
				}
			}
			BaseCtrl::SetState(BaseCtrl::STANDBY);
			return;
		}
	}
	

	for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
		Scanner* scanner = m_scan[scanIndex];
		scanner->WaitHeatingScanner();
	}

	for (size_t laserIndex = 0; laserIndex < laserCfgs->size(); laserIndex++) {
		ScannerControlCfg* laserCfg = (*laserCfgs)[laserIndex];
		if (laserCfg->m_LaserRed && laserCfg->m_LaserRed->IsActive()) {
			laserCfg->m_LaserRed->SetActive(false);
		}
	}
	if (!isHeatingActive) {
		if (m_IOCfgWrapper->m_Heating) {
			m_IOCfgWrapper->m_Heating->SetActive(false);
			Sleep(500);
		}
	}

	if (m_IOCfgWrapper->m_Heating && m_IOCfgWrapper->m_Heating->IsActive())
	{
		TempStat ts;
		int count = 0;
		float platformTemp = 0.0f;
		float platformTempSettingValue = 0.0f;
		while (BaseCtrl::IsPrePrint()) {
			if (!m_IOCfgWrapper->m_Heating->IsActive()) {
				break;
			}
			EnterCriticalSection(&g_SystemInfo->m_InfoCs);
			platformTemp = g_SystemInfo->m_PlatformTemp;
			platformTempSettingValue = g_SystemInfo->m_PlatformTempSettingValue;
			LeaveCriticalSection(&g_SystemInfo->m_InfoCs);

			if ((platformTempSettingValue - platformTemp) < 3.0f) {
				break;
			}
			else {
				if ((count % 20) == 0) {
					g_Toast->AddToast(new ToastBean(_(u8"正在等待基板预热").c_str(), 3000, Toast::COLOR_ORANGE));
				}
			}
			count++;
			if (count > 100000)count = 0;
			Sleep(500);
		}
	}
	if (!BaseCtrl::IsPrePrint()) {
		BaseCtrl::SetState(BaseCtrl::STANDBY);
		return;
	}

	if (!m_job_controller->GetJob()->m_IsAutoCtrl) {
		BaseCtrl::SetPreState(BaseCtrl::WaitConfirm);
		bool isconfirm = false;
		while (BaseCtrl::IsPrePrint())
		{
			if (BaseCtrl::GetPreState() == CancelConfirm) {
				break;
			}
			if (BaseCtrl::GetPreState() == SummitConfirm) {
				isconfirm = true;
				break;
			}
			Sleep(300);
		}

		if (!isconfirm) {
			BaseCtrl::SetState(BaseCtrl::STANDBY);
			BaseCtrl::SetPreState(BaseCtrl::NonePre);
			return;
		}
	}

	BaseCtrl::SetPreState(BaseCtrl::PreFinished);
	if (!BaseCtrl::IsPrePrint()) {
		BaseCtrl::SetState(BaseCtrl::STANDBY);
		BaseCtrl::SetPreState(BaseCtrl::NonePre);
		return;
	}
	StopHeatingMotion(true);

	m_MachineCtrl->StartLaser(true);
	//m_gc->StartLaser(true);
	if (!BaseCtrl::IsPrePrint()) {
		BaseCtrl::SetState(BaseCtrl::STANDBY);
		BaseCtrl::SetPreState(BaseCtrl::NonePre);
		return;
	}
	g_SystemInfo->m_AutoPrintCtrlState = AutoPrint;
	m_job_controller->GetJob()->m_BeginPrintTime = GetTickCount64();
	if (m_job_controller->GetJob()->m_FirstStartTime == 0L)m_job_controller->GetJob()->m_FirstStartTime = GetTickCount64();
	JobBean* jobBean = m_job_controller->GetJob()->GetJobbean();
	jobBean->m_TaskID = m_job_controller->GetJob()->m_TaskId;
	m_job_controller->GetJob()->UpdateJobBeanWhenStart();

	if (!jobBean->m_IsContinue) {
		g_SystemInfo->LockInfo();
		jobBean->m_StartMoldPos = g_SystemInfo->m_MoldMainPos;
		g_SystemInfo->UnlockInfo();
		jobBean->m_FirstStartIndex = m_job_controller->GetJob()->GetStartIndex();
	}
	g_log->m_LogDao->LogJobStart(jobBean);
	if (m_ScannerPowerClient)m_ScannerPowerClient->SetJobId(jobBean->m_Id);

	BaseCtrl::SetState(BaseCtrl::PRINTING);
	for (size_t i = 0; i < m_scan.size(); i++)
	{
		m_scan[i]->SetAutoUpdateScanInfo(false);
		m_scan[i]->ResetDefocus();
		m_scan[i]->m_IsOrderSeqV2 = m_job_controller->GetJob()->GetMetaData()->m_IsScanOrderSeqV2;
	}
	Sleep(500);
	DispatchDataBlock();

	Sleep(100);
	for (size_t i = 0; i < m_scan.size(); i++)
	{
		m_scan[i]->SetAutoUpdateScanInfo(true);
		m_scan[i]->ResetDefocus();
	}

	if (m_ServoManager)m_ServoManager->ResetLogServo();
	g_log->m_LogDao->ResetImageDB();
	if (BaseCtrl::IsFinish()) {
		g_SystemInfo->m_AutoPrintCtrlState = NoAuto;
		if (m_RemoteClient)m_RemoteClient->SetNeedSendFinish(true);
		m_ShowFinishReport = true;
		CtrlWhenStop();
		m_job_controller->GetJob()->UpdateJobBeanWhenStop();
		g_SystemInfo->m_StateBean.layerIndex = 0;
		m_IOCfgWrapper->m_PrintDoorLock->SetActive(false);
	}
	else if(BaseCtrl::IsPause()){
		m_job_controller->GetJob()->GetJobbean()->m_IsContinue = true;
		m_job_controller->GetJob()->GetJobbean()->m_PrintSecond = m_job_controller->GetJob()->GetJobbean()->m_PrintSecond + (int)m_job_controller->GetJob()->GetJobbean()->m_EveryPrintedTime;
		if (m_RunCfg->m_PrintRestEnable) {
			g_SystemInfo->m_AutoPrintCtrlState = AutoPause;
			m_job_controller->GetJob()->m_AutoPauseTime = GetTickCount64();
		}
		BaseCtrl::SetState(BaseCtrl::STANDBY_PAUSE);
	}
	else if (BaseCtrl::IsStop()) {
		m_job_controller->GetJob()->UpdateJobBeanWhenStop();
		g_SystemInfo->m_StateBean.layerIndex = 0;
		CtrlWhenStop();
		m_IOCfgWrapper->m_PrintDoorLock->SetActive(false);
		BaseCtrl::SetState(BaseCtrl::STANDBY_STOP);
	}
	else {
		BaseCtrl::SetState(BaseCtrl::STANDBY);
	}
	BaseCtrl::SetPreState(BaseCtrl::NonePre);
	CtrlIoWhenExit();
	
}


bool ScannerCtrl::ReadyPrint(bool startAfterPause)
{
	//DWORD startTick = GetTickCount64();
	unsigned int deoxytime = 0;
	bool rel = false;
	rel=m_PurifierClient->HandleReadyPrint(startAfterPause, deoxytime);
	//DWORD stoptick = GetTickCount64();

	FileProcessor* job = m_job_controller->GetJob();
	if (job) {
		job->GetJobbean()->m_DeoxygenSecond = deoxytime;
	}
	return rel;
}

void ScannerCtrl::StopRedTest()
{
	PrintState printStateTemp = BaseCtrl::GetState();
	BaseCtrl::SetState(BaseCtrl::STOP);
	EnterCriticalSection(&m_LayerTestCs);
	if (m_RedPrintTestThread != INVALID_HANDLE_VALUE) {
		for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
			Scanner* scanner = m_scan[scanIndex];
			scanner->StopWork();
		}
		if (WaitForSingleObject(m_RedPrintTestThread, 1000) == WAIT_TIMEOUT) {
			TerminateThread(m_RedPrintTestThread, 0);
		}
		CloseHandle(m_RedPrintTestThread);
		m_RedPrintTestThread = INVALID_HANDLE_VALUE;
	}
	LeaveCriticalSection(&m_LayerTestCs);
	BaseCtrl::SetState(printStateTemp);

	for (size_t i = 0; i < m_scan.size();i++) {
		m_scan[i]->Clean();
	}
}

DWORD WINAPI ScannerCtrl::RedPrintTestProc(thisClass* _this)
{
	if (_this)
	{
		_this->DispatchTestDataBlock();
		EnterCriticalSection(&_this->m_LayerTestCs);
		if (_this->m_RedPrintTestThread != INVALID_HANDLE_VALUE) {
			CloseHandle(_this->m_RedPrintTestThread);
			_this->m_RedPrintTestThread = INVALID_HANDLE_VALUE;
		}
		LeaveCriticalSection(&_this->m_LayerTestCs);
	}
	return 0;
}


bool ScannerCtrl::BeginWork()
{
	StopRedTest();
	for (size_t i = 0; i < m_scan.size(); i++) {
		m_scan[i]->StopDebugTest();
	}
	if (m_scan.size() == 0)
	{
		ToastBean* bean = new ToastBean(_(u8"没有振镜控制卡").c_str(), 3000);
		g_Toast->AddToast(bean);
		return false;
	}
	//是否达到打印条件
	/*if (m_AlarmCfgWrapper->m_CoverBreak)m_AlarmCfgWrapper->m_CoverBreak->m_IsAlarm = false;
	if(m_AlarmCfgWrapper->m_MoldMotionTransferAlarm)m_AlarmCfgWrapper->m_MoldMotionTransferAlarm->m_IsAlarm = false;
	if (m_AlarmCfgWrapper->m_PowderMotionTransferAlarm)m_AlarmCfgWrapper->m_PowderMotionTransferAlarm->m_IsAlarm = false;
	*/
	SignalService::GetInstance().ResetRelateCoverAlarm();
	if (!m_job_controller || !m_job_controller->GetJob()) {
		ToastBean* bean = new ToastBean(_(u8"没有可打印的任务").c_str(),3000);
		g_Toast->AddToast(bean);
		return false;
	}

	if (!m_job_controller->CheckDiskSpace())
	{
		char buffer[123];
		sprintf_s(buffer, sizeof(buffer), _(u8"任务执行失败：%s空间不足，请清理").c_str(), g_AppDisk.c_str());
		ToastBean* bean = new ToastBean(buffer, 5000, Toast::COLOR_RED);
		g_Toast->AddToast(bean);
		return false;
	}


	if (!g_isDebug) {
		vector<string> ei;
		m_job_controller->GetJob()->GetMetaData()->GetErrorInfo(ei);
		if (!ei.empty()) {
			g_Toast->AddToast(new ToastBean(ei[0], 5000, Toast::COLOR_RED));
			return false;
		}
	}

	if (m_scan.size()==1)
	{
		Scanner* sc = m_scan[0];
		if (!sc) {
			return false;
		}
		vector<MetaData::Part*> &partVec = m_job_controller->GetJob()->GetMetaData()->GetPartVec();
		CorrectParamCfg* correctCfg = &sc->GetConfig()->m_ScanCfgWrapper.m_CorrectParamCfg;
		char buffer[1024];
		bool hasOutLimit = false;
		for (size_t i = 0; i < partVec.size(); ++i)
		{
			MetaData::Part* part = partVec[i];
			if (!part->print_enable)continue;

			double corxmin = (part->dimensions->xmin + part->partPosBean.m_XOffset );
			double corxmax = (part->dimensions->xmax + part->partPosBean.m_XOffset);
			double corymin = (part->dimensions->ymin + part->partPosBean.m_YOffset );
			double corymxn = (part->dimensions->ymax + part->partPosBean.m_YOffset);
			if (corxmin<correctCfg->m_xmeasure_min || corxmax>correctCfg->m_xmeasure_max) {
				sprintf_s(buffer, sizeof(buffer), _(u8"零件：%s X方向超出可打印范围").c_str(), part->name.c_str());
				hasOutLimit = true;
				break;
			}
			if (corymin<correctCfg->m_ymeasure_min || corymxn>correctCfg->m_ymeasure_max) {
				sprintf_s(buffer, sizeof(buffer), _(u8"零件：%s Y方向超出可打印范围").c_str(), part->name.c_str());
				hasOutLimit = true;
				break;
			}
		}
		if (hasOutLimit) {
			ToastBean* bean = new ToastBean(buffer, 5000, Toast::COLOR_RED);
			g_Toast->AddToast(bean);
			return false;
		}
	}
	


	if (!SignalService::GetInstance().CheckAlarmBeforeDeoxygen())
	{
		return false;
	}
	

	if (!m_RunCfg->m_HadSetBasePlatformPoint && !m_RunCfg->m_IsDebugMode) {
		ToastBean* bean = new ToastBean(_(u8"请先执行基板缸平面位置确定").c_str(), 5000, Toast::COLOR_RED);
		g_Toast->AddToast(bean);
		return false;
	}

	if (!BaseCtrl::IsStandBy()) {
		ToastBean* bean = new ToastBean(_(u8"请等待系统就绪后再开始任务").c_str(), 3000);
		g_Toast->AddToast(bean);
		return false;
	}

	if (!g_isDebug) {
		if (!m_Machine->CheckPrintHigh(m_job_controller->GetJob()->GetJobPrintHigh()))
		{
			return false;
		}
	}
	m_IOCfgWrapper->SetAutoCtrlHeating(false);

	m_print_thread = AtlCreateThread(PrintProc, this);
	return true;
}

bool ScannerCtrl::PauseWork()
{
	m_PauseMsg = "";
	SignalService::GetInstance().ResetRelateCoverAlarm();
	if (!m_job_controller || !m_job_controller->GetJob()) {
		ToastBean* bean = new ToastBean(_(u8"没有可暂停的打印任务").c_str(), 3000);
		g_Toast->AddToast(bean);
		m_PauseMsg = _(u8"没有可暂停的打印任务").c_str();
		return false;
	}
	m_job_controller->GetJob()->m_IsAutoCtrl = false;
	g_SystemInfo->m_AutoPrintCtrlState = NoAuto;
	if (BaseCtrl::IsStandBy()) {
		m_PauseMsg = _(u8"就绪状态不能暂停").c_str();
		return false;
	}
	BaseCtrl::SetState(BaseCtrl::PAUSE);
	BaseCtrl::SetPreState(BaseCtrl::NonePre);
	g_Toast->AddToast(new ToastBean(_(u8"正在暂停任务").c_str(),3000,Toast::COLOR_ORANGE));
	g_log->TraceInfo(_(u8"暂停任务").c_str());
	return true;
}

void ScannerCtrl::PauseAuto()
{
	SignalService::GetInstance().ResetRelateCoverAlarm();
	
	if (!m_job_controller || !m_job_controller->GetJob()) {
		ToastBean* bean = new ToastBean(_(u8"没有可暂停的打印任务").c_str(), 3000);
		g_Toast->AddToast(bean);
		return ;
	}
	
	m_job_controller->GetJob()->m_IsAutoCtrl = true;
	if (BaseCtrl::IsStandBy()) {
		return ;
	}
	BaseCtrl::SetState(BaseCtrl::PAUSE);
	BaseCtrl::SetPreState(BaseCtrl::NonePre);
	g_Toast->AddToast(new ToastBean(_(u8"正在暂停任务").c_str(), 3000, Toast::COLOR_ORANGE));
	g_log->TraceInfo(_(u8"自动暂停任务").c_str());
}

bool ScannerCtrl::StopWork()
{
	
	m_StopMsg = "";
	SignalService::GetInstance().ResetRelateCoverAlarm();
	if (!m_job_controller || !m_job_controller->GetJob()) {
		ToastBean* bean = new ToastBean(_(u8"没有可停止的打印任务").c_str(), 3000);
		g_Toast->AddToast(bean);
		m_StopMsg = _(u8"没有可停止的打印任务").c_str();
		return false;
	}
	m_job_controller->GetJob()->m_IsAutoCtrl = false;
	g_SystemInfo->m_AutoPrintCtrlState = NoAuto;
	BaseCtrl::SetPauseState(BaseCtrl::NoPause);
	if (BaseCtrl::IsStandBy()) {
		m_job_controller->GetJob()->SetStartIndex(0);
		m_job_controller->GetJob()->GetJobbean()->m_IsContinue = false;
		CtrlWhenStop();
		m_job_controller->GetJob()->UpdateJobBeanWhenStop();
		BaseCtrl::SetState(BaseCtrl::STANDBY_STOP);
		return true;
	}

	BaseCtrl::SetState(BaseCtrl::STOP);
	for (size_t i = 0; i < m_scan.size(); i++) {
		m_scan[i]->StopWork();
	}
	BaseCtrl::SetPreState(BaseCtrl::NonePre);
	g_Toast->AddToast(new ToastBean(_(u8"正在停止任务").c_str(), 3000, Toast::COLOR_ORANGE));
	g_log->TraceKeyInfo(_(u8"正在停止任务").c_str());
	return true;
}

bool ScannerCtrl::IsTestLayerEnable()
{
	return (m_RedPrintTestThread == INVALID_HANDLE_VALUE);
}

void ScannerCtrl::TestLayer()
{
	if (m_RedPrintTestThread != INVALID_HANDLE_VALUE)
		return;

	if (m_scan.size() == 0)
	{
		ToastBean* bean = new ToastBean(_(u8"没有振镜控制卡").c_str(), 3000);
		g_Toast->AddToast(bean);
		return;
	}

	m_RedPrintTestThread = AtlCreateThread(RedPrintTestProc, this);
}

void ScannerCtrl::CtrlIoWhenExit() {
	
	m_PurifierClient->ResetSlowWind();
}

void ScannerCtrl::CtrlWhenStop()
{
	m_MachineCtrl->StopLaser(true);
	if (BaseCtrl::IsFinish()) {
		m_IOCfgWrapper->SetAutoCtrlHeating(true);
		m_PurifierClient->HandlePrintFinish();

		if (m_RunCfg->m_IsAutoReleasePressureWhenFinish) {
			m_PressureCtrlFlag = true;
			m_PressureThread = AtlCreateThread(ReleasePressureProc, this);
		}
		if (m_RunCfg->m_AutoShutdownPower) {
			m_IOCfgWrapper->m_Laser->SetActive(false);
		}
		
	}
	m_PurifierClient->HandlePrintStop();
	CtrlIoWhenExit();
}

void ScannerCtrl::GetInitErrorInfos(vector<string>& vec)
{
	for (size_t i = 0; i < m_InitErrorInfos.size(); ++i) {
		vec.push_back(m_InitErrorInfos[i]);
	}
}

string ScannerCtrl::GetInitErrorInfos()
{
	string msg;
	for (size_t i = 0; i < m_InitErrorInfos.size(); ++i) {
		msg += (m_InitErrorInfos[i])+"";
	}
	return msg;
}


void ScannerCtrl::DispatchDataBlock()
{
	if (!m_job_controller)return;
	FileProcessor* job = m_job_controller->GetJob();
	if (job == NULL) {
		g_Toast->AddToast(new ToastBean(_(u8"没有可打印的任务").c_str(), 3000));
		return;
	}
	MetaData* job_meta_data = job->GetMetaData();
	if (job_meta_data == NULL)return;

	size_t layerindex = job->GetStartIndex();

	//m_Camera->SetDemandCatpure(true);    //wxxtest
	bool nodebug = !g_isDebug;

	//job->UpdateJobBeanWhenStart();
	JobBean* jobBean = job->GetJobbean();
//	g_log->m_LogDao->LogJobStart(jobBean);
	//g_log->m_LogDao->LogImageBeforePrint(jobBean->m_Id, jobBean->m_IsContinue);
	vector<MetaData::Layer*> &layers = job_meta_data->GetLayersVec();
	//unsigned int memorySize = GetMemorySize();
	g_SystemInfo->m_StateBean.maxLayerIndex = job->GetLayerCount();
	g_SystemInfo->m_StateBean.layerThick = job->GetLayerThickness();

	uint32_t startPos = jobBean->m_StartMoldPos;
	uint32_t firstStartIndex = jobBean->m_FirstStartIndex;
	int fix = 0;
	if (firstStartIndex < layers.size())
	{
		fix = startPos - layers[firstStartIndex]->z;
	}
	for (size_t i = 0; i < layers.size(); i++) {
		layers[i]->realZ = layers[i]->z + fix;
	}

	job_meta_data->CalcRealPower();

	job_meta_data->ReCalcEvaTime();
	g_SystemInfo->m_StateBean.jobCostMil = job_meta_data->GetEvaTime();

	//if (job->m_StartTime == 0L)job->m_StartTime = GetTickCount64();
	bool isbreak = false;

	map<MetaData::DataBlock*, int>* DBRefScanLaser = job_meta_data->GetDBRefScanLaser();
	map<MetaData::DataBlock*, int>::iterator dbsIt;
	map<int, Scanner*> scanMap;
	for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
		Scanner* scanner = m_scan[scanIndex];
		scanner->m_JobStartTime = job->m_FirstStartTime;
		scanMap[scanner->GetConfig()->m_SeqNo] = scanner;
	}

	m_DownSkinStopFlag = 1;
	m_IsDownSkinContinue = false;

	bool isCoverFirst = true;
	//short lastPowderGrid = 0;

	int linearAccDis = 0;
	float lastLinearPos = 0.0f;
	for (; layerindex < layers.size(); layerindex++) {//遍历层	
		bool hasDownSkin = false;
		if (BaseCtrl::IsStop() || BaseCtrl::IsPause()) {
			if (BaseCtrl::IsStop()) {
				job->SetStartIndex(0);
			}
			if (BaseCtrl::IsPause()) {
				job->SetStartIndex(layerindex);
			}
			isbreak = true;
			break;
		}

		if (!job_meta_data->LoadLayerByIndex(layerindex)) continue;
		job_meta_data->CalcRemainTime(layerindex);
		g_SystemInfo->m_StateBean.layerIndex = layerindex;
		g_SystemInfo->m_StateBean.jobProgress = (float)layerindex / (float)g_SystemInfo->m_StateBean.maxLayerIndex;
		MetaData::Layer* layer = layers[layerindex];
		bool hasPrintPart = false;
		for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
			MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
			if (!datablock)continue;
			MetaData::Part* part = job_meta_data->GetPart(datablock->references->part);
			if (part) {
				if (part->print_enable) {
					hasPrintPart = true;
					break;
				}
			}
		}
		if (!hasPrintPart)break;

	//	if (!g_isDebug) {
			int ptickcount = 0;
			while (m_MachineCtrl->IsCovering() && IsStart() && !g_isDebug) {
				ptickcount++;
				Sleep(20);
			}

			//AxisLog* lc = NULL;
			if (m_ServoManager) {
				m_ServoManager->StartLog(jobBean->m_Id, layerindex, m_CoverCfg->m_CoverDirection);
				//lc = new AxisLog(jobBean->m_Id, layerindex, m_CoverCfg->m_CoverDirection);
				//if (m_ServoManager)m_ServoManager->StartLog(lc);
			}

			bool windalaemEnable = m_AlarmCfgWrapper->m_WindOverLimitAlarm->m_IsEnable;
			bool isSlowWindSet = false;
			if (m_ExtCfg->m_AutoCoverSlowWind && m_PurifierClient->IsWindActive())
			{
				if(m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(_(u8"层%d开始铺粉降风速").c_str(), layerindex + 1);
				if (windalaemEnable)m_AlarmCfgWrapper->m_WindOverLimitAlarm->m_IsEnable = false;
				m_PurifierClient->SetCoverWind(true);
				isSlowWindSet = true;
				int windcount = 0;
				while (IsStart() && windcount < 300) {
					if (m_PurifierClient->IsCoverWindSlow()) {
						break;
					}
					windcount++;
					Sleep(100);
				}
				if (m_RunCfg->m_UseCoverWindSignal)
				{
					m_PurifierClient->ResetSlwoWindSignal(true);
				}
			}

			bool isOK = true;
			int retry = m_RecoatCheckCfg->m_RetryTimes;
			float layerThick = layer->layer_thickness;

			g_SystemInfo->LockInfo();
			int32_t premoldPos = g_SystemInfo->m_MoldMainPos;
			g_SystemInfo->UnlockInfo();

			float layerYmin = FLT_MAX;
			float layerYmax = -FLT_MAX;
			for (map<int, MetaData::Part*>::iterator pit = layer->parts.begin(); pit != layer->parts.end(); pit++) {
				MetaData::Part* tempPart = pit->second;
				if (!tempPart->print_enable)continue;
				if (layerYmin > tempPart->layerDimensions->ymin)layerYmin = tempPart->layerDimensions->ymin;
				if (layerYmax < tempPart->layerDimensions->ymax)layerYmax = tempPart->layerDimensions->ymax;
			}

			if (m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(_(u8"层%d开始铺粉").c_str(), layerindex + 1);
			do {
				if (BaseCtrl::IsStop() || BaseCtrl::IsPause()) {
					if (BaseCtrl::IsStop()) {
						job->SetStartIndex(0);
					}
					if (BaseCtrl::IsPause()) {
						job->SetStartIndex(layerindex);
					}
					isbreak = true;
					break;
				}

				m_MachineCtrl->ResetCoverFinishedCanPrint();

				if (m_RunCfg->m_SmartCoverEnable) {
					m_MachineCtrl->ExecuteDataSizeY(ceil(layerYmin) * 1000, ceil(layerYmax) * 1000);
				}

				short powderGrid = ceil((float)layer->powder / m_PowderEstimateCfg->m_PowderPerGrid);
				if (isCoverFirst) {
					m_MachineCtrl->ExecuteCover(layerThick, powderGrid, false, isCoverFirst);
					if (isCoverFirst) {
						isCoverFirst = !isCoverFirst;
					}
				}
				else {
					m_MachineCtrl->ExecuteCover(layerThick, powderGrid, false, false);
				}

				//lastPowderGrid = powderGrid;
				Sleep(500);

				while (!m_MachineCtrl->IsCoverFinishedCanPrint() && !g_isDebug && IsStart()) {
					if (m_MachineCtrl->IsCoverFinishedCanPrint()) {
						break;
					}
					Sleep(10);
				}
				
				/*while (m_MachineCtrl->IsCovering() && !g_isDebug && IsStart()) {
					if (!m_MachineCtrl->IsCovering()) {
						break;
					}
					Sleep(10);
				}*/
				Sleep(100);

				m_MachineCtrl->ResetCoverFinishedCanPrint();
				if (/*m_RecoatCheck == nullptr ||*/ !m_RecoatCheckCfg->m_Enable || (layerindex < 5) || m_CoverCfg->IsNoCover())
					break;
				if (layer->powder == 0)break;
				unsigned char* img = nullptr;
				int width = 0, height = 0;
				//isOK = m_RecoatCheck->CheckWP2(job_meta_data, layerindex);   //wxxtest
				//if (!isOK) {
				//	layerThick = 0.0f;
				//}
				//else
				//	break;
			} while (!isOK && retry--);
			if (m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(_(u8"层%d铺粉完成").c_str(), layerindex + 1);
			if (isSlowWindSet&& m_PurifierClient->IsWindActive())
			{
				m_PurifierClient->SetCoverWind(false);
				int windcount = 0;
				while (IsStart() && windcount < 300) {
					if (m_PurifierClient->IsCoverWindRecover()) {
						break;
					}
					windcount++;
					Sleep(100);
				}
				if (m_RunCfg->m_UseCoverWindSignal)
				{
					m_PurifierClient->ResetSlwoWindSignal(false);
				}
			}
			if (m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(_(u8"层%d风速已经恢复").c_str(), layerindex + 1);
			m_AlarmCfgWrapper->m_WindOverLimitAlarm->m_IsEnable = windalaemEnable;
			//ResetEvent(m_PowderEvent);
			if (m_ServoManager ) {
				m_ServoManager->StopLog();
			}

			if (m_RunCfg->m_CoverLayerDelay != 0)
			{
				uint64_t tb = GetTickCount64();
				while (true)
				{
					Sleep(300);
					uint64_t tt = GetTickCount64();
					unsigned int difs = tt - tb;
					if (difs > (m_RunCfg->m_CoverLayerDelay * 1000))
					{
						break;
					}
					if (BaseCtrl::IsStop() || BaseCtrl::IsPause()) {
						if (BaseCtrl::IsStop()) {
							job->SetStartIndex(0);
						}
						if (BaseCtrl::IsPause()) {
							job->SetStartIndex(layerindex);
						}
						isbreak = true;
						break;
					}
				}
			}

			if (BaseCtrl::IsStop() || BaseCtrl::IsPause()) {
				if (BaseCtrl::IsStop()) {
					job->SetStartIndex(0);
				}
				if (BaseCtrl::IsPause()) {
					job->SetStartIndex(layerindex);
				}
				m_MachineCtrl->MoldMoveUp(layer->layer_thickness, false);
				isbreak = true;
				break;
			}

			
			//if (m_Camera->IsConnect()) {   //wxxtest
			//	if (m_Camera->GenLogImage()) {
			//		LogImage image;
			//		time(&image.m_InsertTime);
			//		image.m_JobId = jobBean->m_Id;
			//		image.m_LayerIndex = layerindex;
			//		image.m_Type = LogImage::COVERED;
			//		image.m_Image = m_Camera->GetLogImage();
			//		image.m_ImageLength = m_Camera->GetLogImageSize();
			//		g_log->m_LogDao->AddImage(image);
			//	}
			//}
	//	}

		linearAccDis -= (layer->powder == 0 ? 0 : layer->layer_thickness);
		float linearTheoryPos=lastLinearPos- (layer->powder==0?0:layer->layer_thickness);
		float layerJudgeValue = m_RunCfg->m_LayerLinearPosAlarmOffset;
		g_SystemInfo->LockInfo();
		float nowDis = g_SystemInfo->m_EnvState.m_LinearActDistance;
		int32_t nowPDis = g_SystemInfo->m_EnvState.m_LinearActPulse*g_SystemInfo->m_EnvState.m_LineEncPulseEqu;
		int32_t moldPos = g_SystemInfo->m_MoldMainPos;
		g_SystemInfo->UnlockInfo();
		
		if (abs(nowDis - linearTheoryPos) > layerJudgeValue) {
			char buffer[256];
			sprintf_s(buffer, sizeof(buffer), _(u8"%zu层光栅位置为%.3f mm，理论值应为%.3f mm").c_str(), layerindex + 1, nowDis / 1000.0f, linearTheoryPos / 1000.0f);
			m_AlarmCfgWrapper->m_LayerLinearPosAlarm->m_AlarmInfo = string(buffer);
			SignalService::GetInstance().SetAlarm(m_AlarmCfgWrapper->m_LayerLinearPosAlarm, true);
		}

		if (abs(layer->realZ - moldPos) > m_RunCfg->m_MoldServoPosWarnOffset) {
			char buffer[256];
			sprintf_s(buffer, sizeof(buffer), _(u8"%zu层的理论伺服位置为%.3f mm，当前值为%.3f mm").c_str(), layerindex + 1, (float)layer->realZ / 1000.0f, (float)moldPos / 1000.0f);
			m_AlarmCfgWrapper->m_MoldServoPosWarn->m_AlarmInfo = string(buffer);
			SignalService::GetInstance().SetAlarm(m_AlarmCfgWrapper->m_MoldServoPosWarn, true);
		}
		else {
			SignalService::GetInstance().SetAlarm(m_AlarmCfgWrapper->m_MoldServoPosWarn, false);
		}

		if (abs(linearAccDis - nowPDis) > m_RunCfg->m_PrintLinearAccDevAlarmOffset) {
			char buffer[256];
			sprintf_s(buffer, sizeof(buffer), _(u8"%zu层的理论光栅位置为%.3f mm，当前值为%.3f mm").c_str(), layerindex + 1, (float)linearAccDis / 1000.0f, (float)nowPDis / 1000.0f);
			m_AlarmCfgWrapper->m_PrintLinnearAccDevAlarm->m_AlarmInfo = string(buffer);
			SignalService::GetInstance().SetAlarm(m_AlarmCfgWrapper->m_PrintLinnearAccDevAlarm, true);
		}
		else {
			SignalService::GetInstance().SetAlarm(m_AlarmCfgWrapper->m_PrintLinnearAccDevAlarm, false);
		}
		lastLinearPos = nowDis;
		//	unsigned int scan_field_num = job_meta_data->GetNumOfScanField();

		if (m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(_(u8"层%d准备扫描").c_str(), layerindex + 1);
		map<int, Scanner*> useScanner;
		for (int times = 0; times < layer->scan_times && !BaseCtrl::IsStop(); times++) {
			for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
				MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
				if (!datablock)continue;
				MetaData::Part* part = job_meta_data->GetPart(datablock->references->part);
				if (part) {
					if (!part->print_enable) {
						continue;
					}
				}
				BPBinary::BinDataBlock* pdb = job_meta_data->GetDataBlock(datablock);
				MetaData::ParameterSet* paramSet = job_meta_data->GetParameterSet(datablock->references->process);
				dbsIt = DBRefScanLaser->find(datablock);
				//LaserCfg* laserCfg = (*fieldRefScanLaser)[paramSet->scan_field];
				if (dbsIt == DBRefScanLaser->end()) continue;
				if (paramSet->set_type.find("Down") != string::npos && m_RunCfg->m_DownSkinStopTimes > 0) {
					hasDownSkin = true;
					if ((m_DownSkinStopFlag % (m_RunCfg->m_DownSkinStopTimes + 1)) == 0) {
						continue;
					}
				}
				float laserPower = paramSet->laser_set->laser_real_power;
				if (laserPower == 0.0f) {
					continue;
				}

				if (!pdb)
				{
					continue;
				}

				int sno = (*DBRefScanLaser)[datablock];
				Scanner* scanner = scanMap[sno];
				if (!scanner)continue;
				scanner->AddDataBlock(pdb, part, paramSet, datablock->order,datablock->scanTime);
				useScanner[sno] = scanner;
			}

			Scanner::ResetScaningLimit();

			for (auto sc : useScanner) {
				sc.second->BeginWork();
			}

			for (auto sc : useScanner) {
				sc.second->WaitFinish();
			}

			Scanner::ResetScaningLimit();
			//OutputDebugString("end\n");
		}
		if (m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(_(u8"层%d扫描完成").c_str(), layerindex + 1);
		jobBean->m_PrintedLayerIndex = layerindex;
		g_SystemInfo->LockInfo();
		jobBean->m_MoldPos = g_SystemInfo->m_MoldMainPos/1000.0f;
		g_SystemInfo->UnlockInfo();
		time(&jobBean->m_StopTime);
		g_log->m_LogDao->UpdateJobAfterPrintLayer(jobBean);
		/*if (m_Camera->IsConnect()) {     //wxxtest
			if (m_Camera->GenLogImage()) {
				LogImage image;
				time(&image.m_InsertTime);
				image.m_JobId = jobBean->m_Id;
				image.m_LayerIndex = layerindex;
				image.m_Type = LogImage::PRINTED;
				image.m_Image = m_Camera->GetLogImage();
				image.m_ImageLength = m_Camera->GetLogImageSize();
				g_log->m_LogDao->AddImage(image);
			}
		}*/
		if (m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(_(u8"层%d扫描图像记录完成").c_str(), layerindex + 1);
		m_IsDownSkinContinue = hasDownSkin;
		if (m_IsDownSkinContinue)m_DownSkinStopFlag++;
		else m_DownSkinStopFlag = 1;

		if (m_MachineCfg->m_IsIntelli) {

			vector<ScannerStatus*> scannerStatus;
			vector<FocusStatus*> focusStatus;
			for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
				m_scan[scanIndex]->UpdateScannerInfo();
				ScannerStatus* sstatus = new ScannerStatus();
				ScanStateXY sxy;
				m_scan[scanIndex]->GetXYScanState(&sxy, sstatus->m_InsertTime);
				sstatus->m_ScanTempX = sxy.m_X.m_GalvanometerScannerTemp;
				sstatus->m_ScanServoTempX = sxy.m_X.m_ServoBoardTemp;
				sstatus->m_ScanTempY = sxy.m_Y.m_GalvanometerScannerTemp;
				sstatus->m_ScanServoTempY = sxy.m_Y.m_ServoBoardTemp;
				sstatus->m_ScanId = m_scan[scanIndex]->GetConfig()->m_SeqNo;
				sstatus->m_JobId = jobBean->m_Id;
				sstatus->m_LayerIndex = layerindex;
				sstatus->m_ActualPositionX = sxy.m_X.m_ActualPosition;
				sstatus->m_SetPositionX = sxy.m_X.m_SetPosition;
				sstatus->m_PositionErrorX = sxy.m_X.m_PositionError;
				sstatus->m_ActualPositionY = sxy.m_Y.m_ActualPosition;
				sstatus->m_SetPositionY = sxy.m_Y.m_SetPosition;
				sstatus->m_PositionErrorY = sxy.m_Y.m_PositionError;
				sstatus->m_LowStateX = sxy.m_X.m_LowState;
				sstatus->m_LowStateY = sxy.m_Y.m_LowState;
				sstatus->m_HighStateX = sxy.m_X.m_HighState;
				sstatus->m_HighStateY = sxy.m_Y.m_HighState;
				scannerStatus.push_back(sstatus);

				if (m_scan[scanIndex]->GetConfig()->m_ScanCfgWrapper.m_CorrectParamCfg.m_IsDynamicFocus) {
					FocusStatus* fs = new FocusStatus();
					fs->m_ScanId = m_scan[scanIndex]->GetConfig()->m_SeqNo;
					fs->m_JobId = jobBean->m_Id;
					fs->m_LayerIndex = layerindex;
					time(&fs->m_InsertTime);
					fs->m_ScanServoTemp = sxy.m_Focus.m_ServoBoardTemp;
					fs->m_PDSupplyVoltage = sxy.m_Focus.m_PDSupplyVoltage;
					fs->m_DSPCoreSupplyVoltage = sxy.m_Focus.m_DSPCoreSupplyVoltage;
					fs->m_DSPIOVoltage = sxy.m_Focus.m_DSPIOVoltage;
					fs->m_AnalogSectionVoltage = sxy.m_Focus.m_AnalogSectionVoltage;
					fs->m_ADConverterSupplyVoltage = sxy.m_Focus.m_ADConverterSupplyVoltage;
					fs->m_PDSupplyCurrent = sxy.m_Focus.m_PDSupplyCurrent;
					fs->m_LowState = sxy.m_Focus.m_LowState;
					fs->m_HighState = sxy.m_Focus.m_HighState;
					fs->m_StopEven = sxy.m_Focus.m_StopEven;
					focusStatus.push_back(fs);
				}
			}
			g_log->m_LogDao->LogScannerStatus(scannerStatus);
			for (size_t ssindex = 0; ssindex < scannerStatus.size(); ssindex++) {
				delete scannerStatus[ssindex];
			}
			scannerStatus.clear();
			if (!focusStatus.empty()) {
				g_log->m_LogDao->LogFocusStatus(focusStatus);
				for (size_t ssindex = 0; ssindex < focusStatus.size(); ssindex++) {
					delete focusStatus[ssindex];
				}
				focusStatus.clear();
			}
		}

		if (m_RunCfg->m_PrintLayerDelay != 0)
		{
			uint64_t tb = GetTickCount64();
			while (true)
			{
				Sleep(300);
				uint64_t tt = GetTickCount64();
				unsigned int difs = tt - tb;
				if (difs > (m_RunCfg->m_PrintLayerDelay * 1000))
				{
					break;
				}
				if (BaseCtrl::IsStop() || BaseCtrl::IsPause()) {
					if (BaseCtrl::IsStop()) {
						job->SetStartIndex(0);
					}
					if (BaseCtrl::IsPause()) {
						job->SetStartIndex(layerindex + 1);
					}
					break;
				}
			}

		}
	}
	if (!isbreak) {
		job->SetFinished(true);
		time(&jobBean->m_StopTime);
		jobBean->m_IsFinished = true;
		jobBean->m_PrintedLayerIndex = layerindex-1;
		g_log->m_LogDao->UpdateJobAfterPrintLayer(jobBean);
		BaseCtrl::SetFinish();
		g_SystemInfo->m_StateBean.jobProgress = 1.0f;
		job->GetMetaData()->SetRemainTime(0);
		g_SystemInfo->m_StateBean.remainMil = 0;
		//jobBean->m_StopTime = 0;
		jobBean->m_IsFinished = false;
	}
	else {
		if (BaseCtrl::IsPause())
		{
			time(&jobBean->m_LastPauseTime);
			g_log->m_LogDao->UpdateJobPauseTime(jobBean);
		}
	}
	//m_Camera->SetDemandCatpure(false);    //wxxtest
	if (m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(_(u8"退出打印流程").c_str(), layerindex + 1);
}



void ScannerCtrl::DispatchTestDataBlock()
{
	for (size_t i = 0; i < m_RedTestDBS.size(); i++) {
		delete m_RedTestDBS[i];
		m_RedTestDBS[i] = NULL;
	}
	m_RedTestDBS.clear();
	if (!m_job_controller)return;
	FileProcessor* job = m_job_controller->GetJob();
	if (job == NULL) {
		g_Toast->AddToast(new ToastBean(_(u8"没有可打印的任务").c_str(), 3000));
		return;
	}
	//SetDefocus(0);
	MetaData* job_meta_data = job->GetMetaData();
	if (job_meta_data == NULL)return;
	job_meta_data->CalcRealPower();
	bool nodebug = !g_isDebug;

	vector<MetaData::Layer*> layers = job_meta_data->GetLayersVec();
	unsigned int layerindex = job->GetPreviewLayerIndex();
	//unsigned int memorySize = GetMemorySize();
	if (layerindex >= layers.size())return;
	if (!job_meta_data->LoadLayerByIndex(layerindex)) return;
	MetaData::Layer* layer = job_meta_data->GetLayer(layerindex);

	//MetaData::Layer* layer = job_meta_data->GetPreviewLayer();
	map<int, Scanner*> useScanner;
	map<MetaData::DataBlock*, int>* DBRefScanLaser = job_meta_data->GetDBRefScanLaser();
	map<MetaData::DataBlock*, int>::iterator dbsIt;
	map<int, Scanner*> scanMap;

	for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
		Scanner* scanner = m_scan[scanIndex];
		scanMap[scanner->GetConfig()->m_SeqNo] = scanner;
		m_scan[scanIndex]->Clean();
	}
	for (size_t i = 0; i < m_scan.size(); i++)
	{
		m_scan[i]->SetAutoUpdateScanInfo(false);
		m_scan[i]->m_IsOrderSeqV2 = m_job_controller->GetJob()->GetMetaData()->m_IsScanOrderSeqV2;
	}
	for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
			
		if (BaseCtrl::IsStop()) {
			break;
		}
		MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
		if (!datablock)continue;
		MetaData::Part* part = job_meta_data->GetPart(datablock->references->part);
		if (part) {
			if (!part->print_enable) continue;
		}
		BPBinary::BinDataBlock* pdb = job_meta_data->GetDataBlock(datablock);
		if (!pdb)continue;
		MetaData::ParameterSet* paramSet = job_meta_data->GetParameterSet(datablock->references->process);
		if (!paramSet)continue;
		if (paramSet->laser_set->laser_power == 0.0f)
		{
			continue;
		}
		dbsIt = DBRefScanLaser->find(datablock);
		//LaserCfg* laserCfg = (*fieldRefScanLaser)[paramSet->scan_field];
		if (dbsIt == DBRefScanLaser->end()) continue;
		int sno = (*DBRefScanLaser)[datablock];
		Scanner* scanner = scanMap[sno];
		if (!scanner)continue;
		BPBinary::BinDataBlock* pbindb = new BPBinary::BinDataBlock;
		pdb->Copy(pbindb);
		m_RedTestDBS.push_back(pbindb);
		scanner->AddDataBlock(pbindb, part, paramSet,datablock->order, datablock->scanTime);
		useScanner[sno] = scanner;
	}
	Scanner::ResetScaningLimit();
	for (auto scanner : useScanner)
		scanner.second->BeginWork();

	for (auto scanner : useScanner)
		scanner.second->WaitFinish();

	Scanner::ResetScaningLimit();

	for (size_t i = 0; i < m_RedTestDBS.size(); i++) {
		delete m_RedTestDBS[i];
	}
	m_RedTestDBS.clear();
	for (size_t i = 0; i < m_scan.size(); i++)
	{
		m_scan[i]->SetAutoUpdateScanInfo(true);
	}
}


void ScannerCtrl::ModelScan(void)
{
	if (m_RedPrintTestThread != INVALID_HANDLE_VALUE)
		return;
	m_RedPrintTestThread = AtlCreateThread(ModelScanProc, this);
}

void ScannerCtrl::StopModelScan(void)
{
	PrintState printStateTemp = BaseCtrl::GetState();
	BaseCtrl::SetState(BaseCtrl::STOP);
	EnterCriticalSection(&m_LayerTestCs);
	if (m_RedPrintTestThread != INVALID_HANDLE_VALUE) {
		for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
			Scanner* scanner = m_scan[scanIndex];
			scanner->StopWork();
		}
		if (WaitForSingleObject(m_RedPrintTestThread, 1000) == WAIT_TIMEOUT) {
			TerminateThread(m_RedPrintTestThread, 0);
		}
		CloseHandle(m_RedPrintTestThread);
		m_RedPrintTestThread = INVALID_HANDLE_VALUE;
	}
	LeaveCriticalSection(&m_LayerTestCs);
	BaseCtrl::SetState(printStateTemp);
	for (size_t i = 0; i < m_scan.size(); i++) {
		m_scan[i]->Clean();
	}
}


DWORD WINAPI ScannerCtrl::ModelScanProc(thisClass* _this)
{
	if (_this)
	{
		ExtCfg* stc = ConfigManager::GetInstance()->GetExtCfg();
		if (stc->m_model_scan_mode == 0) {}
			//_this->m_gc->StartLaser(true);
		else {
			//_this->m_gc->StopLaser(true);
			if (!_this->m_IOCfgWrapper->m_Laser->IsActive()) {
				_this->m_IOCfgWrapper->m_Laser->SetActive(true);
				Sleep(_this->m_ExtCfg->m_AftLaserPowerWaitSecond*1000);
			}
			vector<ScannerControlCfg*>* laserCfgs = ConfigManager::GetInstance()->GetMatchScannerControlCfg();
			for (size_t lrIndex = 0; lrIndex < laserCfgs->size(); lrIndex++) {
				ScannerControlCfg* laserCfg = (*laserCfgs)[lrIndex];
				if (laserCfg->m_LaserRed && !laserCfg->m_LaserRed->IsActive()) {
					laserCfg->m_LaserRed->SetActive(true);
				}
			}
		}
		g_Toast->AddToast(new ToastBean(_(u8"开始扫描").c_str(), 2000, ImVec4(0, 1, 0, 1)));
	
		_this->DispatchModelDataBlock(stc->m_model_scan_part_id, stc->m_model_scan_type, stc->m_model_laser_power, stc->m_model_laser_speed);
		EnterCriticalSection(&_this->m_LayerTestCs);
		if (_this->m_RedPrintTestThread != INVALID_HANDLE_VALUE) {
			CloseHandle(_this->m_RedPrintTestThread);
			_this->m_RedPrintTestThread = INVALID_HANDLE_VALUE;
		}
		LeaveCriticalSection(&_this->m_LayerTestCs);
	}
	return 0;
}

void ScannerCtrl::DispatchModelDataBlock(int partId, string scanType, float power, float speed)
{
	for (size_t i = 0; i < m_ModeTestDBS.size(); i++) {
		delete m_ModeTestDBS[i];
	}
	m_ModeTestDBS.clear();

	if (!m_job_controller)return;
	FileProcessor* job = m_job_controller->GetJob();
	if (job == NULL) {
		g_Toast->AddToast(new ToastBean(_(u8"没有可打印的任务").c_str(), 3000));
		return;
	}

	MetaData* job_meta_data = job->GetMetaData();
	if (job_meta_data == NULL)return;
	job_meta_data->CalcRealPower();
	bool nodebug = !g_isDebug;

	vector<MetaData::Part*> parts = job_meta_data->GetPartVec();
	if (partId > parts.size())
		return;

	if (scanType != "Border" && scanType != "Hatching")
		return;

	vector<MetaData::Layer*> layers = job_meta_data->GetLayersVec();
	size_t layerindex = job->GetStartIndex();
	if (layerindex >= layers.size())return;

	map<int, Scanner*> useScanner;
	map<MetaData::DataBlock*, int>* DBRefScanLaser = job_meta_data->GetDBRefScanLaser();
	map<MetaData::DataBlock*, int>::iterator dbsIt;
	map<int, Scanner*> scanMap;
	for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
		Scanner* scanner = m_scan[scanIndex];
		scanMap[scanner->GetConfig()->m_SeqNo] = scanner;
	}

	if (!job_meta_data->LoadLayerByIndex(layerindex)) return;
	MetaData::Layer* layer = job_meta_data->GetLayer(layerindex);

	vector<MetaData::ParameterSet*> params;

	for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
		if (BaseCtrl::IsStop()) {
			break;
		}

		MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
		if (!datablock)continue;
		if (datablock->references->part != partId)
			continue;


		MetaData::Part* part = job_meta_data->GetPart(datablock->references->part);
		if (part) {
			if (!part->print_enable) continue;
		}

		MetaData::ParameterSet* ps = job_meta_data->GetParameterSet(datablock->references->process);
		if (ps->laser_set->laser_power == 0.0f)
		{
			continue;
		}
		if (scanType == "Border") {
			switch (m_ExtCfg->m_model_border_type) {
			case ExtCfg::All_Border: {
				if (ps->set_type.find("Border") == ps->set_type.npos) {
					continue;
				}
			}break;
			case ExtCfg::Border: {
				if (ps->set_type != "Border" && ps->set_type != "InBorder"  &&  ps->set_type != "InBorderJ")continue;
			}break;
			case ExtCfg::BorderDown: {
				if (ps->set_type != "BorderDown" && ps->set_type != "DownBorder" && ps->set_type != "DownBorderJ")continue;
			}break;
			case ExtCfg::BorderAdditionalDown: {
				if (ps->set_type != "BorderAdditionalDown" && ps->set_type != "DownBorderAd" && ps->set_type != "DownBorderAdJ")continue;
			}break;
			case ExtCfg::BorderBlockedDown: {
				if (ps->set_type != "BorderBlockedDown")continue;
			}break;
			case ExtCfg::BorderAdditional: {
				if (ps->set_type != "BorderAdditional" && ps->set_type != "InBorderAd" && ps->set_type != "InBorderAdJ")continue;
			}break;
			case ExtCfg::BorderBlocked: {
				if (ps->set_type != "BorderBlocked")continue;
			}break;
			case ExtCfg::BorderUp: {
				if (ps->set_type != "BorderUp" && ps->set_type != "UpBorder")continue;
			}break;
			case ExtCfg::BorderAdditionalUp: {
				if (ps->set_type != "BorderAdditionalUp" && ps->set_type != "UpBorderAd")continue;
			}break;
			case ExtCfg::BorderBlockedUp: {
				if (ps->set_type != "BorderBlockedUp")continue;
			}break;
			case ExtCfg::BorderSupport: {
				if (ps->set_type != "BorderSupport" && ps->set_type != "SupportBorder")continue;
			}break;
			case ExtCfg::BorderAdditionalSupport: {
				if (ps->set_type != "BorderAdditionalSupport")continue;
			}break;
			}

		}
		else {
			if (ps->set_type != "Hatching" && ps->set_type != "InHatching")
				continue;
		}

		BPBinary::BinDataBlock* pdb = job_meta_data->GetDataBlock(datablock);
		if (!pdb)continue;
		dbsIt = DBRefScanLaser->find(datablock);
		if (dbsIt == DBRefScanLaser->end()) continue;
		int sno = (*DBRefScanLaser)[datablock];
		Scanner* scanner = scanMap[sno];
		if (!scanner)continue;
		BPBinary::BinDataBlock* pbindb = new BPBinary::BinDataBlock;
		pdb->Copy(pbindb);
		m_ModeTestDBS.push_back(pbindb);

		MetaData::ParameterSet* newParam = new MetaData::ParameterSet();
		newParam->laser_speed = speed;
		newParam->laser_set->laser_diameter = ps->laser_set->laser_diameter;
		newParam->laser_set->laser_power = power;
		newParam->laser_set->laser_real_power = scanner->GetConfig()->m_ScanCfgWrapper.m_PowerCompensateCfg.CalcPowerCompensate(power);
		params.push_back(newParam);
		scanner->AddDataBlock(pbindb, part, newParam,datablock->order, datablock->scanTime);
		useScanner[sno] = scanner;
	}
	Scanner::ResetScaningLimit();
	for (auto scanner : useScanner)
		scanner.second->BeginWork();

	for (auto scanner : useScanner)
		scanner.second->WaitFinish();

	Scanner::ResetScaningLimit();
	for (size_t i = 0; i < params.size(); i++) {
		delete params[i];
	}
	params.clear();
	for (size_t i = 0; i < m_ModeTestDBS.size(); i++) {
		delete m_ModeTestDBS[i];
	}
	m_ModeTestDBS.clear();
}

DWORD WINAPI ScannerCtrl::ReleasePressureProc(thisClass* _this)
{
	if (_this) {
		_this->m_IOCfgWrapper->SetSystemCtrlPressure(false);
		Sleep(100);
		uint64_t tflag = GetTickCount64();
		_this->m_IOCfgWrapper->m_PressureRelease->SetActive(true);
		while (true && _this->m_PressureCtrlFlag) {

			uint64_t tnow = GetTickCount64();
			if ((tnow-tflag) > (_this->m_RunCfg->m_ReleasePressureSeconds*1000)) {
				break;
			}

			if (g_SystemInfo->m_EnvState.m_PrintPressureAnalog <= _this->m_RunCfg->m_ReleasePressureTargeValue) {
				break;
			}
			Sleep(500);
		}
		_this->m_IOCfgWrapper->m_PressureRelease->SetActive(false);
		CloseHandle(_this->m_PressureThread);
		_this->m_PressureThread = INVALID_HANDLE_VALUE;
		_this->m_IOCfgWrapper->SetSystemCtrlPressure(true);
	}
	return 0;
}

bool ScannerCtrl::IsHeatingScannerEnable()
{
	bool rel = false;
	for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
		Scanner* scanner = m_scan[scanIndex];

		if (scanner->GetConfig()->m_ScanCfgWrapper.m_ScanTestCfg.m_IsAutoHeatingScanner)
		{
			rel = true;
			break;
		}
	}

	return rel;
}


void ScannerCtrl::StartHeatingMotion()
{
	if (!m_IOCfgWrapper->m_Heating) return;
	if (!m_RunCfg->m_UseHeatingMotion)return;
	if (BaseCtrl::IsStart())return;
	if (BaseCtrl::IsPause())return;
	if (BaseCtrl::IsStop())return;
	if (m_HeatingMotionThread != INVALID_HANDLE_VALUE)return;
	m_HeatingMotionFlag = true;
	m_HeatingMotionThread = AtlCreateThread(HeatingMotionProc, this);
}

void ScannerCtrl::StopHeatingMotion(bool iswait)
{
	m_HeatingMotionFlag = false;
	if (iswait) {
		while (true) {
			if (m_HeatingMotionThread == INVALID_HANDLE_VALUE) {
				break;
			}
			Sleep(200);
		}
	}
}

DWORD WINAPI ScannerCtrl::HeatingMotionProc(ScannerCtrl* _this)
{
	if (_this) {
		_this->HeatingMotionRun();
		CloseHandle(_this->m_HeatingMotionThread);
		_this->m_HeatingMotionThread = INVALID_HANDLE_VALUE;
	}
	return 0;
}

void ScannerCtrl::HeatingMotionRun()
{
	uint64_t tflag = GetTickCount64();
	Sleep(500);
	while (m_HeatingMotionFlag) {
		int count = 0;
		while (m_HeatingMotionFlag && count < 10 && m_RunCfg->m_UseHeatingMotion) {
			Sleep(100);
			count++;
		}
		if (!m_HeatingMotionFlag || !m_RunCfg->m_UseHeatingMotion || !m_IOCfgWrapper->m_Heating->IsActive()) {
			m_HeatingMotionFlag = false;
			break;
		}
		if (BaseCtrl::IsStart()) {
			m_HeatingMotionFlag = false;
			break;
		}
		if (m_MachineCtrl->IsCovering())continue;
		uint64_t tnow = GetTickCount64();
		if (tnow - tflag > (m_RunCfg->m_HeatingMotionPeriodSecond * 1000))
		{
			m_MachineCtrl->MoldMoveDown(m_RunCfg->m_HeatingMotionDistance,true);
			Sleep(500);
			m_MachineCtrl->MoldMoveUp(m_RunCfg->m_HeatingMotionDistance,true);
			Sleep(500);
			tflag = tnow;
		}
	}
}

void ScannerCtrl::RemoveScanner(int seq)
{
	for (vector<Scanner*>::iterator it = m_scan.begin(); it != m_scan.end();) {
		Scanner* s = (*it);
		if (s->GetConfig()->m_SeqNo == seq)
		{
			delete s;
			it = m_scan.erase(it);
			break;
		}
		else {
			it++;
		}
	}
}

//void ScannerCtrl::DrawFinishReport()
//{
//	if (!m_ShowFinishReport)return;
//
//	if (m_RemoteClient->IsNeedSendFinish())
//	{
//		time_t tnow;
//		time(&tnow);
//		if (tnow - m_LastSendFinishReportTime > 5) {
//			m_RemoteClient->SendStateChangeMsg();
//			m_LastSendFinishReportTime = tnow;
//		}
//	}
//
//	ImGui::OpenPopup(_(u8"打印报告").c_str());
//	if (ImGui::BeginPopupModal(_(u8"打印报告").c_str(), NULL, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize)) {
//		ImGui::Text(_(u8"任务 %s 已打印完成").c_str(), m_job_controller->GetJob()->GetJobTitle().c_str());
//		ImGui::Text(_(u8"任务开始时间：%s").c_str(), TimeHelper::Time2Str(m_job_controller->GetJob()->GetJobbean()->m_StartTime).c_str());
//		ImGui::Text(_(u8"任务结束时间：%s").c_str(), TimeHelper::Time2Str(m_job_controller->GetJob()->GetJobbean()->m_StopTime).c_str());
//		int ss = m_job_controller->GetJob()->GetJobbean()->m_StopTime - m_job_controller->GetJob()->GetJobbean()->m_StartTime;
//		int h = ss / 60 / 60;
//		int m = (ss / 60) % 60;
//		ImGui::Text(_(u8"耗时：%d小时%d分钟").c_str(), h, m);
//
//		m_PurifierClient->DrawFinishReportRel();
//		int ft = m_PurifierClient->GetFilterUseTime();
//		if (ft > m_RunCfg->m_PurifierFilterNotifyHour) {
//			ImGui::TextColored(Toast::COLOR_ORANGE, _(u8"注意：滤芯已使用%d小时").c_str(), ft);
//		}
//		ImGui::Separator();
//		if (ImGui::Button(_(u8"确定").c_str(), ImVec2(120, 0))) {
//			BaseCtrl::SetStandBy();
//			m_RemoteClient->SetNeedSendAlarm(false);
//			m_ShowFinishReport = false;
//			m_job_controller->GetJob()->GetJobbean()->m_StopTime = 0;
//			m_job_controller->GetJob()->GetJobbean()->m_IsFinished = false;
//			ImGui::CloseCurrentPopup();
//		}
//		ImGui::EndPopup();
//	}
//}


void ScannerCtrl::CallFunc(const ReadData& rd) {

	FUNCNAME func = (FUNCNAME)stoi(rd.nameKey);
	switch (func) {
		case BEGINWORK:
			BeginWork();
			break;
		case PAUSEWORK:
			PauseWork();
			break;	
		case PAUSEAUTO:
			PauseAuto();
			break;	
		case STOPWORK:
			StopWork();
			break;
		case STOPREDTEST:
			StopRedTest();
			break;
		case TESTLAYER:
			TestLayer();
			break;
		case REMOVESCANNER:
			RemoveScanner(stoi(rd.strValue));
			break;
		case STARTHEATINGMOTION:
			StartHeatingMotion();
			break;
		case STOPHEATINGMOTION:
			StopHeatingMotion((bool)stoi(rd.strValue));
			break;
		default:
			printf("参数不对...\n");
			break;
	
	}

}