GrpcPrint/PrintS/ScannerCtrl/ScannerCtrl.cpp

#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"
#include "../DataManage/ClientInfo.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)
	, m_ShowFinishReport(false)
	, m_StopThread(INVALID_HANDLE_VALUE)
	, m_StopFlag(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();

	
	//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();
	m_InfraredTempCfg = ConfigManager::GetInstance()->GetInfraredTempCfg();
	map<int, ScannerControlCfg*>* scannerControlCfgsMap = ConfigManager::GetInstance()->GetScannerControlCfg();
	bool rel = false;
	unsigned int card_num = 0;

	if (!RTC5Scanner::PreInit(card_num))
	{
		return false;
	}
	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->GetValue();
				cfg->m_SerialNo = s->second;
				cfg->m_HadMatch = false;
				cfg->m_IsEnable = true;
				cfg->Init();
				//m_Machine->InitScanParamBeforeFind(&cfg->m_ScanCfgWrapper);
				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(g_LngManager->Log_NoScannerCtrl->ShowText());
		m_InitErrorInfos.push_back(g_LngManager->Log_NoScannerCtrl->ShowText());

		//for (int i = 0; i < 4; ++i) {     //wxxtest
		//	Scanner* scanner = new RTC5Scanner(nullptr, i);
		//	m_scan.push_back(scanner);
		//}
		return false;
	}

	int index = 0;
	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 = NULL;


		scanner = new RTC5Scanner(cfg,index++);


		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(g_LngManager->Log_NewScannerAsCfgError->ShowText());
		m_InitErrorInfos.push_back(g_LngManager->Log_NewScannerAsCfgError->ShowText());
		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]);
		}
		else if (m_scan.size() == 8) {
			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]);
			m_scan[4]->SetPairScan(m_scan[5]);
			m_scan[5]->SetPairScan(m_scan[4]);
			m_scan[6]->SetPairScan(m_scan[7]);
			m_scan[7]->SetPairScan(m_scan[6]);
		}
	}

	//#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(g_LngManager->Toast_ServoPowering->ShowText(), 3000, ImVec4(1, 0.4f, 0, 1)));
		Sleep(3000);
	}*/

	SignalService& alarmService = SignalService::GetInstance();

	if (!m_Machine->CheckPrintMoldReady() && !g_isDebug) {
		g_Toast->AddToast(new ToastBean(u8"执行失败：缸体未在打印位装载", 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);
		}
	}

	if (!m_RunCfg->m_IsDebugMode->GetValue()) {
		if (!ReadyPrint(startAfterPause)) {
			BaseCtrl::SetState(BaseCtrl::STANDBY);
			return;
		}
		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"正在等待基板预热", 3000, Toast::COLOR_ORANGE));
					}
				}
				count++;
				if (count > 100000)count = 0;
				Sleep(500);
			}
		}
		if (!BaseCtrl::IsPrePrint()) {
			BaseCtrl::SetState(BaseCtrl::STANDBY);
			return;
		}
		if (alarmService.CheckAlarmAfterDeoxygen())
		{
			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;
		}
	}

	if (!m_job_controller->GetJob()->m_IsAutoCtrl && m_job_controller->GetJob()->m_AutoHeatingScanner) {
		BaseCtrl::SetPreState(BaseCtrl::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();
		}

		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);
			}
		}
	}

	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;
	}
	m_InfraredTemp->m_LogFlag = true;
	Sleep(500);
	DispatchDataBlock();

	Sleep(100);
	m_InfraredTemp->m_LogFlag = false;
	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();
	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->GetValue()) {
			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();
	g_log->m_LogDao->DeleteImageAfterPrint();
}


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()
{
	if (m_StopFlag)
	{
		ToastBean* bean = new ToastBean(_(u8"系统正在停止中，请稍后再开始").c_str(), 3000);
		g_Toast->AddToast(bean);
		return false;
	}
	StopRedTest();
	for (size_t i = 0; i < m_scan.size(); i++) {
		m_scan[i]->StopDebugTest();
	}
	if (m_scan.size() == 0)
	{
		ToastBean* bean = new ToastBean(g_LngManager->Log_NoScannerCtrl->ShowText(), 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(g_LngManager->Toast_NoTaskPrint->ShowText(), 3000);
		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), g_LngManager->Toast_CheckDataOutRangeX->ShowText(), part->name.c_str());
				hasOutLimit = true;
				break;
			}
			if (corymin<correctCfg->m_ymeasure_min || corymxn>correctCfg->m_ymeasure_max) {
				sprintf_s(buffer, sizeof(buffer), g_LngManager->Toast_CheckDataOutRangeY->ShowText(), 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->GetValue() && !m_RunCfg->m_IsDebugMode->GetValue()) {
		ToastBean* bean = new ToastBean(u8"请先执行基板缸平面位置确定", 5000, Toast::COLOR_RED);
		g_Toast->AddToast(bean);
		return false;
	}

	float fh = m_job_controller->GetJob()->GetJobPrintHigh();
	float ah = m_MachineCtrl->GetAllowPrintHigh();
	if (!g_isDebug && (fh > ah))
	{
		char buffer[512];
		sprintf_s(buffer, sizeof(buffer), u8"需要打印的高度：%.3f 超过了 允许的打印高度：%.3f", fh, ah);
		ToastBean* bean = new ToastBean(string(buffer), 5000, Toast::COLOR_RED);
		g_Toast->AddToast(bean);
		return false;
	}

	if (!BaseCtrl::IsStandBy()) {
		ToastBean* bean = new ToastBean(g_LngManager->Toast_CheckStanby->ShowText(), 3000);
		g_Toast->AddToast(bean);
		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(g_LngManager->Toast_NoPauseTask->ShowText(), 3000);
		g_Toast->AddToast(bean);
		m_PauseMsg = g_LngManager->Toast_NoPauseTask->ShowText();
		return false;
	}
	m_job_controller->GetJob()->m_IsAutoCtrl = false;
	g_SystemInfo->m_AutoPrintCtrlState = NoAuto;
	if (BaseCtrl::IsStandBy()) {
		m_PauseMsg = g_LngManager->Toast_StanbyPauseError->ShowText();
		return false;
	}
	BaseCtrl::SetState(BaseCtrl::PAUSE);
	BaseCtrl::SetPreState(BaseCtrl::NonePre);
	g_Toast->AddToast(new ToastBean(g_LngManager->Toast_PausingTask->ShowText(), 3000, Toast::COLOR_ORANGE));
	g_log->TraceInfo(u8"暂停任务");
	return true;
}

