~chenluhua/Bond2.git

			@@ -1,6 +1,11 @@
			#include "stdafx.h"
			#include "Common.h"
			#include "CMaster.h"
			#include <future>
			#include <vector>
			#include "RecipeManager.h"
			#include <fstream>
			#include "SerializeUtil.h"


			namespace SERVO {
			@@ -48,11 +53,34 @@
			m_ullRunTime = 0;
			m_state = MASTERSTATE::READY;
			m_pActiveRobotTask = nullptr;
			m_nLastError = ER_CODE_NOERROR;
			m_isCompareMapsBeforeProceeding = FALSE;
			m_bJobMode = FALSE;
			m_bEnableEventReport = true;
			m_bEnableAlarmReport = true;
			m_bContinuousTransfer = false;
			m_bBatch = false;
			m_nContinuousTransferCount = 0;
			m_nContinuousTransferStep = CTStep_Unknow;
			m_nContinuousWorkingPort = 0;
			m_nContinuousWorkingSlot = 0;
			m_pControlJob = nullptr;
			m_nTestFlag = 0;
			InitializeCriticalSection(&m_criticalSection);
			}

			CMaster::~CMaster()
			{
			// 释放Job相关
			for (auto item : m_processJobs) {
			delete item;
			}
			m_processJobs.clear();
			if (m_pControlJob != nullptr) {
			delete m_pControlJob;
			m_pControlJob = nullptr;
			}

			if (m_hEventReadBitsThreadExit[0] != nullptr) {
			::CloseHandle(m_hEventReadBitsThreadExit[0]);
			m_hEventReadBitsThreadExit[0] = nullptr;
			@@ -105,7 +133,7 @@
			BoardVersion version{};
			int nRet = m_cclink.GetBoardVersion(version);
			if (nRet == 0) {
			LOGI("版本信息：%s.", version.toString().c_str());
			LOGD("版本信息：%s.", version.toString().c_str());
			}
			else {
			LOGE("获取CC-Link版本信息失败.");
			@@ -114,7 +142,7 @@
			BoardStatus status;
			nRet = m_cclink.GetBoardStatus(status);
			if (nRet == 0) {
			LOGI("状态：%s.", status.toString().c_str());
			LOGD("状态：%s.", status.toString().c_str());
			}
			else {
			LOGE("获取CC-Link状态失败.");
			@@ -160,9 +188,9 @@
			ASSERT(pMeasurement);

			pEfem->setPort(0, pPort1);
			pEfem->setPort(1, pPort1);
			pEfem->setPort(2, pPort1);
			pEfem->setPort(3, pPort1);
			pEfem->setPort(1, pPort2);
			pEfem->setPort(2, pPort3);
			pEfem->setPort(3, pPort4);
			pEfem->setFliper(pFliper);
			pEfem->setAligner(pAligner);
			pEfem->setArmTray(0, pArmTray1);
			@@ -185,10 +213,9 @@





			// 读缓存数据
			readCache();
			loadState();


			// 定时器
			@@ -245,28 +272,83 @@
			return -1;
			}

			m_bContinuousTransfer = false;
			m_bBatch = false;
			setState(MASTERSTATE::STARTING);
			m_ullStartTime = GetTickCount64();

			return 0;
			}

			int CMaster::stop()
			int CMaster::startContinuousTransfer()
			{
			// 运行时间为累加结果，本次停止时刷新；
			if (m_state != MASTERSTATE::RUNNING) {
			if (m_state != MASTERSTATE::READY) {
			return -1;
			}

			m_ullRunTime += (GetTickCount64() - m_ullStartTime);
			setState(MASTERSTATE::STOPPING);
			m_bContinuousTransfer = true;
			m_bBatch = false;
			setState(MASTERSTATE::STARTING);
			m_ullStartTime = GetTickCount64();

			return 0;
			}

			int CMaster::startBatch()
			{
			if (m_state != MASTERSTATE::READY) {
			return -1;
			}

			m_bContinuousTransfer = false;
			m_bBatch = true;
			setState(MASTERSTATE::STARTING);
			m_ullStartTime = GetTickCount64();

			return 0;
			}

			int CMaster::stop(int nErCode/* = ER_CODE_NOERROR*/)
			{
			// 运行时间为累加结果，本次停止时刷新；
			lock();
			if (m_state != MASTERSTATE::RUNNING && m_state != MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER
			&& m_state != MASTERSTATE::RUNNING_BATCH) {
			unlock();
			return -1;
			}
			m_ullRunTime += (GetTickCount64() - m_ullStartTime);
			unlock();


			// 更新状态
			m_nLastError = nErCode;
			setState(MASTERSTATE::STOPPING);


			// ControlJob暂停
			lock();
			if (m_pControlJob != nullptr) {
			m_pControlJob->pause();
			saveState();
			}
			unlock();


			return 0;
			}

			void CMaster::clearError()
			{
			m_nLastError = 0;
			m_strLastError = "";
			setState(MASTERSTATE::READY);
			}

			ULONGLONG CMaster::getRunTime()
			{
			if (m_state == MASTERSTATE::RUNNING)
			if (m_state == MASTERSTATE::RUNNING \|\| m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER
			\|\| m_state == MASTERSTATE::RUNNING_BATCH)
			return m_ullRunTime + (GetTickCount64() - m_ullStartTime);
			else
			return m_ullRunTime;
			@@ -287,28 +369,37 @@


			// 各种机器
			CLoadPort* pLoadPort1 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT1);
			CLoadPort* pLoadPort2 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT2);
			CLoadPort* pLoadPorts[4];
			CEFEM* pEFEM = (CEFEM*)getEquipment(EQ_ID_EFEM);
			pLoadPorts[0] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT1);
			pLoadPorts[1] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT2);
			pLoadPorts[2] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT3);
			pLoadPorts[3] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT4);
			CFliper* pFliper = (CFliper*)getEquipment(EQ_ID_FLIPER);
			CVacuumBake* pVacuumBack = (CVacuumBake*)getEquipment(EQ_ID_VACUUMBAKE);
			CVacuumBake* pVacuumBake = (CVacuumBake*)getEquipment(EQ_ID_VACUUMBAKE);
			CAligner* pAligner = (CAligner*)getEquipment(EQ_ID_ALIGNER);
			CBonder* pBonder1 = (CBonder*)getEquipment(EQ_ID_Bonder1);
			CBonder* pBonder2 = (CBonder*)getEquipment(EQ_ID_Bonder2);
			CBakeCooling* pBakeCooling = (CBakeCooling*)getEquipment(EQ_ID_BAKE_COOLING);
			CMeasurement* pMeasurement = (CMeasurement*)getEquipment(EQ_ID_MEASUREMENT);

			ASSERT(pLoadPort1);
			ASSERT(pLoadPort2);
			ASSERT(pEFEM);
			ASSERT(pLoadPorts[0]);
			ASSERT(pLoadPorts[1]);
			ASSERT(pLoadPorts[2]);
			ASSERT(pLoadPorts[3]);
			ASSERT(pFliper);
			ASSERT(pVacuumBack);
			ASSERT(pVacuumBake);
			ASSERT(pAligner);
			ASSERT(pBonder1);
			ASSERT(pBonder2);
			ASSERT(pBakeCooling);
			ASSERT(pMeasurement);

			while (1) {
			// 待退出信号或时间到
			HANDLE hEvents[] = { m_hEventDispatchThreadExit[0], m_hDispatchEvent };
			int nRet = WaitForMultipleObjects(2, hEvents, FALSE, 1000);
			int nRet = WaitForMultipleObjects(2, hEvents, FALSE, 500);
			if (nRet == WAIT_OBJECT_0) {
			break;
			}
			@@ -317,9 +408,126 @@
			// 如果状态为STARTING，开始工作并切换到RUNNING状态
			lock();
			if (m_state == MASTERSTATE::STARTING) {
			// 发送indexerOperationModeChange到各个机台，成功后切换到RUNNING状态
			// 否则切换到MSERROR状态
			int nRet;
			CEquipment* pEq[6] = { pEFEM, pBonder1, pBonder2, pBakeCooling,
			pVacuumBake, pMeasurement};
			BOOL bIomcOk[7] = {FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE};
			std::vector<std::promise<void>> promises(6);
			std::vector<std::future<void>> futures;

			nRet = pEq[0]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
			[&](int writeCode, int retCode) -> void {
			bIomcOk[0] = retCode == (int)RET::OK;
			promises[0].set_value();
			TRACE("a0001\n", writeCode, retCode);
			});
			if (nRet != 0) {
			LOGE("<Master>EFEM切换Start状态失败");
			m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
			m_strLastError = "EFEM切换Start状态失败.";
			goto WAIT;
			}
			futures.push_back(promises[0].get_future());
			/*
			nRet = pEq[1]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
			[&](int writeCode, int retCode) -> void {
			bIomcOk[1] = retCode == (int)RET::OK;
			promises[1].set_value();
			TRACE("a0002\n");
			});
			if (nRet != 0) {
			LOGE("<Master>Bonder1切换Start状态失败");
			m_nLastError = ER_CODE_BONDER_OPERATION_MODE_FAIL;
			m_strLastError = "Bonder1切换Start状态失败.";
			goto WAIT;
			}
			futures.push_back(promises[1].get_future());

			nRet = pEq[2]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
			[&](int writeCode, int retCode) -> void {
			bIomcOk[2] = retCode == (int)RET::OK;
			promises[2].set_value();
			TRACE("a0003\n");
			});
			if (nRet != 0) {
			LOGE("<Master>Bonder2切换Start状态失败");
			m_nLastError = ER_CODE_BONDER_OPERATION_MODE_FAIL;
			m_strLastError = "Bonder2切换Start状态失败.";
			goto WAIT;
			}
			futures.push_back(promises[2].get_future());

			nRet = pEq[3]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
			[&](int writeCode, int retCode) -> void {
			bIomcOk[3] = retCode == (int)RET::OK;
			promises[3].set_value();
			TRACE("a0004\n");
			});
			if (nRet != 0) {
			LOGE("<Master>BakeCooling切换Start状态失败");
			m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
			m_strLastError = "BakeCooling切换Start状态失败.";
			goto WAIT;
			}
			futures.push_back(promises[3].get_future());

			nRet = pEq[4]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
			[&](int writeCode, int retCode) -> void {
			bIomcOk[4] = retCode == (int)RET::OK;
			promises[4].set_value();
			TRACE("a0005\n");
			});
			if (nRet != 0) {
			LOGE("<Master>VacuumBake切换Start状态失败");
			m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
			m_strLastError = "VacuumBake切换Start状态失败.";
			goto WAIT;
			}
			futures.push_back(promises[4].get_future());

			nRet = pEq[5]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
			[&](int writeCode, int retCode) -> void {
			bIomcOk[5] = retCode == (int)RET::OK;
			promises[5].set_value();
			TRACE("a0006\n");
			});
			if (nRet != 0) {
			LOGE("<Master>Measurement切换Start状态失败");
			m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
			m_strLastError = "Measurement切换Start状态失败.";
			goto WAIT;
			}
			futures.push_back(promises[5].get_future());
			*/

			WAIT:
			for (auto& f : futures) {
			f.wait(); // 阻塞等待对应设备完成
			}
			for (int i = 0; i < 6; i++) {
			if (!bIomcOk[i]) {
			bIomcOk[6] = FALSE;
			LOGE("<Master>%s切换Start状态失败", pEq[i]->getName().c_str());
			}
			}

			// 检查看是否都已经切换到START状态
			if (!bIomcOk[6]) {
			unlock();
			setState(MASTERSTATE::MSERROR);
			continue;
			}

			unlock();
			Sleep(1000);
			setState(MASTERSTATE::RUNNING);
			if(m_bContinuousTransfer)
			setState(MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER);
			else if (m_bBatch)
			setState(MASTERSTATE::RUNNING_BATCH);
			else
			setState(MASTERSTATE::RUNNING);

			continue;
			}

			@@ -327,19 +535,72 @@
			// 处理完成当前事务后，切换到停止或就绪状态
			else if (m_state == MASTERSTATE::STOPPING) {
			unlock();
			Sleep(1000);
			setState(MASTERSTATE::READY);
			LOGI("<Master>开始切换各设备到 Stop 模式...");

			std::vector<std::promise<void>> promises(6);
			std::vector<std::future<void>> futures;
			BOOL bIomcOk[7] = { FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE };

			int nRet;
			CEquipment* pEq[6] = { pEFEM, pBonder1, pBonder2, pBakeCooling,
			pVacuumBake, pMeasurement };

			for (int i = 0; i < 1; ++i) {
			nRet = pEq[i]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Stop,
			[i, &promises, &bIomcOk](int writeCode, int retCode) -> void {
			bIomcOk[i] = retCode == (int)RET::OK;
			promises[i].set_value();
			TRACE("s000%d: ret=%d\n", i + 1, retCode);
			});
			if (nRet != 0) {
			LOGE("<Master>%s切换Stop状态发送失败", pEq[i]->getName().c_str());
			m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
			m_strLastError = pEq[i]->getName() + "切换Stop状态发送失败.";
			bIomcOk[i] = FALSE;
			promises[i].set_value(); // 避免 wait 阻塞
			}
			futures.push_back(promises[i].get_future());
			}

			for (auto& f : futures) {
			f.wait(); // 等待所有完成
			}

			for (int i = 0; i < 6; ++i) {
			if (!bIomcOk[i]) {
			bIomcOk[6] = FALSE;
			LOGE("<Master>%s切换Stop状态失败", pEq[i]->getName().c_str());
			}
			}

			if (!bIomcOk[6]) {
			setState(MASTERSTATE::MSERROR);
			continue;
			}

			LOGI("<Master>所有设备成功切换到 Stop 模式");
			if(m_nLastError == ER_CODE_NOERROR)
			setState(MASTERSTATE::READY);
			else
			setState(MASTERSTATE::ATHERERROR);

			continue;
			}


			// 调度逻辑处理
			else if (m_state == MASTERSTATE::RUNNING) {
			unlock();
			// LOGI("调度处理中...");
			// 检测判断robot状态
			RMDATA& rmd = pEFEM->getRobotMonitoringData();
			if (rmd.status != ROBOT_STATUS::Idle && rmd.status != ROBOT_STATUS::Run) {
			unlock();
			continue;
			}

			lock();
			if (m_pActiveRobotTask != nullptr) {
			if (m_pActiveRobotTask->isPicked()) {
			m_pActiveRobotTask->place();
			}
			unlock();
			// 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
			// LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
			@@ -347,164 +608,616 @@
			}


			// 此处检测优先类型和次要类型（G1或G2）
			// 如果其中一Bonder有单个玻璃，优先取它的配对类型，否则无所谓了
			primaryType = MaterialsType::G1;
			secondaryType = MaterialsType::G2;
			if ((!pBonder1->canPlaceGlassInSlot(0) && !pBonder1->canPlaceGlassInSlot(1))
			&& (!pBonder2->canPlaceGlassInSlot(0) && !pBonder2->canPlaceGlassInSlot(1))) {
			// 如果G1和G2都满了，那就看Aligner, 如果Aligner有玻璃为G1, 则取G2
			CGlass* pGlass = pAligner->getGlassFromSlot(1);
			if (pGlass != nullptr && pGlass->getType() == MaterialsType::G1) {
			primaryType = MaterialsType::G2;
			secondaryType = MaterialsType::G1;
			// Bonder1、Bonder2、Fliper、VacuumBake、Aligner，统计G2和G1的数量, 配对组数, 多出的类型
			int nG2Count = 0, nG1Count = 0, nGlassGroup, nExtraType;
			if (pBonder1->slotHasGlass(0)) {
			nG2Count++;
			}
			if (pBonder1->slotHasGlass(1)) {
			nG1Count++;
			}

			if (pBonder2->slotHasGlass(0)) {
			nG2Count++;
			}
			if (pBonder2->slotHasGlass(1)) {
			nG1Count++;
			}

			if (pFliper->slotHasGlass(0)) {
			nG2Count++;
			}

			if (pVacuumBake->slotHasGlass(0)) {
			nG1Count++;
			}
			if (pVacuumBake->slotHasGlass(1)) {
			nG1Count++;
			}

			CGlass* pTempGlass = pAligner->getGlassFromSlot(0);
			if (pTempGlass != nullptr) {
			MaterialsType type = pTempGlass->getType();
			if(type == MaterialsType::G1)
			nG1Count++;
			else if (type == MaterialsType::G2)
			nG2Count++;
			}
			nGlassGroup = min(nG1Count, nG2Count);

			if (nG1Count == nG2Count) {
			nExtraType = 0;
			}
			else if (nG1Count > nG2Count) {
			nExtraType = 1;
			}
			else {
			nExtraType = 2;
			}
			secondaryType = MaterialsType::G0;


			// Measurement -> LoadPort
			for (int s = 0; s < 4; s++) {
			PortType pt = pLoadPorts[s]->getPortType();
			if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
			&& (pt == PortType::Unloading \|\| pt == PortType::Both)
			&& pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
			m_pActiveRobotTask = createTransferTask(pMeasurement, pLoadPorts[s], MaterialsType::G1, secondaryType);
			if (m_pActiveRobotTask != nullptr) {
			goto PORT_PUT;
			}
			}
			}
			else if ((pBonder1->canPlaceGlassInSlot(0) && !pBonder1->canPlaceGlassInSlot(1))
			\|\| (pBonder2->canPlaceGlassInSlot(0) && !pBonder2->canPlaceGlassInSlot(1))) {
			primaryType = MaterialsType::G2;
			secondaryType = MaterialsType::G1;
			}

			PORT_PUT:
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);


			// Bonder -> BakeCooling
			m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder1, pBakeCooling, primaryType, secondaryType);
			if (m_pActiveRobotTask != nullptr) {
			std::string strDescription = m_pActiveRobotTask->getDescription();
			unlock();
			if (m_listener.onRobotTaskEvent != nullptr) {
			m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, 0);
			}
			LOGI("创建新任务<%s>...", strDescription.c_str());
			continue;
			}

			m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder2, pBakeCooling, primaryType, secondaryType);
			if (m_pActiveRobotTask != nullptr) {
			std::string strDescription = m_pActiveRobotTask->getDescription();
			unlock();
			if (m_listener.onRobotTaskEvent != nullptr) {
			m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, 0);
			}
			LOGI("创建新任务<%s>...", strDescription.c_str());
			continue;
			}

			// Aligner -> Bonder
			m_pActiveRobotTask = createTransferTask(pAligner, pBonder1, primaryType, secondaryType);
			if (m_pActiveRobotTask != nullptr) {
			std::string strDescription = m_pActiveRobotTask->getDescription();
			unlock();
			if (m_listener.onRobotTaskEvent != nullptr) {
			m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, 0);
			}
			LOGI("创建新任务<%s>...", strDescription.c_str());
			continue;
			}

			m_pActiveRobotTask = createTransferTask(pAligner, pBonder2, primaryType, secondaryType);
			if (m_pActiveRobotTask != nullptr) {
			std::string strDescription = m_pActiveRobotTask->getDescription();
			unlock();
			if (m_listener.onRobotTaskEvent != nullptr) {
			m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, 0);
			}
			LOGI("创建新任务<%s>...", strDescription.c_str());
			continue;
			}


			// Fliper(G2) -> Aligner
			// VacuumBake(G1) -> Aligner
			m_pActiveRobotTask = createTransferTask(pFliper, pAligner, primaryType, secondaryType);
			if (m_pActiveRobotTask != nullptr) {
			std::string strDescription = m_pActiveRobotTask->getDescription();
			unlock();
			if (m_listener.onRobotTaskEvent != nullptr) {
			m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, 0);
			}
			LOGI("创建新任务<%s>...", strDescription.c_str());
			continue;
			}

			m_pActiveRobotTask = createTransferTask(pVacuumBack, pAligner, primaryType, secondaryType);
			if (m_pActiveRobotTask != nullptr) {
			std::string strDescription = m_pActiveRobotTask->getDescription();
			unlock();
			if (m_listener.onRobotTaskEvent != nullptr) {
			m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, 0);
			}
			LOGI("创建新任务<%s>...", strDescription.c_str());
			continue;
			}


			// LoadPort -> Fliper(G2)
			// LoadPort -> VacuumBake(G1)
			CEquipment* pEqTar1 = pVacuumBack;
			CEquipment* pEqTar2 = pFliper;
			if (primaryType == MaterialsType::G2) {
			pEqTar1 = pFliper;
			pEqTar2 = pVacuumBack;
			}
			m_pActiveRobotTask = createTransferTask(pLoadPort1, pEqTar1, primaryType, secondaryType);
			if (m_pActiveRobotTask != nullptr) {
			std::string strDescription = m_pActiveRobotTask->getDescription();
			unlock();
			if (m_listener.onRobotTaskEvent != nullptr) {
			m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, 0);
			}
			LOGI("创建新任务<%s>...", strDescription.c_str());
			continue;
			}

			m_pActiveRobotTask = createTransferTask(pLoadPort2, pEqTar1, primaryType, secondaryType);
			if (m_pActiveRobotTask != nullptr) {
			std::string strDescription = m_pActiveRobotTask->getDescription();
			unlock();
			if (m_listener.onRobotTaskEvent != nullptr) {
			m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, 0);
			}
			LOGI("创建新任务<%s>...", strDescription.c_str());
			continue;
			}



			// LoadPort -> VacuumBake(G1)
			m_pActiveRobotTask = createTransferTask(pLoadPort1, pEqTar2, primaryType, secondaryType);
			if (m_pActiveRobotTask != nullptr) {
			std::string strDescription = m_pActiveRobotTask->getDescription();
			unlock();
			if (m_listener.onRobotTaskEvent != nullptr) {
			m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, 0);
			}
			LOGI("创建新任务<%s>...", strDescription.c_str());
			continue;
			}

			m_pActiveRobotTask = createTransferTask(pLoadPort2, pEqTar2, primaryType, secondaryType);
			if (m_pActiveRobotTask != nullptr) {
			std::string strDescription = m_pActiveRobotTask->getDescription();
			unlock();
			if (m_listener.onRobotTaskEvent != nullptr) {
			m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, 0);
			}
			LOGI("创建新任务<%s>...", strDescription.c_str());
			continue;
			// Measurement NG -> LoadPort
			// NG回原位
			if (!rmd.armState[1]) {
			m_pActiveRobotTask = createTransferTask_restore(pMeasurement, pLoadPorts);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}


			// BakeCooling ->Measurement
			if (!rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask_bakecooling_to_measurement(pBakeCooling, pMeasurement);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}


			// BakeCooling内部
			// Bake -> Cooling
			if (!rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask_bake_to_cooling(pBakeCooling);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}


			// Measurement -> LoadPort
			// Bonder -> BakeCooling
			if (!rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder1, pBakeCooling);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			if (!rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder2, pBakeCooling);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}


			// Fliper(G2) -> Bonder
			//m_nTestFlag = 1;
			//pVacuumBake->m_nTestFlag = 1;
			auto pSrcSlot = pVacuumBake->getProcessedSlot(MaterialsType::G1);
			//LOGI("<Master>pSrcSlot = %x", pSrcSlot,);
			if (pSrcSlot != nullptr && !rmd.armState[1]
			&& pBonder1->canPlaceGlassInSlot(0)) {
			m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, MaterialsType::G2, MaterialsType::G0, 2);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}
			if (pSrcSlot != nullptr && !rmd.armState[1]
			&& pBonder2->canPlaceGlassInSlot(0)) {
			m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, MaterialsType::G2, MaterialsType::G0, 2);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}
			//m_nTestFlag = 0
			;
			// VacuumBake(G1) -> Bonder
			if (!rmd.armState[0] && pBonder1->slotHasGlass(0) && !pBonder1->slotHasGlass(1)) {
			m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder1, MaterialsType::G1, MaterialsType::G0);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			if (!rmd.armState[0] && pBonder2->slotHasGlass(0) && !pBonder2->slotHasGlass(1)) {
			m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder2, MaterialsType::G1, MaterialsType::G0);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}


			// Aligner -> Fliper(G2)
			// Aligner -> VacuumBake(G1)
			if (!rmd.armState[1]) {
			m_pActiveRobotTask = createTransferTask(pAligner, pFliper, MaterialsType::G2, secondaryType);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			if (!rmd.armState[0]) {
			// m_nTestFlag = 1;
			if (m_nTestFlag == 1) LOGD("createTransferTask 004df %d, %d", MaterialsType::G1, secondaryType);
			m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, MaterialsType::G1, secondaryType);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			m_nTestFlag = 0;
			}


			// Aligner -> LoadPort
			if (!rmd.armState[1]) {
			m_pActiveRobotTask = createTransferTask_restore(pAligner, pLoadPorts);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}


			// LoadPort -> Aligner
			if (nGlassGroup >= 2) {
			unlock();
			continue;
			}

			if(nExtraType == 0)
			primaryType = MaterialsType::G2;
			else {
			primaryType = MaterialsType::G1;
			}

			for (int s = 0; s < 4; s++) {
			PortType pt = pLoadPorts[s]->getPortType();
			if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
			&& (pt == PortType::Loading \|\| pt == PortType::Both)
			&& pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
			m_pActiveRobotTask = createTransferTask(pLoadPorts[s], pAligner, primaryType, secondaryType, 1, m_bJobMode);
			if (m_pActiveRobotTask != nullptr) {
			CGlass* pGlass = (CGlass*)m_pActiveRobotTask->getContext();
			if (pGlass->getBuddy() != nullptr) {
			delete m_pActiveRobotTask;
			m_pActiveRobotTask = nullptr;
			continue;
			}

			pGlass->queue();
			pGlass->start();
			pEFEM->setContext(m_pActiveRobotTask->getContext());
			goto PORT_GET;
			}
			}
			}

			PORT_GET:
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);


			unlock();

			continue;
			}

			// 批处理模式，最终以此为准，但先保留之前的单片模式
			else if (m_state == MASTERSTATE::RUNNING_BATCH) {
			// 1) 控制作业生命周期保障
			if (m_pControlJob == nullptr) { unlock(); continue; }
			CJState cjst = m_pControlJob->state();
			if (cjst == CJState::Completed \|\| cjst == CJState::Aborted \|\| cjst == CJState::Failed) {
			unlock();
			continue;
			}
			if (cjst == CJState::NoState) {
			LOGI("<Master>ControlJob已经进入列队");
			m_pControlJob->queue();
			}
			if (m_pControlJob->state() == CJState::Queued) {
			LOGI("<Master>ControlJob已经启动");
			m_pControlJob->start();
			if (m_listener.onCjStart) m_listener.onCjStart(this, m_pControlJob);
			}
			if (m_pControlJob->state() == CJState::Paused) {
			LOGI("<Master>ControlJob已经恢复运行");
			m_pControlJob->resume();
			}

			// 2) 若当前无 PJ，则选择一个并上报
			if (m_inProcesJobs.empty()) {
			if (auto pj = acquireNextProcessJob()) {
			m_inProcesJobs.push_back(pj);
			if (m_listener.onPjStart) m_listener.onPjStart(this, pj);
			}
			}
			if (m_inProcesJobs.empty()) {
			LOGE("<Master>选择当前ProcessJob失败！");
			unlock();
			continue;
			}

			// 3) 若队列无 Glass，拉取到等待队列
			if (m_queueGlasses.empty()) {
			int nCount = acquireGlassToQueue();
			if (nCount > 0) {
			LOGI("<Master>已加入 %d 块Glass到工艺列队！", nCount);
			}
			}

			// 4) 机器人状态
			RMDATA& rmd = pEFEM->getRobotMonitoringData();
			if (rmd.status != ROBOT_STATUS::Idle && rmd.status != ROBOT_STATUS::Run) {
			unlock(); continue;
			}

			// 5) 正在执行的 RobotTask 先让它跑完一拍
			if (m_pActiveRobotTask != nullptr) {
			if (m_pActiveRobotTask->isPicked()) {
			m_pActiveRobotTask->place();
			}
			unlock(); // 等当前任务完成或中止后继续
			continue;
			}

			// 6) ——关键：全局统计 G1/G2 与组数门限（与单片分支对齐）——
			auto countG1G2 = [&]() {
			int g1 = 0, g2 = 0;
			if (pBonder1->slotHasGlass(0)) g2++;
			if (pBonder1->slotHasGlass(1)) g1++;
			if (pBonder2->slotHasGlass(0)) g2++;
			if (pBonder2->slotHasGlass(1)) g1++;
			if (pFliper->slotHasGlass(0)) g2++;
			if (pVacuumBake->slotHasGlass(0)) g1++;
			if (pVacuumBake->slotHasGlass(1)) g1++;
			if (auto g = pAligner->getGlassFromSlot(0)) {
			auto t = g->getType();
			if (t == MaterialsType::G1) g1++; else if (t == MaterialsType::G2) g2++;
			}
			return std::pair<int, int>(g1, g2);
			};

			int g1Count = 0, g2Count = 0;
			std::tie(g1Count, g2Count) = countG1G2();
			int nGlassGroup = min(g1Count, g2Count);
			int nExtraType = (g1Count == g2Count ? 0 : (g1Count > g2Count ? 1 : 2));

			// primary/secondary 统一定义（secondary 默认 G0）
			MaterialsType primaryType = MaterialsType::G1;
			MaterialsType secondaryType = MaterialsType::G0;
			if (nExtraType == 0) primaryType = MaterialsType::G2; // 与单片分支一致
			else primaryType = MaterialsType::G1;

			// 组数门限：≥2 组时不再从 LP 上片，避免堆积（与单片一致）
			bool blockLoadFromLP = (nGlassGroup >= 2);

			// 7) Measurement -> LoadPort（固定：G1 优先回 LP）
			if (rmd.armState[0] \|\| rmd.armState[1]) {
			LOGD("Arm1 %s, Arm2 %s.",
			rmd.armState[0] ? _T("不可用") : _T("可用"),
			rmd.armState[1] ? _T("不可用") : _T("可用"));
			}
			for (int s = 0; s < 4; s++) {
			PortType pt = pLoadPorts[s]->getPortType();
			if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
			&& (pt == PortType::Unloading \|\| pt == PortType::Both)
			&& pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
			m_pActiveRobotTask = createTransferTask(pMeasurement, pLoadPorts[s], MaterialsType::G1, secondaryType);
			if (m_pActiveRobotTask != nullptr) { goto BATCH_PORT_PUT; }
			}
			}

			BATCH_PORT_PUT:
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);

			// 8) Measurement NG -> LoadPort（原位回退）
			if (!rmd.armState[1]) {
			m_pActiveRobotTask = createTransferTask_restore(pMeasurement, pLoadPorts);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			// 9) BakeCooling -> Measurement
			if (!rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask_bakecooling_to_measurement(pBakeCooling, pMeasurement);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			// 10) BakeCooling 内部（Bake -> Cooling）
			if (!rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask_bake_to_cooling(pBakeCooling);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			// 11) Bonder -> BakeCooling
			if (!rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder1, pBakeCooling);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}
			if (!rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder2, pBakeCooling);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			// 12) Fliper(G2) -> Bonder（前置：VacuumBake 有 processed G1；输出 G2 到 Bonder slot0）
			if (auto pSrcSlot = pVacuumBake->getProcessedSlot(MaterialsType::G1)) {
			if (!rmd.armState[1] && pBonder1->canPlaceGlassInSlot(0)) {
			m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, MaterialsType::G2, MaterialsType::G0, 2);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}
			if (!rmd.armState[1] && pBonder2->canPlaceGlassInSlot(0)) {
			m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, MaterialsType::G2, MaterialsType::G0, 2);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}
			}

			// 13) VacuumBake(G1) -> Bonder（槽级判定：slot0(G2) 已有且 slot1(G1) 为空）
			if (!rmd.armState[0] && pBonder1->slotHasGlass(0) && !pBonder1->slotHasGlass(1)) {
			m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder1, MaterialsType::G1, MaterialsType::G0);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}
			if (!rmd.armState[0] && pBonder2->slotHasGlass(0) && !pBonder2->slotHasGlass(1)) {
			m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder2, MaterialsType::G1, MaterialsType::G0);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			// 14) Aligner -> Fliper(G2) 以及 -> VacuumBake(G1)（固定映射）
			if (!rmd.armState[1]) {
			m_pActiveRobotTask = createTransferTask(pAligner, pFliper, MaterialsType::G2, MaterialsType::G0);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}
			if (!rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, MaterialsType::G1, MaterialsType::G0);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			// 15) Aligner -> LoadPort（restore）
			if (!rmd.armState[1]) {
			m_pActiveRobotTask = createTransferTask_restore(pAligner, pLoadPorts);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			// 16) LoadPort -> Aligner（受组数门限控制；统一 buddy/状态时序）
			if (blockLoadFromLP) { unlock(); continue; }

			for (int s = 0; s < 4; s++) {
			PortType pt = pLoadPorts[s]->getPortType();
			if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
			&& (pt == PortType::Loading \|\| pt == PortType::Both)
			&& pLoadPorts[s]->getPortStatus() == PORT_INUSE) {

			m_pActiveRobotTask = createTransferTask(pLoadPorts[s], pAligner, primaryType, secondaryType, 1, m_bJobMode);
			if (m_pActiveRobotTask != nullptr) {
			auto* pGlass = static_cast<CGlass*>(m_pActiveRobotTask->getContext());
			if (pGlass->getBuddy() != nullptr) {
			delete m_pActiveRobotTask; m_pActiveRobotTask = nullptr;
			continue;
			}

			// 统一：queue -> start -> setContext -> move queue→inProcess -> onPanelStart
			pGlass->queue();
			pGlass->start();
			pEFEM->setContext(pGlass);

			bool bMoved = glassFromQueueToInPorcess(pGlass);
			if (bMoved) {
			LOGI("<Master>Glass(%s)从等待列队到工艺列队转移成功.", pGlass->getID().c_str());
			}
			else {
			LOGE("<Master>Glass(%s)从等待列队到工艺列队转移失败.", pGlass->getID().c_str());
			}

			if (m_listener.onPanelStart) m_listener.onPanelStart(this, pGlass);
			goto BATCH_PORT_GET;
			}
			}
			}

			BATCH_PORT_GET:
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);

			unlock();
			continue;
			}


			// 千传模式调度逻辑
			else if (m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER) {
			// 检测判断robot状态
			RMDATA& rmd = pEFEM->getRobotMonitoringData();
			if (rmd.status != ROBOT_STATUS::Idle && rmd.status != ROBOT_STATUS::Run) {
			unlock();
			continue;
			}

			if (m_pActiveRobotTask != nullptr) {
			if (m_pActiveRobotTask->isPicked()) {
			m_pActiveRobotTask->place();
			}
			unlock();
			// 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
			// LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
			continue;
			}

			// Measurement -> LoadPort
			for (int p = 0; p < 4; p++) {
			if (p != m_nContinuousWorkingPort) continue;
			PortType pt = pLoadPorts[p]->getPortType();
			if ((m_nContinuousTransferStep == CTStep_Unknow \|\| m_nContinuousTransferStep == CTStep_BakeCooling_Measurement)
			&& !rmd.armState[0] && pLoadPorts[p]->isEnable()
			&& (pt == PortType::Unloading \|\| pt == PortType::Both)
			&& pLoadPorts[p]->getPortStatus() == PORT_INUSE) {
			for (int slot = 0; slot < SLOT_MAX; slot++) {
			if (slot != m_nContinuousWorkingSlot) continue;
			m_pActiveRobotTask = createTransferTask_continuous_transfer(pMeasurement,
			0, pLoadPorts[p], slot);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_Measurement_LoadPort;
			m_nContinuousTransferStep = CTStep_end;
			goto CT_PORT_PUT;
			}
			}
			}
			}

			CT_PORT_PUT:
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);


			// BakeCooling ->Measurement
			if ((m_nContinuousTransferStep == CTStep_Unknow \|\| m_nContinuousTransferStep == CTStep_BakeCooling_BakeCooling3)
			&& !rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask_continuous_transfer(pBakeCooling,
			3, pMeasurement, 0);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_BakeCooling_Measurement;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling -> Measurement)...");
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}


			// BakeCooling内部
			if ((m_nContinuousTransferStep == CTStep_Unknow \|\| m_nContinuousTransferStep == CTStep_BakeCooling_BakeCooling2)
			&& !rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask_continuous_transfer(pBakeCooling,
			2, pBakeCooling, 3);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_BakeCooling_BakeCooling3;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling-2 -> BakeCooling-3)...");
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}
			if ((m_nContinuousTransferStep == CTStep_Unknow \|\| m_nContinuousTransferStep == CTStep_BakeCooling_BakeCooling1)
			&& !rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask_continuous_transfer(pBakeCooling,
			1, pBakeCooling, 2);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_BakeCooling_BakeCooling2;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling-1 -> BakeCooling-2)...");
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}
			if ((m_nContinuousTransferStep == CTStep_Unknow \|\| m_nContinuousTransferStep == CTStep_VacuumBake_BakeCooling)
			&& !rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask_continuous_transfer(pBakeCooling,
			0, pBakeCooling, 1);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_BakeCooling_BakeCooling1;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling-0 -> BakeCooling-1)...");
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			// VacuumBake(G1) -> BakeCooling
			if ((m_nContinuousTransferStep == CTStep_Unknow \|\| m_nContinuousTransferStep == CTStep_VacuumBake_VacuumBake)
			&& !rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask_continuous_transfer(pVacuumBake,
			1, pBakeCooling, 0);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_VacuumBake_BakeCooling;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(VacuumBake(G1) -> BakeCooling)...");
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			// VacuumBake(G1) -> VacuumBake(G1)
			if ((m_nContinuousTransferStep == CTStep_Unknow \|\| m_nContinuousTransferStep == CTStep_Bonder2_VacuumBake)
			&& !rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask_continuous_transfer(pVacuumBake,
			0, pVacuumBake, 1);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_VacuumBake_VacuumBake;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(VacuumBake(G1-0) -> VacuumBake(G1-1))...");
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			// Bonder2 -> VacuumBake(G1)
			if ((m_nContinuousTransferStep == CTStep_Unknow \|\| m_nContinuousTransferStep == CTStep_Bonder1_Bonder2)
			&& !rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask_continuous_transfer(pBonder2,
			1, pVacuumBake, 0);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_Bonder2_VacuumBake;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Bonder2 -> VacuumBake(G1))...");
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			// Bonder1 -> Bonder2
			if ((m_nContinuousTransferStep == CTStep_Unknow \|\| m_nContinuousTransferStep == CTStep_Fliper_Bonder1)
			&& !rmd.armState[0] && !pBonder2->hasBondGlass()) {
			m_pActiveRobotTask = createTransferTask_continuous_transfer(pBonder1,
			1, pBonder2, 1);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_Bonder1_Bonder2;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Bonder1 -> Bonder2)...");
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			// Fliper(G2) -> Bonder1
			if ((m_nContinuousTransferStep == CTStep_Unknow \|\| m_nContinuousTransferStep == CTStep_Aligner_Fliper)
			&&!rmd.armState[0] && !pBonder1->hasBondGlass()) {
			m_pActiveRobotTask = createTransferTask_continuous_transfer(pFliper,
			0, pBonder1, 1);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_Fliper_Bonder1;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Fliper(G2) -> Bonder1)...");
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			// Aligner -> Fliper(G2)
			if ((m_nContinuousTransferStep == CTStep_Unknow \|\| m_nContinuousTransferStep == CTStep_LoadPort_Aligner)
			&& !rmd.armState[1]) {
			m_pActiveRobotTask = createTransferTask_continuous_transfer(pAligner,
			0, pFliper, 0);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_Aligner_Fliper;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Aligner -> Fliper(G2))...");
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			// LoadPort -> Aligner
			for (int p = 0; p < 4; p++) {
			PortType pt = pLoadPorts[p]->getPortType();
			if ((m_nContinuousTransferStep == CTStep_Unknow \|\| m_nContinuousTransferStep == CTStep_end)
			&& !rmd.armState[0] && pLoadPorts[p]->isEnable()
			&& (pt == PortType::Loading \|\| pt == PortType::Both)
			&& pLoadPorts[p]->getPortStatus() == PORT_INUSE) {
			for (int slot = 0; slot < SLOT_MAX; slot++) {
			m_pActiveRobotTask = createTransferTask_continuous_transfer(pLoadPorts[p],
			slot, pAligner, 0);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_LoadPort_Aligner;
			m_nContinuousWorkingPort = p;
			m_nContinuousWorkingSlot = slot;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(LoadPort -> Aligner)...");
			pEFEM->setContext(m_pActiveRobotTask->getContext());
			goto CT_PORT_GET;
			}
			}
			}
			}

			CT_PORT_GET:
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_begin;
			LOGI("<ContinuousTransfer>千传测试，开始第 %d 轮", m_nContinuousTransferCount + 1);
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);


			unlock();
			continue;
			}


			unlock();
			}

			@@ -518,6 +1231,16 @@

			unsigned CMaster::ReadBitsProc()
			{
			// 标志位清0复位
			{
			StationIdentifier station;
			station.nNetNo = 0;
			station.nStNo = 255;
			char szBuffer[528] = { 0 }; // 0x0, 0x1087
			m_cclink.WriteData(station, (long)DeviceType::B, 0, 528, (short*)szBuffer);
			}


			while (1) {
			// 待退出信号或时间到
			int nRet = ::WaitForSingleObject(m_hEventReadBitsThreadExit[0], 1000);
			@@ -525,12 +1248,11 @@
			break;
			}

			// 读标志位
			for (auto item : m_listEquipment) {
			if (item->getID() == EQ_ID_Bonder1 \|\|
			item->getID() == EQ_ID_Bonder2) {
			const StationIdentifier& station = item->getStation();
			MemoryBlock& block = item->getReadBitBlock();

			const StationIdentifier& station = item->getStation();
			MemoryBlock& block = item->getReadBitBlock();
			if (block.end > block.start) {
			int nRet = m_cclink.ReadData2(station, (DeviceType)block.type,
			block.start, block.size, block.buffer);
			if (0 == nRet) {
			@@ -576,23 +1298,37 @@
			m_listener.onEqVcrEventReport(this, p, p2);
			}
			};
			listener.onPreFethedOutJob = [&](void* pEquipment, CJobDataB* pJobDataB) -> BOOL {
			listener.onPreFethedOutJob = [&](void* pEquipment, int port, CJobDataB* pJobDataB) -> BOOL {
			CEquipment* p = (CEquipment*)pEquipment;

			// 可能要加这一句
			Sleep(750);

			// 取片，更新当前搬送任务
			BOOL bOk = FALSE;
			lock();
			if (m_pActiveRobotTask != nullptr) {
			LOGD("<CMaster>onPreFethedOutJob 0001.");
			if (m_pActiveRobotTask->getSrcPosition() == p->getID()) {
			LOGD("<CMaster>onPreFethedOutJob 0002.");
			CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getSrcSlot());
			if (pGlass != nullptr) {
			CJobDataB* pJobDataBSrc = pGlass->getJobDataB();
			if (pJobDataBSrc != nullptr
			&& pJobDataBSrc->getCassetteSequenceNo() == pJobDataB->getCassetteSequenceNo()
			&& pJobDataBSrc->getJobSequenceNo() == pJobDataB->getJobSequenceNo()) {
			LOGD("<CMaster>onPreFethedOutJob 0003.");
			CJobDataS* pJobDataS = pGlass->getJobDataS();
			if (pJobDataS != nullptr
			&& pJobDataS->getCassetteSequenceNo() == pJobDataB->getCassetteSequenceNo()
			&& pJobDataS->getJobSequenceNo() == pJobDataB->getJobSequenceNo()) {
			bOk = TRUE;
			LOGI("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
			LOGD("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
			}
			LOGD("<CMaster>onPreFethedOutJob 0004.");
			if (pJobDataS != nullptr) {
			LOGD("<CMaster>onPreFethedOutJob 0005. %d,%d,%d,%d",
			pJobDataS->getCassetteSequenceNo(),
			pJobDataB->getCassetteSequenceNo(),
			pJobDataS->getJobSequenceNo(),
			pJobDataB->getJobSequenceNo()
			);
			}
			}
			}
			@@ -609,31 +1345,51 @@
			return bOk;

			};
			listener.onPreStoredJob = [&](void* pEquipment, CJobDataB* pJobDataB, short& slot) -> BOOL {
			listener.onPreStoredJob = [&](void* pEquipment, int port, CJobDataB* pJobDataB, short& slot) -> BOOL {
			CEquipment* p = (CEquipment*)pEquipment;

			// 可能要加这一句
			Sleep(750);

			// 放片，更新当前搬送任务
			BOOL bOk = FALSE;
			lock();
			if (m_pActiveRobotTask != nullptr) {
			if (m_pActiveRobotTask->getTarPosition() == p->getID()) {
			// 是否已经进入手臂(即取片完成),进入下一步，放片
			if (m_pActiveRobotTask->isPicking() &&
			((m_pActiveRobotTask->getArmNo() == 1 && p->getID() == EQ_ID_ARM_TRAY1)
			\|\| (m_pActiveRobotTask->getArmNo() == 2 && p->getID() == EQ_ID_ARM_TRAY2))
			) {
			slot = 1;
			bOk = TRUE;
			}

			// 是否放片完成
			else if (m_pActiveRobotTask->isPlacing() &&
			m_pActiveRobotTask->getTarPosition() == p->getID()) {
			CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getTarSlot());
			if (pGlass == nullptr) {
			bOk = TRUE;
			slot = m_pActiveRobotTask->getTarSlot();
			LOGI("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
			LOGI("<CMaster>onPreStoredJob, 已校验数据一致性.");
			}
			}
			else if (p->getID() == EQ_ID_ARM_TRAY1 \|\| p->getID() == EQ_ID_ARM_TRAY2) {
			slot = 1;
			bOk = TRUE;

			// 是否回撤
			else if (m_pActiveRobotTask->isRestoring() &&
			m_pActiveRobotTask->getSrcPosition() == p->getID()) {
			CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getSrcSlot());
			if (pGlass == nullptr && m_pActiveRobotTask->getSrcSlot() == port) {
			bOk = TRUE;
			slot = m_pActiveRobotTask->getSrcSlot();
			LOGI("<CMaster>onPreStoredJob, 已校验数据一致性.");
			}
			}
			}
			unlock();

			if (!bOk) {
			LOGE("<CMaster>onPreFethedOutJob, 数据校验失败.");
			LOGE("<CMaster>onPreStoredJob, 数据校验失败.");
			}

			return bOk;
			@@ -650,34 +1406,189 @@
			if (code == EDCC_FETCHOUT_JOB) {
			lock();
			if (m_pActiveRobotTask != nullptr && m_pActiveRobotTask->getSrcPosition() == p->getID()) {
			m_pActiveRobotTask->fetchOut();
			LOGI("开始取片...");
			}
			unlock();
			}
			else if (code == EDCC_STORED_JOB) {
			lock();
			if (m_pActiveRobotTask != nullptr && m_pActiveRobotTask->getTarPosition() == p->getID()) {
			if (m_pActiveRobotTask != nullptr
			&& m_pActiveRobotTask->isPicking()
			&& ((m_pActiveRobotTask->getArmNo() == 1 && p->getID() == EQ_ID_ARM_TRAY1)
			\|\| (m_pActiveRobotTask->getArmNo() == 2 && p->getID() == EQ_ID_ARM_TRAY2))
			) {
			LOGI("取片完成.");
			m_pActiveRobotTask->fetchOut();
			m_pActiveRobotTask->picked();
			}

			else if (m_pActiveRobotTask != nullptr
			&& m_pActiveRobotTask->isPlacing()
			&& m_pActiveRobotTask->getTarPosition() == p->getID()) {
			m_pActiveRobotTask->stored();
			m_pActiveRobotTask->completed();

			if (m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER) {
			if (m_nContinuousTransferStep == CTStep_end) {
			m_nContinuousTransferCount++;
			LOGI("<ContinuousTransfer>千传测试，第 %d 轮结束", m_nContinuousTransferCount);
			if (m_listener.onCTRoundEnd != nullptr) {
			m_listener.onCTRoundEnd(this, m_nContinuousTransferCount);
			}
			}
			}

			LOGI("放片完成...");

			// 完成此条搬送任务，但要把数据和消息上抛应用层
			unlock();

			// 如果是搬送回从AOI搬送回Port, 则glass工艺完成
			if (m_pActiveRobotTask->getSrcPosition() == EQ_ID_MEASUREMENT) {
			CGlass* pGlass = (CGlass*)m_pActiveRobotTask->getContext();
			pGlass->complete();
			CGlass* pBuddy = pGlass->getBuddy();
			if (pBuddy != nullptr) pBuddy->complete();
			this->saveState();
			bool bMoved = glassFromInPorcessToComplete(pGlass);
			if (bMoved) {
			LOGI("<Master>Glass(%s)从工艺列队到完成列队转移成功.",
			pGlass->getID().c_str());
			}
			else {
			LOGE("<Master>Glass(%s)从工艺列队到完成列队转移失败.",
			pGlass->getID().c_str());
			}
			if (m_listener.onPanelEnd != nullptr) {
			m_listener.onPanelEnd(this, pGlass);
			}

			// 检查PJ是否已经完成
			CProcessJob* pJob = getGlassProcessJob((CGlass*)m_pActiveRobotTask->getContext());
			if (pJob != nullptr && checkAndUpdatePjComplete(pJob)) {
			this->saveState();
			LOGE("<Master>ProcessJob(%s)完成.",
			pJob->id().c_str());
			if (m_listener.onPjEnd != nullptr) {
			m_listener.onPjEnd(this, pJob);
			}

			// 检查CJ是否已经完成
			ASSERT(m_pControlJob);
			if (checkAndUpdateCjComplete(m_pControlJob)) {
			this->saveState();
			LOGE("<Master>ControlJob(%s)完成.",
			m_pControlJob->id().c_str());
			if (m_listener.onCjEnd != nullptr) {
			m_listener.onCjEnd(this, pJob);
			}
			}
			}
			}



			unlock();


			lock();
			if (m_listener.onRobotTaskEvent != nullptr) {
			m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, 0);
			m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_FINISH);
			}
			delete m_pActiveRobotTask;
			m_pActiveRobotTask = nullptr;
			}

			else if (m_pActiveRobotTask != nullptr
			&& m_pActiveRobotTask->isRestoring()
			&& m_pActiveRobotTask->getSrcPosition() == p->getID()) {
			m_pActiveRobotTask->stored();
			m_pActiveRobotTask->restored();
			LOGI("回撤完成...");
			// 完成此条搬送任务，但要把数据和消息上抛应用层
			unlock();


			lock();
			if (m_listener.onRobotTaskEvent != nullptr) {
			m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_RESTORE);
			}
			delete m_pActiveRobotTask;
			m_pActiveRobotTask = nullptr;
			stop();
			}
			unlock();
			}
			};
			listener.onProcessStateChanged = [&](void* pEquipment, PROCESS_STATE state) -> void {
			LOGI("<Master>onProcessStateChanged<%d>", (int)state);
			};
			listener.onMapMismatch = [&](void* pEquipment, short scanMap, short downMap) {
			LOGE("<Master-%s>Port InUse, map(%d!=%d)不一致，请检查。",
			((CEquipment*)pEquipment)->getName().c_str(), scanMap, downMap);
			};
			listener.onPortStatusChanged = [&](void* pEquipment, short status, __int64 data) {
			LOGE("<Master-%s>onPortStatusChanged。status=%d, data=%lld", ((CEquipment*)pEquipment)->getName().c_str(), status);
			if (status == PORT_INUSE && m_pControlJob != nullptr) {
			CLoadPort* pPort = (CLoadPort*)pEquipment;
			auto pjs = m_pControlJob->getPjs();
			for (auto pj : pjs) {
			auto carrier = pj->getCarrier(pPort->getCassetteId());
			if (carrier != nullptr) {
			for (auto slot : carrier->slots) {
			CGlass* pGlass = pPort->getGlassFromSlot(slot);
			carrier->contexts.push_back((void*)pGlass);
			if (pGlass != nullptr) {
			pGlass->setProcessJob(pj);
			}
			}
			}
			}


			}

			if (m_listener.onLoadPortStatusChanged != nullptr) {
			m_listener.onLoadPortStatusChanged(this, (CEquipment*)pEquipment, status, data);
			}
			};
			listener.onSVDataReport = [&](void* pEquipment, void* pData) {
			CSVData* pSVData = (CSVData*)pData;
			auto rawData = pSVData->getSVRawData();
			std::vector<CParam> params;
			((CEquipment)pEquipment)->parsingSVData((const char)rawData.data(), rawData.size(), params);

			std::string strOut;
			char szBuffer[256];
			for (auto p : params) {
			if (!strOut.empty()) strOut.append(",");
			if (p.getValueType() == PVT_INT) {
			sprintf_s(szBuffer, 256, "%s:%d", p.getName().c_str(), p.getIntValue());
			}
			else if (p.getValueType() == PVT_DOUBLE) {
			sprintf_s(szBuffer, 256, "%s:%f", p.getName().c_str(), p.getDoubleValue());
			}
			strOut.append(szBuffer);
			}
			LOGD("<CMaster-%s>SVDataReport:%s", ((CEquipment*)pEquipment)->getName().c_str(), strOut.c_str());
			};
			listener.onPanelDataReport = [&](void* pEquipment, void* pContext) {
			LOGD("<CMaster-%s>onPanelDataReport", ((CEquipment*)pEquipment)->getName().c_str());

			CEquipment* pEq = (CEquipment*)pEquipment;
			CGlass* pGlass = (CGlass*)pContext;

			// 如果AOI检测失败，要停机
			if (pEq->getID() == EQ_ID_MEASUREMENT) {
			LOGD("<CMaster-%s>onPanelDataReport 01", ((CEquipment*)pEquipment)->getName().c_str());
			if (pGlass->getAOIInspResult() == InspResult::Fail) {
			LOGD("<CMaster-%s>onPanelDataReport 02", ((CEquipment*)pEquipment)->getName().c_str());
			if (stop() == 0) {
			m_nLastError = ER_CODE_AOI_NG;
			m_strLastError = "AOI检测未通过.";
			}
			}
			}

			};
			pEquipment->setListener(listener);
			pEquipment->setCcLink(&m_cclink);
			m_listEquipment.push_back(pEquipment);
			@@ -691,6 +1602,15 @@
			}

			CEquipment* CMaster::getEquipment(int id)
			{
			for (auto item : m_listEquipment) {
			if (item->getID() == id) return item;
			}

			return nullptr;
			}

			CEquipment* CMaster::getEquipment(int id) const
			{
			for (auto item : m_listEquipment) {
			if (item->getID() == id) return item;
			@@ -715,6 +1635,7 @@
			pEquipment->setID(EQ_ID_LOADPORT1 + index);
			pEquipment->setName(szName);
			pEquipment->setDescription(szName);
			pEquipment->setCompareMapsBeforeProceeding(m_isCompareMapsBeforeProceeding);
			addToEquipmentList(pEquipment);


			@@ -732,7 +1653,7 @@
			pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
			pEquipment->setName("Fliper(G2)");
			pEquipment->setDescription("Fliper(G2).");
			pEquipment->setReadBitBlock(0x4000, 0x45ff);
			pEquipment->setReadBitBlock(0x0, 0x0);
			pEquipment->setStation(0, 255);
			addToEquipmentList(pEquipment);

			@@ -749,7 +1670,7 @@
			pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
			pEquipment->setName("VacuumBake(G1)");
			pEquipment->setDescription("VacuumBake(G1).");
			pEquipment->setReadBitBlock(0x4000, 0x45ff);
			pEquipment->setReadBitBlock(0x5c00, 0x66ff);
			pEquipment->setStation(0, 255);
			addToEquipmentList(pEquipment);

			@@ -767,7 +1688,7 @@
			pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
			pEquipment->setName("Aligner");
			pEquipment->setDescription("Aligner.");
			pEquipment->setReadBitBlock(0x4000, 0x45ff);
			pEquipment->setReadBitBlock(0x0, 0x0);
			pEquipment->setStation(0, 255);
			addToEquipmentList(pEquipment);

			@@ -860,7 +1781,7 @@
			pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
			pEquipment->setName("BakeCooling");
			pEquipment->setDescription("BakeCooling.");
			pEquipment->setReadBitBlock(0x4000, 0x45ff);
			pEquipment->setReadBitBlock(0x5100, 0x5bff);
			pEquipment->setStation(0, 255);
			addToEquipmentList(pEquipment);

			@@ -894,27 +1815,8 @@
			}


			// 按一定频率扫描LB数据
			static int i = 0;
			i++;
			/*
			if (i % (4 * 1) == 0) {

			for (auto item : m_listEquipment) {
			if (item->getID() == EQ_ID_Bonder1) {
			const StationIdentifier& station = item->getStation();
			MemoryBlock& block = item->getReadBitBlock();

			int nRet = m_cclink.ReadData2(station, (DeviceType)block.type,
			block.start, block.size, block.buffer);
			if (0 == nRet) {
			item->onReceiveLBData(block.buffer, block.size);
			}
			}
			}
			}
			*/


			// 自动保存缓存
			if (i % (4 * 2) == 0) {
			@@ -924,6 +1826,64 @@
			}
			}



			// 模拟测试
			/*
			static int aaa = 0;
			aaa++;
			if (aaa % 30 == 0) {
			if (!m_queueGlasses.empty()) {
			CGlass* pGlass = m_queueGlasses.front();
			pGlass->start();
			glassFromQueueToInPorcess(pGlass);
			this->saveState();

			// 这里上报Panel Start事件
			if (m_listener.onPanelStart != nullptr) {
			m_listener.onPanelStart(this, pGlass);
			}
			}
			}

			if (aaa % 45 == 0) {
			if (!m_inProcesGlasses.empty()) {
			CGlass* pGlass = m_inProcesGlasses.front();
			pGlass->complete();
			CGlass* pBuddy = pGlass->getBuddy();
			if (pBuddy != nullptr) pBuddy->complete();
			glassFromInPorcessToComplete(pGlass);
			this->saveState();

			// 这里上报Panel End事件
			if (m_listener.onPanelEnd != nullptr) {
			m_listener.onPanelEnd(this, pGlass);
			}

			CProcessJob* pJob = getGlassProcessJob(pGlass);
			if (pJob != nullptr && checkAndUpdatePjComplete(pJob)) {
			processJobFromInPorcessToComplete(pJob);
			this->saveState();
			LOGE("<Master>ProcessJob(%s)完成.",
			pJob->id().c_str());
			if (m_listener.onPjEnd != nullptr) {
			m_listener.onPjEnd(this, pJob);
			}

			// 检查CJ是否已经完成
			ASSERT(m_pControlJob);
			if (checkAndUpdateCjComplete(m_pControlJob)) {
			this->saveState();
			LOGE("<Master>ControlJob(%s)完成.",
			m_pControlJob->id().c_str());
			if (m_listener.onCjEnd != nullptr) {
			m_listener.onCjEnd(this, pJob);
			}
			}
			}
			}
			}
			*/
			}

			void CMaster::connectEquipments()
			@@ -941,42 +1901,40 @@
			CBakeCooling* pBakeCooling = (CBakeCooling*)getEquipment(EQ_ID_BAKE_COOLING);
			CMeasurement* pMeasurement = (CMeasurement*)getEquipment(EQ_ID_MEASUREMENT);

			nRet = pLoadPort1->getPin("Out1")->connectPin(pFliper->getPin("In1"));
			nRet = pLoadPort1->getPin("Out")->connectPin(pAligner->getPin("In1"));
			if (nRet < 0) {
			LOGE("连接LoadPort1-Fliper失败");
			}
			nRet = pLoadPort2->getPin("Out1")->connectPin(pFliper->getPin("In2"));
			nRet = pLoadPort2->getPin("Out")->connectPin(pAligner->getPin("In2"));
			if (nRet < 0) {
			LOGE("连接LoadPort1-Fliper失败");
			}

			nRet = pLoadPort1->getPin("Out2")->connectPin(pVacuumBake->getPin("In1"));
			nRet = pAligner->getPin("Out1")->connectPin(pFliper->getPin("In"));
			if (nRet < 0) {
			LOGE("连接LoadPort1-VacuumBake失败");
			LOGE("连接Aligner-Fliper失败");
			}
			nRet = pLoadPort2->getPin("Out2")->connectPin(pVacuumBake->getPin("In2"));
			nRet = pAligner->getPin("Out2")->connectPin(pVacuumBake->getPin("In"));
			if (nRet < 0) {
			LOGE("连接LoadPort1-VacuumBake失败");
			LOGE("连接Aligner-VacuumBake失败");
			}

			nRet = pFliper->getPin("Out")->connectPin(pAligner->getPin("In1"));
			nRet = pFliper->getPin("Out1")->connectPin(pBonder1->getPin("In1"));
			if (nRet < 0) {
			LOGE("连接Fliper-Aligner失败");
			LOGE("连接Fliper-Bonder1失败");
			}
			nRet = pFliper->getPin("Out2")->connectPin(pBonder2->getPin("In1"));
			if (nRet < 0) {
			LOGE("连接Fliper-Bonder2失败");
			}

			nRet = pVacuumBake->getPin("Out")->connectPin(pAligner->getPin("In2"));
			nRet = pVacuumBake->getPin("Out1")->connectPin(pBonder1->getPin("In2"));
			if (nRet < 0) {
			LOGE("连接VacuumBake-Aligner失败");
			LOGE("连接VacuumBake-Bonder1失败");
			}

			nRet = pAligner->getPin("Out1")->connectPin(pBonder1->getPin("In"));
			nRet = pVacuumBake->getPin("Out2")->connectPin(pBonder2->getPin("In2"));
			if (nRet < 0) {
			LOGE("连接Aligner-Bondere1失败");
			}

			nRet = pAligner->getPin("Out2")->connectPin(pBonder2->getPin("In"));
			if (nRet < 0) {
			LOGE("连接Aligner-Bondere2失败");
			LOGE("连接VacuumBake-Bonder2失败");
			}

			nRet = pBonder1->getPin("Out")->connectPin(pBakeCooling->getPin("In1"));
			@@ -1089,22 +2047,29 @@

			static int taskSeqNo = 0;
			CRobotTask* CMaster::createTransferTask(CEquipment* pSrcEq, CEquipment* pTarEq,
			MaterialsType primaryType/* = MaterialsType::G1/, MaterialsType secondaryType/ = MaterialsType::G2*/)
			MaterialsType primaryType/* = MaterialsType::G1/, MaterialsType secondaryType/ = MaterialsType::G2*/,
			int armNo/* = 1/, BOOL bJobMode/ = FALSE*/)
			{
			if (!pSrcEq->IsEnabled()) {
			return nullptr;
			}
			CRobotTask* pTask = nullptr;
			CSlot* pSrcSlot, * pTarSlot;
			pSrcEq->m_nTestFlag = m_nTestFlag;
			pTarSlot = pTarEq->getAvailableSlotForGlass(primaryType);
			pSrcSlot = pSrcEq->getProcessedSlot(primaryType);
			if (pSrcSlot == nullptr \|\| nullptr == pTarSlot) {
			pSrcSlot = pSrcEq->getProcessedSlot(primaryType, bJobMode);
			if (m_nTestFlag == 1) LOGD("createTransferTask 003 %x, %x", pTarSlot, pSrcSlot);
			if ((pSrcSlot == nullptr \|\| nullptr == pTarSlot) && secondaryType != SERVO::MaterialsType::G0) {
			pTarSlot = pTarEq->getAvailableSlotForGlass(secondaryType);
			pSrcSlot = pSrcEq->getProcessedSlot(secondaryType);
			pSrcSlot = pSrcEq->getProcessedSlot(secondaryType, bJobMode);
			}

			if (m_nTestFlag == 1) LOGD("createTransferTask 004 %x, %x", pTarSlot, pSrcSlot);

			if (pSrcSlot != nullptr && nullptr != pTarSlot) {
			pTask = new CRobotTask();
			pTask->setContext(pSrcSlot->getContext());
			pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
			pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
			taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, armNo, pSrcSlot->getPosition(),
			pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
			}

			@@ -1112,29 +2077,848 @@
			return pTask;
			}

			CRobotTask* CMaster::createTransferTask_bonder_to_bakecooling(CEquipment* pSrcEq, CEquipment* pTarEq,
			MaterialsType primaryType/* = MaterialsType::G1/, MaterialsType secondaryType/ = MaterialsType::G2*/)
			CRobotTask* CMaster::createTransferTask_bonder_to_bakecooling(CEquipment* pSrcEq, CEquipment* pTarEq)
			{
			std::vector<int> slots = {1, 2};
			if (!pSrcEq->IsEnabled()) {
			return nullptr;
			}

			std::vector<int> slots = {1, 3};

			CRobotTask* pTask = nullptr;
			CSlot* pSrcSlot, * pTarSlot;
			pTarSlot = pTarEq->getAvailableSlotForGlass2(primaryType, slots);
			pSrcSlot = pSrcEq->getProcessedSlot(primaryType);
			if (pSrcSlot == nullptr \|\| nullptr == pTarSlot) {
			pTarSlot = pTarEq->getAvailableSlotForGlass(secondaryType);
			pSrcSlot = pSrcEq->getProcessedSlot(secondaryType);
			pTarSlot = pTarEq->getAvailableSlotForGlass2(MaterialsType::G1, slots);
			pSrcSlot = pSrcEq->getProcessedSlot(MaterialsType::G1);

			if (pSrcSlot != nullptr && nullptr != pTarSlot) {
			pTask = new CRobotTask();
			pTask->setContext(pSrcSlot->getContext());
			pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
			taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, 1, pSrcSlot->getPosition(),
			pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
			}


			return pTask;
			}

			CRobotTask* CMaster::createTransferTask_bake_to_cooling(CEquipment* pSrcEq)
			{
			if (!pSrcEq->IsEnabled()) {
			return nullptr;
			}

			std::vector<int> slotsTar = { 2, 4 };
			std::vector<int> slotsSrc = { 1, 3 };

			CRobotTask* pTask = nullptr;
			CSlot* pSrcSlot, * pTarSlot;
			pTarSlot = pSrcEq->getAvailableSlotForGlass2(MaterialsType::G1, slotsTar);
			pSrcSlot = pSrcEq->getProcessedSlot2(MaterialsType::G1, slotsSrc);

			if (pSrcSlot != nullptr && nullptr != pTarSlot) {
			pTask = new CRobotTask();
			pTask->setContext(pSrcSlot->getContext());
			pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
			taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, 1, pSrcSlot->getPosition(),
			pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
			}


			return pTask;
			}

			CRobotTask* CMaster::createTransferTask_bakecooling_to_measurement(CEquipment* pSrcEq, CEquipment* pTarEq)
			{
			if (!pSrcEq->IsEnabled()) {
			return nullptr;
			}

			std::vector<int> slots = { 2, 4 };

			CRobotTask* pTask = nullptr;
			CSlot* pSrcSlot, * pTarSlot;
			pTarSlot = pTarEq->getAvailableSlotForGlass(MaterialsType::G1);
			pSrcSlot = pSrcEq->getProcessedSlot2(MaterialsType::G1, slots);

			if (pSrcSlot != nullptr && nullptr != pTarSlot) {
			pTask = new CRobotTask();
			pTask->setContext(pSrcSlot->getContext());
			pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
			taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, 1, pSrcSlot->getPosition(),
			pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
			}


			return pTask;
			}

			CRobotTask* CMaster::createTransferTask_restore(CEquipment* pEqSrc, CLoadPort** pPorts)
			{
			if (!pEqSrc->IsEnabled()) {
			return nullptr;
			}

			CRobotTask* pTask = nullptr;
			CSlot* pSrcSlot, * pTarSlot = nullptr, * pTempSlot;
			pSrcSlot = pEqSrc->getInspFailSlot();
			if (pSrcSlot != nullptr) {
			CGlass* pGlass = (CGlass*)pSrcSlot->getContext();
			ASSERT(pGlass);
			int port, slot;
			pGlass->getOrginPort(port, slot);
			pGlass->setInspResult(pPorts[port]->getID(), 0, InspResult::Fail);
			ASSERT(0 <= port && port < 4);
			ASSERT(0 <= slot && slot < 8);
			pTempSlot = pPorts[port]->getSlot(slot);
			if (pTempSlot->getContext() == nullptr) {
			pTarSlot = pTempSlot;
			}
			}


			if (pSrcSlot != nullptr && nullptr != pTarSlot) {
			pTask = new CRobotTask();
			pTask->setContext(pSrcSlot->getContext());
			pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
			pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
			taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, 1, pSrcSlot->getPosition(),
			pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
			}


			return pTask;
			}

			CRobotTask* CMaster::createTransferTask_continuous_transfer(CEquipment* pSrcEq, int nSrcSlot,
			CEquipment* pTarEq, int nTarSlot, int armNo/* = 1*/)
			{
			if (!pSrcEq->IsEnabled()) {
			return nullptr;
			}
			if (!pTarEq->IsEnabled()) {
			return nullptr;
			}

			CRobotTask* pTask = nullptr;
			CSlot* pSrcSlot = pSrcEq->getProcessedSlotCt(nSrcSlot);
			if (pSrcSlot != nullptr && pSrcEq->getID() == EQ_ID_MEASUREMENT
			&& (pTarEq->getID() == EQ_ID_LOADPORT1 \|\| pTarEq->getID() == EQ_ID_LOADPORT2 \|\| pTarEq->getID() == EQ_ID_LOADPORT3 \|\| pTarEq->getID() == EQ_ID_LOADPORT4)) {
			pTarEq->removeGlass(1);
			}
			CSlot* pTarSlot = pTarEq->isSlotAvailable(nTarSlot);
			if (pSrcSlot != nullptr && nullptr != pTarSlot) {
			pTask = new CRobotTask();
			pTask->setContext(pSrcSlot->getContext());
			pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
			taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, armNo, pSrcSlot->getPosition(),
			pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
			}


			return pTask;
			}

			int CMaster::abortCurrentTask()
			{
			lock();
			if (m_pActiveRobotTask != nullptr) {
			m_pActiveRobotTask->abort();
			}
			unlock();

			if (m_listener.onRobotTaskEvent != nullptr) {
			m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_ABORT);
			}

			lock();
			if (m_pActiveRobotTask != nullptr) {
			delete m_pActiveRobotTask;
			m_pActiveRobotTask = nullptr;
			}
			unlock();

			// 当前任务手动中止后，停止调度，需要操作员在解决问题后，重新启动
			// 25年7月23日后修改为不停止任务
			// stop();

			return 0;
			}

			int CMaster::restoreCurrentTask()
			{
			lock();
			if (m_pActiveRobotTask != nullptr) {
			m_pActiveRobotTask->restore();
			}
			unlock();


			return 0;
			}

			int CMaster::resendCurrentTask()
			{
			lock();
			if (m_pActiveRobotTask != nullptr) {
			m_pActiveRobotTask->resend();
			}
			unlock();


			return 0;
			}

			void CMaster::setPortType(unsigned int index, BOOL enable, int type, int mode,
			int cassetteType, int transferMode, BOOL autoChangeEnable)
			{
			ASSERT(index < 4);
			int eqid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4};
			CLoadPort* pPort = (CLoadPort*)getEquipment(eqid[index]);
			pPort->localEanblePort(enable);
			pPort->localSetPortType((SERVO::PortType)type);
			pPort->localSetPortMode((SERVO::PortMode)mode);
			pPort->localSetCessetteType((SERVO::CassetteType)cassetteType);
			pPort->localSetTransferMode((SERVO::TransferMode)transferMode);
			pPort->localAutoChangeEnable(autoChangeEnable);
			}

			void CMaster::setPortCassetteType(unsigned int index, SERVO::CassetteType type)
			{
			ASSERT(index < 4);
			int eqid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4 };
			CLoadPort* pPort = (CLoadPort*)getEquipment(eqid[index]);
			pPort->localSetCessetteType(type);
			}

			void CMaster::setPortEnable(unsigned int index, BOOL bEnable)
			{
			ASSERT(index < 4);
			int eqid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4 };
			CLoadPort* pPort = (CLoadPort*)getEquipment(eqid[index]);
			pPort->localEanblePort(bEnable);
			}

			int CMaster::getPortCassetteSnSeed(int port)
			{
			ASSERT(1 <= port && port <= 4);
			int eqid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4 };
			CLoadPort* pPort = (CLoadPort*)getEquipment(eqid[port - 1]);
			return pPort->getPortCassetteSnSeed();
			}

			void CMaster::setPortCassetteSnSeed(int port, int seed)
			{
			ASSERT(1 <= port && port <= 4);
			int eqid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4 };
			CLoadPort* pPort = (CLoadPort*)getEquipment(eqid[port - 1]);
			return pPort->setPortCassetteSnSeed(seed);
			}

			void CMaster::setCompareMapsBeforeProceeding(BOOL bCompare)
			{
			m_isCompareMapsBeforeProceeding = bCompare;
			}

			void CMaster::setJobMode(BOOL bJobMode)
			{
			m_bJobMode = bJobMode;
			}

			void CMaster::datetimeSync(SYSTEMTIME& time)
			{
			for (auto item : m_listEquipment) {
			item->setDateTime(time.wYear, time.wMonth, time.wDay,
			time.wHour, time.wMinute, time.wSecond);
			}
			}

			void CMaster::enableEventReport(bool bEnable)
			{
			m_bEnableEventReport = bEnable;
			}

			void CMaster::enableAlarmReport(bool bEnable)
			{
			m_bEnableAlarmReport = bEnable;
			}

			bool CMaster::isAlarmReportEnable()
			{
			return m_bEnableAlarmReport;
			}

			int CMaster::proceedWithCarrier(unsigned int port)
			{
			if (port >= 4) return -1;

			static int pid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4};
			CLoadPort* pPort = (CLoadPort*)getEquipment(pid[port]);
			pPort->sendCassetteCtrlCmd(CCC_PROCESS_START, nullptr, 0, 0, 0, nullptr, nullptr);
			return 0;
			}

			int CMaster::carrierRelease(unsigned int port)
			{
			if (port >= 4) return -1;

			static int pid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4 };
			CLoadPort* pPort = (CLoadPort*)getEquipment(pid[port]);
			pPort->sendCassetteCtrlCmd(CCC_PROCESS_CANCEL, nullptr, 0, 0, 0, nullptr, nullptr);
			return 0;
			}

			int CMaster::getContinuousTransferCount()
			{
			return m_nContinuousTransferCount;
			}

			void CMaster::setContinuousTransferCount(int round)
			{
			m_nContinuousTransferCount = round;
			}

			int CMaster::setProcessJobs(std::vector<CProcessJob*>& pjs)
			{
			std::vector<SERVO::CProcessJob*> temp;
			for (auto p : pjs) {
			if (p->validate(*this)) {
			p->queue();
			temp.push_back(p);
			}
			}
			m_processJobs = temp;


			// 更新context
			std::vector<uint8_t> newSlots;
			std::vector<void*> newContexts;
			for (auto pj : m_processJobs) {
			for (auto& c : pj->carriers()) {
			auto pPort = getPortWithCarrierId(c.carrierId);
			if (pPort == nullptr) continue;

			for (auto s : c.slots) {
			auto pGlass = pPort->getGlassFromSlot(s);
			if (pGlass == nullptr) continue;

			newSlots.push_back(s);
			newContexts.push_back(pGlass);
			}

			pj->setCarrierSlotsAndContexts(c.carrierId, newSlots, newContexts);
			}
			}



			this->saveState();

			return (int)m_processJobs.size();
			}

			std::vector<CProcessJob*>& CMaster::getProcessJobs()
			{
			return m_processJobs;
			}

			CProcessJob* CMaster::getProcessJob(const std::string& id)
			{
			for (auto item : m_processJobs) {
			if (item->id().compare(id) == 0) return item;
			}

			return nullptr;
			}

			int CMaster::setControlJob(CControlJob& controlJob)
			{
			// 回调：是否参创建ControlJob
			auto canCreateCjFn = [&](uint32_t& cc, std::string& mm) -> bool {
			if (m_pControlJob != nullptr) {
			cc = 1100;
			mm = "当前ControlJob未结批，不能创建新的ControlJob";
			return false;
			}
			return true;
			};


			// 回调：是否存在
			auto pjExists = [&](const std::string& id) -> bool {
			return getProcessJob(id) != nullptr;
			};

			// 回调：是否可加入 CJ（这里定义：必须是 Queued）
			auto pjJoinable = [&](const std::string& id) -> bool {
			auto pj = getProcessJob(id);
			if (pj == nullptr) return false;
			return pj->state() == PJState::Queued;
			};

			bool bRet = controlJob.validateForCreate(canCreateCjFn, pjExists, pjJoinable);
			if (!bRet) return -1;

			std::vector<CProcessJob*> temps;
			m_pControlJob = new CControlJob(controlJob);
			auto pjIds = controlJob.pjIds();
			for (auto id : pjIds) {
			auto pj = getProcessJob(id);
			if (pj != nullptr) {
			temps.push_back(pj);
			}
			}
			m_pControlJob->setPJs(temps);
			this->saveState();


			return 0;
			}

			CControlJob* CMaster::getControlJob()
			{
			return m_pControlJob;
			}

			CLoadPort* CMaster::getPortWithCarrierId(const std::string& carrierId) const
			{
			CLoadPort* pPort;
			int eqid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4};
			for (int i = 0; i < 4; i++) {
			pPort = (CLoadPort*)getEquipment(eqid[i]);
			ASSERT(pPort);
			if (pPort->getCassetteId().compare(carrierId) == 0) return pPort;
			}

			return nullptr;
			}

			bool CMaster::isProcessJobsEmpty() const
			{
			return m_processJobs.empty();
			}

			bool CMaster::recipeExists(const std::string& ppid) const
			{
			std::vector<std::string> vecRecipe = RecipeManager::getInstance().getAllPPID();
			bool exists = std::find(vecRecipe.begin(), vecRecipe.end(), ppid) != vecRecipe.end();
			return exists;
			}

			bool CMaster::carrierPresent(const std::string& carrierId) const
			{
			CLoadPort* pPort = getPortWithCarrierId(carrierId);
			return pPort != nullptr;
			}

			bool CMaster::slotUsable(const std::string& carrierId, uint16_t slot) const
			{
			CLoadPort* pPort = getPortWithCarrierId(carrierId);
			if(pPort == nullptr) return false;
			CSlot* pSlot = pPort->getSlot(slot);
			if (pSlot == nullptr) return false;
			return pSlot->isEnable();
			}

			bool CMaster::ceidDefined(uint32_t ceid) const
			{
			return true;
			}

			bool CMaster::saveState() const
			{
			std::ofstream ofs(m_strStatePath, std::ios::binary);
			if (!ofs) return false;

			// 文件头
			uint32_t magic = 0x4D415354; // 'MAST'
			uint16_t version = 1;
			ofs.write(reinterpret_cast<const char*>(&magic), sizeof(magic));
			ofs.write(reinterpret_cast<const char*>(&version), sizeof(version));

			// 保存 ControlJob
			bool hasCJ = (m_pControlJob != nullptr);
			ofs.write(reinterpret_cast<const char*>(&hasCJ), sizeof(hasCJ));
			if (hasCJ) {
			m_pControlJob->serialize(ofs);
			}

			// 保存 ProcessJob 列表
			uint32_t count = static_cast<uint32_t>(m_processJobs.size());
			ofs.write(reinterpret_cast<const char*>(&count), sizeof(count));
			for (const auto& job : m_processJobs) {
			job->serialize(ofs);
			}

			// 以后可以在这里追加新字段
			return true;
			}

			bool CMaster::loadState()
			{
			std::ifstream ifs(m_strStatePath, std::ios::binary);
			if (!ifs) return false;

			// 文件头
			uint32_t magic = 0;
			uint16_t version = 0;
			ifs.read(reinterpret_cast<char*>(&magic), sizeof(magic));
			ifs.read(reinterpret_cast<char*>(&version), sizeof(version));

			if (magic != 0x4D415354) {
			// 文件不合法
			return false;
			}

			if (m_pControlJob != nullptr) {
			delete m_pControlJob;
			m_pControlJob = nullptr;
			}

			// 读取 ControlJob
			bool hasCJ = false;
			ifs.read(reinterpret_cast<char*>(&hasCJ), sizeof(hasCJ));
			if (hasCJ) {
			m_pControlJob = new CControlJob();
			if (!CControlJob::deserialize(ifs, *m_pControlJob)) return false;
			}
			else {
			return false;
			}

			// 读取 ProcessJob 列表
			uint32_t count = 0;
			ifs.read(reinterpret_cast<char*>(&count), sizeof(count));
			m_processJobs.clear();
			for (uint32_t i = 0; i < count; i++) {
			CProcessJob* pProcessJob = new CProcessJob();
			if (!CProcessJob::deserialize(ifs, *pProcessJob)) return false;
			m_processJobs.push_back(pProcessJob);
			}


			// 找到CProcessJob指针加入列表中
			std::vector<CProcessJob*> tempPjs;
			auto ids = m_pControlJob->pjIds();
			for (auto id : ids) {
			auto pj = getProcessJob(id);
			if (pj != nullptr) {
			tempPjs.push_back(pj);
			}
			}
			m_pControlJob->setPJs(tempPjs);


			// 更新contexts
			auto pjs = m_pControlJob->getPjs();
			for (auto pj : pjs) {
			for (auto& c : pj->carriers()) {
			auto p = getPortWithCarrierId(c.carrierId);
			if (p == nullptr) continue;

			std::vector<void*> contexts;
			for (auto s : c.slots) {
			auto g = getGlass(p->getIndex(), s - 1);
			if (g == nullptr) continue;
			contexts.push_back(g);
			}
			pj->setCarrierContexts(c.carrierId, contexts);
			}
			}


			// 如果版本升级，可在这里判断 version 来加载新字段


			return true;
			}

			void CMaster::setStateFile(const std::string& path)
			{
			m_strStatePath = path;
			}

			CProcessJob* CMaster::acquireNextProcessJob()
			{
			auto& pjs = m_pControlJob->getPjs();
			for (const auto pj : pjs) {
			if (pj->state() == PJState::Queued) {
			pj->start();
			return pj;
			}
			}


			return nullptr;
			}

			CGlass* CMaster::acquireNextGlass()
			{
			for (auto* pj : m_inProcesJobs) {
			// 遍历 PJ 的 carriers 和 slots
			for (auto& cs : pj->carriers()) {
			for (auto ctx : cs.contexts) {
			CGlass* pGlass = (CGlass*)ctx;
			if (pGlass->state() == GlsState::NoState) {
			pGlass->queue();
			return pGlass;
			}
			}
			}
			}
			return nullptr; // 没有可加工的 Glass
			}

			int CMaster::acquireGlassToQueue()
			{
			int nCount = 0;
			for (auto* pj : m_inProcesJobs) {
			// 遍历 PJ 的 carriers 和 slots
			if (pj->carriers().empty()) continue;
			for (auto& cs : pj->carriers()) {
			for (auto ctx : cs.contexts) {
			CGlass* pGlass = (CGlass*)ctx;
			if (pGlass->state() == GlsState::NoState) {
			pGlass->queue();
			if(addGlassToQueue(pGlass)) nCount++;
			}
			}
			}
			}
			return nCount;
			}

			bool CMaster::addGlassToQueue(CGlass* pGlass)
			{
			for (auto g : m_queueGlasses) {
			if (g == pGlass) return false;
			}

			m_queueGlasses.push_back(pGlass);
			return true;
			}

			bool CMaster::glassFromQueueToInPorcess(CGlass* pGlass)
			{
			auto it = std::find(m_queueGlasses.begin(), m_queueGlasses.end(), pGlass);
			if (it != m_queueGlasses.end()) {
			m_inProcesGlasses.push_back(*it);
			m_queueGlasses.erase(it);
			return true;
			}
			return false;
			}

			bool CMaster::glassFromInPorcessToComplete(CGlass* pGlass)
			{
			auto it = std::find(m_inProcesGlasses.begin(), m_inProcesGlasses.end(), pGlass);
			if (it != m_inProcesGlasses.end()) {
			m_completeGlasses.push_back(*it);
			m_inProcesGlasses.erase(it);
			return true;
			}
			return false;
			}

			bool CMaster::processJobFromInPorcessToComplete(CProcessJob* pProcessJob)
			{
			auto it = std::find(m_inProcesJobs.begin(), m_inProcesJobs.end(), pProcessJob);
			if (it != m_inProcesJobs.end()) {
			m_completeProcessJobs.push_back(*it);
			m_inProcesJobs.erase(it);
			return true;
			}
			return false;
			}

			bool CMaster::checkAndUpdatePjComplete(CProcessJob* pJob)
			{
			ASSERT(pJob);
			auto state = pJob->state();
			if (state != PJState::InProcess && state != PJState::Paused) return false;

			for (auto c : pJob->carriers()) {
			for (auto g : c.contexts) {
			auto state = ((CGlass*)g)->state();
			if (state != GlsState::Aborted && state != GlsState::Completed
			&& state != GlsState::Failed) return false;
			}
			}

			return pJob->complete();
			}

			bool CMaster::checkAndUpdateCjComplete(CControlJob* pJob)
			{
			ASSERT(pJob);
			auto state = pJob->state();
			if (state != CJState::Executing && state != CJState::Paused) return false;

			for (auto pj : pJob->getPjs()) {
			auto state = pj->state();
			if (state != PJState::Aborted && state != PJState::Completed
			&& state != PJState::Failed) {
			return false;
			}
			}

			return pJob->complete();
			}

			CProcessJob* CMaster::getGlassProcessJob(CGlass* pGlass)
			{
			if (m_pControlJob == nullptr) return nullptr;
			for (auto pj : m_pControlJob->getPjs()) {
			for (auto c : pj->carriers()) {
			for (auto g : c.contexts) {
			if (g == pGlass) return pj;
			}
			}
			}

			return nullptr;
			}


			bool CMaster::completeControlJob(std::string description)
			{
			if (m_pControlJob == nullptr \|\| m_state != SERVO::MASTERSTATE::READY) {
			return false;
			}
			for (auto item : m_processJobs) {
			item->abort(description);
			}
			m_pControlJob->abort(description);


			// 释放Job相关
			for (auto item : m_processJobs) {
			delete item;
			}
			m_processJobs.clear();
			if (m_pControlJob != nullptr) {
			delete m_pControlJob;
			m_pControlJob = nullptr;
			}

			// 注意要释放引用
			m_inProcesJobs.clear();
			m_completeProcessJobs.clear();
			m_queueGlasses.clear();
			m_inProcesGlasses.clear();
			m_completeGlasses.clear();


			saveState();

			return true;
			}

			bool CMaster::canCreateControlJob()
			{
			return m_pControlJob == nullptr;
			}

			bool CMaster::canCompleteControlJob()
			{
			return m_pControlJob != nullptr && m_state == SERVO::MASTERSTATE::READY;
			}

			bool CMaster::canDeleteControlJob()
			{
			return m_pControlJob != nullptr
			&& m_pControlJob->state() == CJState::NoState
			&& m_state == SERVO::MASTERSTATE::READY;
			}

			int CMaster::getWipGlasses(std::vector<CGlass*>& glasses)
			{
			for (auto eq : m_listEquipment) {
			auto p = dynamic_cast<CLoadPort*>(eq);
			if (p == nullptr) {
			eq->getAllGlass(glasses);
			}

			}

			return (int)glasses.size();
			}

			int CMaster::getLastError()
			{
			return m_nLastError;
			}

			std::string& CMaster::getLastErrorText()
			{
			return m_strLastError;
			}

			void CMaster::test()
			{
			if (stop() == 0) {
			m_nLastError = ER_CODE_AOI_NG;
			m_strLastError = "AOI检测未通过.";
			}
			}

			bool CMaster::moveGlassToBuf(int eqid, int slotNo)
			{
			CEquipment* pEquipment = getEquipment(eqid);
			if (pEquipment == nullptr) return false;

			CSlot* pSlot = pEquipment->getSlotWithNo(slotNo);
			if (pSlot == nullptr) return false;

			CGlass* pGlass = (CGlass*)pSlot->getContext();
			m_bufGlass.push_back(pGlass);
			pGlass->addRef();
			pSlot->setContext(nullptr);

			m_bDataModify = TRUE;
			if (m_listener.onEqDataChanged != nullptr) {
			m_listener.onEqDataChanged(this, pEquipment, 0);
			}

			return true;
			}

			bool CMaster::moveGlassToSlot(int eqid, int slotNo)
			{
			CEquipment* pEquipment = getEquipment(eqid);
			if (pEquipment == nullptr) return false;

			CSlot* pSlot = pEquipment->getSlotWithNo(slotNo);
			if (pSlot == nullptr) return false;
			if (m_bufGlass.empty()) return false;

			CGlass* pGlass = m_bufGlass.front();
			m_bufGlass.pop_front();
			if (pGlass == nullptr) return false;
			pSlot->setContext(pGlass);
			pGlass->release();

			m_bDataModify = TRUE;
			if (m_listener.onEqDataChanged != nullptr) {
			m_listener.onEqDataChanged(this, pEquipment, 0);
			}

			return true;
			}

			CGlass* CMaster::getGlass(int scrPort, int scrSlot)
			{
			for (auto eq : m_listEquipment) {
			std::vector<CGlass*> glasses;
			eq->getAllGlass(glasses);
			for (auto g : glasses) {
			int p, s;
			g->getOrginPort(p, s);
			if (p == scrPort && s == scrSlot) {
			return g;
			}
			}
			}

			return nullptr;
			}
			}