void ScannerCtrl::PauseAuto()
{
	SignalService::GetInstance().ResetRelateCoverAlarm();

	if (!m_job_controller || !m_job_controller->GetJob()) {
		ToastBean* bean = new ToastBean(g_LngManager->Toast_NoPauseTask->ShowText(), 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(g_LngManager->Toast_PausingTask->ShowText(), 3000, Toast::COLOR_ORANGE));
	g_log->TraceInfo(u8"自动暂停任务");
}

bool ScannerCtrl::StopWork()
{
	m_StopMsg = "";
	SignalService::GetInstance().ResetRelateCoverAlarm();
	if (!m_job_controller || !m_job_controller->GetJob()) {
		ToastBean* bean = new ToastBean(g_LngManager->Toast_NoStopTask->ShowText(), 3000);
		g_Toast->AddToast(bean);
		m_StopMsg = g_LngManager->Toast_NoStopTask->ShowText();
		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(g_LngManager->Toast_StoppingTask->ShowText(), 3000, Toast::COLOR_ORANGE));
	g_log->TraceKeyInfo(g_LngManager->Toast_StoppingTask->ShowText());
	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(g_LngManager->Log_NoScannerCtrl->ShowText(), 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->GetValue()) {
			m_PressureCtrlFlag = true;
			m_PressureThread = AtlCreateThread(ReleasePressureProc, this);
		}
		if (m_RunCfg->m_AutoShutdownPower->GetValue()) {
			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(g_LngManager->Toast_NoTaskPrint->ShowText(), 3000));
		return;
	}
	MetaData* job_meta_data = job->GetMetaData();
	if (job_meta_data == NULL)return;

	size_t layerindex = job->GetStartIndex();

	m_Camera->SetDemandCatpure(true);
	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;

	char showBuffer[512];
	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 jLayerIndex = layerindex; jLayerIndex < layers.size(); jLayerIndex++) {
			MetaData::Layer* jlayer = layers[jLayerIndex];
			if (jlayer->data_blocks.empty())continue;
			bool dbbreak = false;
			for (size_t blockIndex = 0; blockIndex < jlayer->data_blocks.size(); ++blockIndex) {
				MetaData::DataBlock* jdatablock = jlayer->data_blocks[blockIndex];
				if (!jdatablock)continue;
				MetaData::Part* part = job_meta_data->GetPart(jdatablock->references->part);
				if (part) {
					if (part->print_enable) {
						hasPrintPart = true;
						dbbreak = true;
						break;
					}
				}
			}
			if (dbbreak)break;
		}
		if (!hasPrintPart)break;

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

		InfraredTempLog log;
		if (m_InfraredTemp && m_InfraredTemp->IsConnect())
		{
			//time(&log.m_InsertTime);
			time(&log.m_PreInsertTime);
			log.m_JobId = jobBean->m_Id;
			log.m_LayerIndex = layerindex;
			log.m_PartCount = job->GetComponentCount();
			vector<InfraredTemp::PartTempStat> pts;
			m_InfraredTemp->GetPartTemp(pts);
			for (int ifIndex = 0; ifIndex < pts.size(); ifIndex++) {
				InfraredTempLog::ITPair itPair;
				itPair.PreCover = pts[ifIndex].maxTemp;
				//itPair.Pid = pts[ifIndex].pid;
				log.m_Temps.push_back(itPair);
			}

			if (m_InfraredTempCfg->m_TempCtrlType->GetValue() == InfraredTempCfg::WAIT_TEMP) {
				while (IsStart()) {
					if (!m_InfraredTemp->IsOverChillDown())
					{
						break;
					}
					if (m_InfraredTempCfg->m_TempCtrlType->GetValue() != InfraredTempCfg::WAIT_TEMP)
					{
						break;
					}
					Sleep(100);
				}
				pts.clear();
				m_InfraredTemp->GetPartTemp(pts);
				for (int ifIndex = 0; ifIndex < pts.size(); ifIndex++) {
					if (ifIndex < log.m_Temps.size())
					{
						log.m_Temps[ifIndex].WaitMax = pts[ifIndex].maxTemp;
					}
				}
			}

			pts.clear();
			m_InfraredTemp->GetPartTemp(pts);
			for (int ifIndex = 0; ifIndex < pts.size(); ifIndex++) {
				if (ifIndex < log.m_Temps.size())
				{
					log.m_Temps[ifIndex].PreCover = pts[ifIndex].maxTemp;
				}
			}
		}

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


		bool isSlowWindSet = false;
		if (m_ExtCfg->m_AutoCoverSlowWind && m_PurifierClient->IsWindActive())
		{
			m_AlarmCfgWrapper->m_WindOverLimitAlarm->m_Shielding = true;
			Sleep(100);

			if (m_RunCfg->m_LogDebugInfo->GetValue())g_log->TraceInfo(u8"层%d开始铺粉降风速", layerindex + 1);
			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->GetValue())
			{
				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->GetValue())g_log->TraceInfo(u8"层%d开始铺粉", 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->GetValue()) {
				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, lastPowderGrid == 0);
			}

			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 < m_RecoatCheckCfg->m_CheckLayerIndex) || 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);
			if (!isOK) {
				layerThick = 0.0f;
			}
			else
				break;
		} while (!isOK && retry--);
		if (m_RunCfg->m_LogDebugInfo->GetValue())g_log->TraceInfo(u8"层%d铺粉完成", 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->GetValue())
			{
				m_PurifierClient->ResetSlwoWindSignal(false);
			}
		}
		if (m_RunCfg->m_LogDebugInfo->GetValue())g_log->TraceInfo(u8"层%d风速已经恢复", layerindex + 1);
		if (m_AlarmCfgWrapper->m_WindOverLimitAlarm && m_AlarmCfgWrapper->m_WindOverLimitAlarm->m_Shielding) {
			m_AlarmCfgWrapper->m_WindOverLimitAlarm->m_Shielding = false;
		}
		//ResetEvent(m_PowderEvent);
		if (m_ServoManager && lc) {
			//AxisLog* lc = new AxisLog(jobBean->m_Id, layerindex, m_CoverCfg->m_CoverDirection);
			m_ServoManager->StopLog(lc);
			g_log->m_LogDao->AddAxisLog(lc);
		}

		if (m_InfraredTemp && m_InfraredTemp->IsConnect())
		{
			time(&log.m_AftInserTime);
			vector<InfraredTemp::PartTempStat> pts;
			m_InfraredTemp->GetPartTemp(pts);
			for (int ifIndex = 0; ifIndex < pts.size(); ifIndex++) {
				if (ifIndex < log.m_Temps.size())
				{
					log.m_Temps[ifIndex].AftCover = pts[ifIndex].maxTemp;
				}
			}
			m_InfraredTemp->ResetPrintMax();
			if (m_InfraredTempCfg->m_TempCtrlType->GetValue() == InfraredTempCfg::COVERED_WAIT) {
				m_InfraredTemp->ResetWaitFlag();
			}
		}

		if (m_RunCfg->m_CoverLayerDelay->GetValue() != 0)
		{
			uint64_t tb = GetTickCount64();
			while (true)
			{
				Sleep(300);
				uint64_t tt = GetTickCount64();
				unsigned int difs = tt - tb;
				if (difs > (m_RunCfg->m_CoverLayerDelay->GetValue() * 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()) {
			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);
			}
		}

		if (m_InfraredTemp && m_InfraredTemp->IsConnect()) {
			IFImage* ifImage = new IFImage();
			time(&ifImage->m_InsertTime);
			ifImage->m_JobId = jobBean->m_Id;
			ifImage->m_LayerIndex = layerindex;
			ifImage->m_Type = IFImage::COVERED;
			m_InfraredTemp->InitLog(ifImage);
			g_log->m_LogDao->AddIFImage(ifImage);
			delete ifImage;
		}
		//	}

		linearAccDis -= (layer->powder == 0 ? 0 : layer->layer_thickness);
		float linearTheoryPos = lastLinearPos - (layer->powder == 0 ? 0 : layer->layer_thickness);
		float layerJudgeValue = m_RunCfg->m_LayerLinearPosAlarmOffset->GetValue();
		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", 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->GetValue()) {
			char buffer[256];
			sprintf_s(buffer, sizeof(buffer), u8"%zu层的理论伺服位置为%.3f mm，当前值为%.3f mm", 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->GetValue()) {
			char buffer[256];
			sprintf_s(buffer, sizeof(buffer), u8"%zu层的理论光栅位置为%.3f mm，当前值为%.3f mm", 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->GetValue())
		{
			g_log->TraceInfo(u8"层%d准备扫描", layerindex + 1);

		}
		sprintf_s(showBuffer, sizeof(showBuffer), u8"层%d准备扫描\n", layerindex + 1);
		OutputDebugString(showBuffer);
		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);
				if (!paramSet) {
					continue;
				}
				if (datablock->cno == 0)continue;
				if (paramSet->set_type.find("Down") != string::npos && m_RunCfg->m_DownSkinStopTimes->GetValue() > 0) {
					hasDownSkin = true;
					if ((m_DownSkinStopFlag % (m_RunCfg->m_DownSkinStopTimes->GetValue() + 1)) == 0) {
						continue;
					}
				}
				float laserPower = paramSet->laser_set->laser_real_power;
				if (laserPower == 0.0f) {
					continue;
				}

				if (!pdb)
				{
					continue;
				}

				Scanner* scanner = scanMap[datablock->cno];
				if (!scanner)continue;
				scanner->AddDataBlock(pdb, part, paramSet, datablock->order, datablock->scanTime);
				useScanner[datablock->cno] = 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->GetValue())
		{
			g_log->TraceInfo(u8"层%d扫描完成", layerindex + 1);

		}

		sprintf_s(showBuffer, sizeof(showBuffer), u8"层%d扫描完成\n", layerindex + 1);
		OutputDebugString(showBuffer);

		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()) {
			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_InfraredTemp && m_InfraredTemp->IsConnect())
		{
			time(&log.m_FinishedTime);
			vector<InfraredTemp::PartTempStat> pts;
			m_InfraredTemp->GetPartTemp(pts);
			for (int ifIndex = 0; ifIndex < pts.size(); ifIndex++) {
				if (ifIndex < log.m_Temps.size())
				{
					//log.m_Temps[ifIndex].AftCover = 20 + ifIndex;
					log.m_Temps[ifIndex].PrintMax = pts[ifIndex].printMaxTemp;
				}
			}
			g_log->m_LogDao->AddInfraredTempLog(log);
		}

		if (m_RunCfg->m_LogDebugInfo->GetValue())g_log->TraceInfo(u8"层%d扫描图像记录完成", layerindex + 1);
		m_IsDownSkinContinue = hasDownSkin;
		if (m_IsDownSkinContinue)m_DownSkinStopFlag++;
		else m_DownSkinStopFlag = 1;

		if (m_MachineCfg->m_IsIntelli->GetValue()) {

			vector<ScannerStatus*> scannerStatus;
			vector<FocusStatus*> focusStatus;
			for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
				m_scan[scanIndex]->UpdateScannerInfo();
				m_scan[scanIndex]->CheckAlarm();
				ScannerStatus* sstatus = new ScannerStatus();
				ScanStateXYSCT 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_InfraredTemp && m_InfraredTemp->IsConnect()) {
			IFImage* ifImage = new IFImage();
			time(&ifImage->m_InsertTime);
			ifImage->m_JobId = jobBean->m_Id;
			ifImage->m_LayerIndex = layerindex;
			ifImage->m_Type = IFImage::PRINTED;
			m_InfraredTemp->InitLog(ifImage);
			g_log->m_LogDao->AddIFImage(ifImage);
			delete ifImage;
		}
		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->GetValue() * 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);
	if (m_RunCfg->m_LogDebugInfo->GetValue())g_log->TraceInfo(u8"退出打印流程", 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(g_LngManager->Toast_NoTaskPrint->ShowText(), 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<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->GetPreviewDataBlock(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;
		}
		if (datablock->cno == 0)continue;
		Scanner* scanner = scanMap[datablock->cno];
		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[datablock->cno] = 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);
		//m_scan[i]->m_IsOrderSeqV2 = m_job_controller->GetJob()->GetMetaData()->m_IsScanOrderSeqV2;
	}
}


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(g_LngManager->Toast_StartScan->ShowText(), 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(g_LngManager->Toast_NoTaskPrint->ShowText(), 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())
	{
		g_Toast->AddToast(new ToastBean(_(u8"零件ID异常").c_str(), 3000, Toast::COLOR_RED));
		return;
	}

	if (scanType != "Border" && scanType != "Hatching")
	{
		g_Toast->AddToast(new ToastBean(_(u8"数据类型异常").c_str(), 3000, Toast::COLOR_RED));
		return;
	}

	vector<MetaData::Layer*> layers = job_meta_data->GetLayersVec();
	size_t layerindex = job->GetStartIndex();
	if (layerindex >= layers.size())
	{
		g_Toast->AddToast(new ToastBean(_(u8"选择层数异常").c_str(), 3000, Toast::COLOR_RED));
		return;
	}

	map<int, Scanner*> useScanner;

	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();
	}

	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") {
			bool isApply = true;
			switch (m_ExtCfg->m_model_border_type) {
			case ExtCfg::All_Border: {
				if (ps->set_type.find("Border") == ps->set_type.npos) {
					isApply = false;
				}
			}break;
			case ExtCfg::Border: {
				if (ps->set_type != "Border" && ps->set_type != "InBorder" && ps->set_type != "InBorderJ" &&
					ps->set_type != "BorderDown" && ps->set_type != "DownBorder" && ps->set_type != "DownBorderJ" &&
					ps->set_type != "BorderUp" && ps->set_type != "UpBorder" && ps->set_type != "UpBorderJ")isApply = false;
			}break;
			case ExtCfg::BorderAdditional: {
				if (ps->set_type != "BorderAdditional" && ps->set_type != "InBorderAd" && ps->set_type != "InBorderAdJ" &&
					ps->set_type != "BorderAdditionalDown" && ps->set_type != "DownBorderAd" && ps->set_type != "DownBorderAdJ" &&
					ps->set_type != "BorderAdditionalUp" && ps->set_type != "UpBorderAd" && ps->set_type != "UpBorderAdJ")isApply = false;
			}break;
			case ExtCfg::BorderBlocked: {
				if (ps->set_type != "BorderBlocked" && ps->set_type != "BorderBlockedDown" && ps->set_type != "BorderBlockedUp")isApply = false;
			}break;
			case ExtCfg::BorderSupport: {
				if (ps->set_type != "BorderSupport" && ps->set_type != "SupportBorder" && ps->set_type != "BorderAdditionalSupport")isApply = false;
			}break;
			}

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


		BPBinary::BinDataBlock* pdb = job_meta_data->GetDataBlock(datablock);
		if (!pdb)continue;
		if (datablock->cno == 0)continue;
		Scanner* scanner = scanMap[datablock->cno];
		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;
		if (m_ExtCfg->m_model_scan_mode == 1)
		{
			newParam->laser_set->laser_power = 1.0;
			newParam->laser_set->laser_real_power = 1.0;
		}
		else {
			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[datablock->cno] = scanner;
	}
	for (size_t i = 0; i < m_scan.size(); i++)
	{
		m_scan[i]->SetAutoUpdateScanInfo(false);
	}
	Sleep(300);
	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();
	for (size_t i = 0; i < m_scan.size(); i++)
	{
		m_scan[i]->SetAutoUpdateScanInfo(true);
	}
}

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

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

			if (g_SystemInfo->m_EnvState.m_PrintPressureAnalog <= _this->m_RunCfg->m_ReleasePressureTargeValue->GetValue()) {
				break;
			}
			Sleep(500);
		}
		if (_this->m_IOCfgWrapper->m_PressureRelease)_this->m_IOCfgWrapper->m_PressureRelease->SetActive(false);
		else _this->m_IOCfgWrapper->m_PrintAirEvacuation->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 && scanner->GetConfig() && 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->GetValue())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->GetValue()) {
			Sleep(100);
			count++;
		}
		if (!m_HeatingMotionFlag || !m_RunCfg->m_UseHeatingMotion->GetValue() || !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->GetValue() * 1000))
		{
			m_MachineCtrl->MoldMoveDown(m_RunCfg->m_HeatingMotionDistance->GetValue(),true);
			Sleep(500);
			m_MachineCtrl->MoldMoveUp(m_RunCfg->m_HeatingMotionDistance->GetValue(),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)ConverType::TryToI(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(ConverType::TryToI(rd.strValue));
			break;
		case STARTHEATINGMOTION:
			StartHeatingMotion();
			break;
		case STOPHEATINGMOTION:
			StopHeatingMotion((bool)ConverType::TryToI(rd.strValue));
			break;
		case STARTDEBUGTEST:
			if (!ConverType::IsToI(rd.strValue) || ConverType::TryToI(rd.strValue) >= m_scan.size()) {
				printf("%d index is out of range...\n",__LINE__);
				break;
			}
			m_scan[stoi(rd.strValue)]->StartDebugTest();
			break;
		case STOPDEBUGTEST:
			if (!ConverType::IsToI(rd.strValue) || ConverType::TryToI(rd.strValue) >= m_scan.size()) {
				printf("%d index is out of range...\n", __LINE__);
				break;
			}
			m_scan[ConverType::TryToI(rd.strValue)]->StopDebugTest();
			break;
		case STARTHEATINGSCANNERTEST:
			if (!ConverType::IsToI(rd.strValue) || ConverType::TryToI(rd.strValue) >= m_scan.size()) {
				printf("%d index is out of range...\n", __LINE__);
				break;
			}
			m_scan[ConverType::TryToI(rd.strValue)]->StartHeatingScannerTest();
			break;
		case STOPHEATINGSCANNERTEST:
			if (!ConverType::IsToI(rd.strValue) || ConverType::TryToI(rd.strValue) >= m_scan.size()) {
				printf("%d index is out of range...\n", __LINE__);
				break;
			}
			m_scan[ConverType::TryToI(rd.strValue)]->StopHeatingScannerTest();
			break;
		case STARTGETSCANINFO:
			if (!ConverType::IsToI(rd.strValue) || ConverType::TryToI(rd.strValue) >= m_scan.size()) {
				printf("%d index is out of range...\n", __LINE__);
				break;
			}
			m_scan[ConverType::TryToI(rd.strValue)]->StartGetScanInfo();
			break;
		case STOPGETSCANINFO:
			if (!ConverType::IsToI(rd.strValue) || ConverType::TryToI(rd.strValue) >= m_scan.size()) {
				printf("%d index is out of range...\n", __LINE__);
				break;
			}
			m_scan[ConverType::TryToI(rd.strValue)]->StopGetScanInfo();
			break;
		default:
			printf("参数不对...\n");
			break;
	
	}

}

void ScannerCtrl::SendToClients() {
	list<Item> lst;
	lst.emplace_back(Item{ "IsTestLayerEnable", to_string(IsTestLayerEnable()), iBOOL });
	lst.emplace_back(Item{ "IsHeatingScannerEnable", to_string(IsHeatingScannerEnable()), iBOOL });
	lst.emplace_back(Item{ "InitErrorInfos", GetInitErrorInfos(), iSTRING });
	int count = m_scan.size();
	lst.emplace_back(Item{ "ScanCount", to_string(count), iINT});
	for (int i = 0; i < count; ++i) {
		lst.emplace_back(Item{ "IsDebugEnable_"+to_string(i), to_string(m_scan[i]->IsDebugEnable()), iBOOL});
		lst.emplace_back(Item{ "IsHeatingScannerTest_"+to_string(i), to_string(m_scan[i]->IsHeatingScannerTest()), iBOOL});
	}

	auto iter = Scanner::m_CurrentSerio.begin();
	while (iter != Scanner::m_CurrentSerio.end()) {
		lst.emplace_back(Item{ to_string(iter->first), to_string(iter->second), iUINT });
		++iter;
	}
	
	ClientWrapper::Instance()->PushAllClient(WriteData(SCANCTRLPARAM,lst));
}



void ScannerCtrl::StopWorkManual()
{
	if (m_StopFlag)return;
	m_StopFlag = true;
	m_StopThread = AtlCreateThread(StopWorkProc, this);
}


DWORD WINAPI ScannerCtrl::StopWorkProc(ScannerCtrl* _this)
{
	if (_this) {
		_this->m_StopMsg = "";
		SignalService::GetInstance().ResetRelateCoverAlarm();
		if (!_this->m_job_controller || !_this->m_job_controller->GetJob()) {
			ToastBean* bean = new ToastBean(g_LngManager->Toast_NoStopTask->ShowText(), 3000);
			g_Toast->AddToast(bean);
			_this->m_StopMsg = g_LngManager->Toast_NoStopTask->ShowText();
			CloseHandle(_this->m_StopThread);
			_this->m_StopThread = INVALID_HANDLE_VALUE;
			_this->m_StopFlag = false;
			return 0;
		}
		_this->m_job_controller->GetJob()->m_IsAutoCtrl = false;
		g_SystemInfo->m_AutoPrintCtrlState = NoAuto;
		BaseCtrl::SetPauseState(BaseCtrl::NoPause);

		if (BaseCtrl::IsStandBy()) {
			BaseCtrl::SetState(BaseCtrl::STOP);
			_this->m_job_controller->GetJob()->SetStartIndex(0);
			_this->m_job_controller->GetJob()->GetJobbean()->m_IsContinue = false;
			_this->CtrlWhenStop();
			_this->m_job_controller->GetJob()->UpdateJobBeanWhenStop();
			BaseCtrl::SetState(BaseCtrl::STANDBY_STOP);
			CloseHandle(_this->m_StopThread);
			_this->m_StopThread = INVALID_HANDLE_VALUE;
			_this->m_StopFlag = false;
			return 0;
		}

		BaseCtrl::SetState(BaseCtrl::STOP);
		for (size_t i = 0; i < _this->m_scan.size(); i++) {
			_this->m_scan[i]->StopWork();
		}
		BaseCtrl::SetPreState(BaseCtrl::NonePre);
		g_Toast->AddToast(new ToastBean(g_LngManager->Toast_StoppingTask->ShowText(), 3000, Toast::COLOR_ORANGE));
		g_log->TraceKeyInfo(g_LngManager->Toast_StoppingTask->ShowText());

		CloseHandle(_this->m_StopThread);
		_this->m_StopThread = INVALID_HANDLE_VALUE;
		_this->m_StopFlag = false;
	}
	return 0;
}