~chenluhua/Bond2.git

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


			#define ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(name,ws,index,psd) { \
			CEqCassetteTransferStateStep* pStep = new CEqCassetteTransferStateStep(); \
			pStep->setName(name); \
			pStep->setWriteSignalDev(ws); \
			pStep->setPortStatusDev(psd); \
			if (pEquipment->addStep(index, pStep) != 0) { \
			delete pStep; \
			} \
			}

			namespace SERVO {
			CMaster* g_pMaster = NULL;

			unsigned __stdcall DispatchThreadFunction(LPVOID lpParam)
			{
			if (g_pMaster != NULL) {
			return g_pMaster->DispatchProc();
			}

			return 0;
			}

			unsigned __stdcall ReadBitsThreadFunction(LPVOID lpParam)
			{
			@@ -34,20 +38,45 @@

			CMaster::CMaster()
			{
			m_listener = {nullptr, nullptr, nullptr, nullptr};
			m_listener = {};
			m_bDataModify = FALSE;
			m_hEventReadBitsThreadExit[0] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
			m_hEventReadBitsThreadExit[1] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
			m_hReadBitsThreadHandle = nullptr;
			m_nReadBitsThreadAddr = 0;
			m_hDispatchEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
			m_hEventDispatchThreadExit[0] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
			m_hEventDispatchThreadExit[1] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
			m_hDispatchThreadHandle = nullptr;
			m_nDispatchThreadAddr = 0;
			m_ullStartTime = 0;
			m_ullRunTime = 0;
			m_state = MASTERSTATE::READY;
			m_pActiveRobotTask = nullptr;
			m_nLastError = 0;
			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_pControlJob = nullptr;
			InitializeCriticalSection(&m_criticalSection);
			}

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

			if (m_hEventReadBitsThreadExit[0] != nullptr) {
			::CloseHandle(m_hEventReadBitsThreadExit[0]);
			@@ -58,14 +87,33 @@
			::CloseHandle(m_hEventReadBitsThreadExit[1]);
			m_hEventReadBitsThreadExit[1] = nullptr;
			}

			if (m_hDispatchEvent != nullptr) {
			::CloseHandle(m_hDispatchEvent);
			m_hDispatchEvent = nullptr;
			}

			if (m_hEventDispatchThreadExit[0] != nullptr) {
			::CloseHandle(m_hEventDispatchThreadExit[0]);
			m_hEventDispatchThreadExit[0] = nullptr;
			}

			if (m_hEventDispatchThreadExit[1] != nullptr) {
			::CloseHandle(m_hEventDispatchThreadExit[1]);
			m_hEventDispatchThreadExit[1] = nullptr;
			}

			DeleteCriticalSection(&m_criticalSection);
			}

			void CMaster::setListener(MasterListener listener)
			{
			m_listener.onEqAlive = listener.onEqAlive;
			m_listener.onEqCimStateChanged = listener.onEqCimStateChanged;
			m_listener.onEqAlarm = listener.onEqAlarm;
			m_listener.onEqVcrEventReport = listener.onEqVcrEventReport;
			m_listener = listener;
			}

			CRobotTask* CMaster::getActiveRobotTask()
			{
			return m_pActiveRobotTask;
			}

			int CMaster::init()
			@@ -100,18 +148,68 @@


			// 初始化添加各子设备
			addLoadPort(0);
			addLoadPort(1);
			addLoadPort(2);
			addLoadPort(3);
			addFliper();
			addVacuumBake();
			addAligner();
			addEFEM();
			addBonder(0);
			addBonder(1);
			addBakeCooling();
			CLoadPort* pPort1, * pPort2, * pPort3, * pPort4;
			CBonder* pBonder1, * pBonder2;
			CEFEM* pEfem;
			CArm* pArm;
			CArmTray* pArmTray1, * pArmTray2;
			CFliper* pFliper;
			CVacuumBake* pVacuumBake;
			CAligner* pAligner;
			CBakeCooling* pBakeCooling;
			CMeasurement* pMeasurement;

			pPort1 = addLoadPort(0);
			pPort2 = addLoadPort(1);
			pPort3 = addLoadPort(2);
			pPort4 = addLoadPort(3);
			pEfem = addEFEM();
			pArm = addArm();
			pArmTray1 = addArmTray(0);
			pArmTray2 = addArmTray(1);
			pFliper = addFliper();
			pVacuumBake = addVacuumBake();
			pAligner = addAligner();
			pBonder1 = addBonder(0);
			pBonder2 = addBonder(1);
			pBakeCooling = addBakeCooling();
			pMeasurement = addMeasurement();

			ASSERT(pEfem);
			ASSERT(pFliper);
			ASSERT(pVacuumBake);
			ASSERT(pAligner);
			ASSERT(pBonder1);
			ASSERT(pBonder2);
			ASSERT(pBakeCooling);
			ASSERT(pMeasurement);

			pEfem->setPort(0, pPort1);
			pEfem->setPort(1, pPort2);
			pEfem->setPort(2, pPort3);
			pEfem->setPort(3, pPort4);
			pEfem->setFliper(pFliper);
			pEfem->setAligner(pAligner);
			pEfem->setArmTray(0, pArmTray1);
			pEfem->setArmTray(1, pArmTray2);
			pPort1->setArm(pArm);
			pPort2->setArm(pArm);
			pPort3->setArm(pArm);
			pPort4->setArm(pArm);
			pArmTray1->setArm(pArm);
			pArmTray2->setArm(pArm);
			pFliper->setArm(pArm);
			pVacuumBake->setArm(pArm);
			pAligner->setArm(pArm);
			pBonder1->setArm(pArm);
			pBonder2->setArm(pArm);
			pBakeCooling->setArm(pArm);
			pMeasurement->setArm(pArm);

			connectEquipments();





			// 读缓存数据
			@@ -123,6 +221,12 @@
			SetTimer(NULL, 1, 250, (TIMERPROC)MasterTimerProc);


			// 调度线程
			m_hDispatchThreadHandle = (HANDLE)_beginthreadex(NULL, 0, SERVO::DispatchThreadFunction, this,
			0, &m_nDispatchThreadAddr);


			// 监控bit线程
			m_hReadBitsThreadHandle = (HANDLE)_beginthreadex(NULL, 0, SERVO::ReadBitsThreadFunction, this,
			0, &m_nReadBitsThreadAddr);

			@@ -134,7 +238,9 @@
			int CMaster::term()
			{
			SetEvent(m_hEventReadBitsThreadExit[0]);
			SetEvent(m_hEventDispatchThreadExit[0]);
			::WaitForSingleObject(m_hEventReadBitsThreadExit[1], INFINITE);
			::WaitForSingleObject(m_hEventDispatchThreadExit[1], INFINITE);

			LOGI("<Master>正在结束程序.");
			for (auto item : m_listEquipment) {
			@@ -142,13 +248,938 @@
			}
			saveCache();

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

			for (auto item : m_listEquipment) {
			delete item;
			}
			m_listEquipment.clear();


			return 0;
			}

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

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

			return 0;
			}

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

			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()
			{
			// 运行时间为累加结果，本次停止时刷新；
			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();


			// 更新状态
			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 \|\| m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER
			\|\| m_state == MASTERSTATE::RUNNING_BATCH)
			return m_ullRunTime + (GetTickCount64() - m_ullStartTime);
			else
			return m_ullRunTime;
			}

			MASTERSTATE CMaster::getState()
			{
			return m_state;
			}

			unsigned CMaster::DispatchProc()
			{
			// 优先考虑的类型和次要类型
			// 一种情况，如果不分主次，一直搬G1, 等到Bonder1和Bonder2都放了G1, Aligner也放了G1,
			// Bonder1和Bonder2需要的G2就过不来了
			// 最基本的实现，可以G2和G2轮流搬送，但最好根据Bonder的需求来决定
			MaterialsType primaryType, secondaryType;


			// 各种机器
			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* 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(pEFEM);
			ASSERT(pLoadPorts[0]);
			ASSERT(pLoadPorts[1]);
			ASSERT(pLoadPorts[2]);
			ASSERT(pLoadPorts[3]);
			ASSERT(pFliper);
			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, 500);
			if (nRet == WAIT_OBJECT_0) {
			break;
			}


			// 如果状态为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) {
			LOGI("<Master>EFEM切换Start状态失败");
			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) {
			LOGI("<Master>Bonder1切换Start状态失败");
			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) {
			LOGI("<Master>Bonder2切换Start状态失败");
			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) {
			LOGI("<Master>BakeCooling切换Start状态失败");
			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) {
			LOGI("<Master>VacuumBake切换Start状态失败");
			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) {
			LOGI("<Master>Measurement切换Start状态失败");
			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;
			LOGI("<Master>%s切换Start状态失败", pEq[i]->getName().c_str());
			}
			}

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

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

			continue;
			}


			// 处理完成当前事务后，切换到停止或就绪状态
			else if (m_state == MASTERSTATE::STOPPING) {
			unlock();
			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) {
			LOGI("<Master>%s切换Stop状态发送失败", pEq[i]->getName().c_str());
			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;
			LOGI("<Master>%s切换Stop状态失败", pEq[i]->getName().c_str());
			}
			}

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

			LOGI("<Master>所有设备成功切换到 Stop 模式");
			setState(MASTERSTATE::READY);
			continue;
			}


			// 调度逻辑处理
			else if (m_state == MASTERSTATE::RUNNING) {
			// 检测判断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;
			}


			// 此处检测优先类型和次要类型（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;
			}
			}
			else if ((pBonder1->canPlaceGlassInSlot(0) && !pBonder1->canPlaceGlassInSlot(1))
			\|\| (pBonder2->canPlaceGlassInSlot(0) && !pBonder2->canPlaceGlassInSlot(1))) {
			primaryType = MaterialsType::G2;
			secondaryType = MaterialsType::G1;
			}


			// Measurement -> LoadPort
			if (rmd.armState[0] \|\| rmd.armState[1]) {
			LOGI("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], primaryType, secondaryType);
			if (m_pActiveRobotTask != nullptr) {
			goto PORT_PUT;
			}
			}
			}

			PORT_PUT:
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);


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


			// 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
			auto pSrcSlot = pVacuumBake->getProcessedSlot(primaryType);
			if (pSrcSlot != nullptr && !rmd.armState[1] && !pBonder1->hasBondClass()) {
			m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, primaryType, secondaryType, 2);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}
			if (pSrcSlot != nullptr && !rmd.armState[1] && !pBonder2->hasBondClass()) {
			m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, primaryType, secondaryType, 2);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}


			// VacuumBake(G1) -> Bonder
			if (!rmd.armState[0] && !pBonder1->hasBondClass()) {
			m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder1, primaryType, secondaryType);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			if (!rmd.armState[0] && !pBonder2->hasBondClass()) {
			m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder2, primaryType, secondaryType);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}


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

			if (!rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, primaryType, secondaryType);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}


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


			// LoadPort -> Aligner
			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) {
			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) {
			// 首选检查有没有CControlJob, 状态等
			if (m_pControlJob == nullptr) {
			unlock();
			continue;
			}
			CJState state = m_pControlJob->state();
			if (state == CJState::Completed \|\| state == CJState::Aborted \|\| state == CJState::Failed) {
			// ConrolJpb已完成
			LOGI("<Master>ControlJob已经完成或失败中断");
			unlock();
			continue;
			}


			if (m_pControlJob->state() == CJState::NoState) {
			LOGI("<Master>ControlJob已经进入列队");
			m_pControlJob->queue();
			}
			if (m_pControlJob->state() == CJState::Queued) {
			LOGI("<Master>ControlJob已经启动");
			m_pControlJob->start();
			}
			if (m_pControlJob->state() == CJState::Paused) {
			LOGI("<Master>ControlJob已经恢复运行");
			m_pControlJob->resume();
			}


			// 如果当前未选择CProcessJob, 选择一个
			if (m_inProcesJobs.empty()) {
			auto pj = acquireNextProcessJob();
			if (pj != nullptr) {
			m_inProcesJobs.push_back(pj);

			// 这里上报PJ Start事件
			if (m_listener.onPjStart != nullptr) {
			m_listener.onPjStart(this, pj);
			}
			}
			}
			if (m_inProcesJobs.empty()) {
			LOGI("<Master>选择当前ProcessJob失败！");
			unlock();
			continue;
			}

			// 如果当前没有Glass, 选择
			if (m_queueGlasses.empty()) {
			int nCount = acquireGlassToQueue();
			LOGI("<Master>已加入 %d 块Glass到工艺列队！", nCount);
			}


			// 检测判断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;
			}


			// 此处检测优先类型和次要类型（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;
			}
			}
			else if ((pBonder1->canPlaceGlassInSlot(0) && !pBonder1->canPlaceGlassInSlot(1))
			\|\| (pBonder2->canPlaceGlassInSlot(0) && !pBonder2->canPlaceGlassInSlot(1))) {
			primaryType = MaterialsType::G2;
			secondaryType = MaterialsType::G1;
			}


			// Measurement -> LoadPort
			if (rmd.armState[0] \|\| rmd.armState[1]) {
			LOGI("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], primaryType, secondaryType);
			if (m_pActiveRobotTask != nullptr) {
			goto BATCH_PORT_PUT;
			}
			}
			}

			BATCH_PORT_PUT:
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);


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


			// 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
			auto pSrcSlot = pVacuumBake->getProcessedSlot(primaryType);
			if (pSrcSlot != nullptr && !rmd.armState[1] && !pBonder1->hasBondClass()) {
			m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, primaryType, secondaryType, 2);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}
			if (pSrcSlot != nullptr && !rmd.armState[1] && !pBonder2->hasBondClass()) {
			m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, primaryType, secondaryType, 2);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}


			// VacuumBake(G1) -> Bonder
			if (!rmd.armState[0] && !pBonder1->hasBondClass()) {
			m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder1, primaryType, secondaryType);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}

			if (!rmd.armState[0] && !pBonder2->hasBondClass()) {
			m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder2, primaryType, secondaryType);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}


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

			if (!rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, primaryType, secondaryType);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}


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


			// LoadPort -> Aligner
			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, m_bJobMode);
			if (m_pActiveRobotTask != nullptr) {
			CGlass* pGlass = (CGlass*)m_pActiveRobotTask->getContext();
			pEFEM->setContext(pGlass);
			pGlass->start();
			bool bMoved = glassFromQueueToInPorcess(pGlass);
			if (bMoved) {
			LOGI("<Master>Glass(%s)从等待列队到工艺列队转移成功.",
			pGlass->getID().c_str());
			}
			else {
			LOGE("<Master>Glass(%s)从等待列队到工艺列队转移失败.",
			pGlass->getID().c_str());
			}

			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 s = 0; s < 4; s++) {
			PortType pt = pLoadPorts[s]->getPortType();
			if ((m_nContinuousTransferStep == CTStep_Unknow \|\| m_nContinuousTransferStep == CTStep_BakeCooling_Measurement)
			&& !rmd.armState[0] && pLoadPorts[s]->isEnable()
			&& (pt == PortType::Unloading \|\| pt == PortType::Both)
			&& pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
			for (int slot = 0; slot < SLOT_MAX; slot++) {
			m_pActiveRobotTask = createTransferTask_continuous_transfer(pMeasurement,
			0, pLoadPorts[s], 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->hasBondClass()) {
			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->hasBondClass()) {
			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 s = 0; s < 4; s++) {
			PortType pt = pLoadPorts[s]->getPortType();
			if ((m_nContinuousTransferStep == CTStep_Unknow \|\| m_nContinuousTransferStep == CTStep_end)
			&& !rmd.armState[0] && pLoadPorts[s]->isEnable()
			&& (pt == PortType::Loading \|\| pt == PortType::Both)
			&& pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
			for (int slot = 0; slot < SLOT_MAX; slot++) {
			m_pActiveRobotTask = createTransferTask_continuous_transfer(pLoadPorts[s],
			slot, pAligner, 0);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_LoadPort_Aligner;
			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();
			}

			SetEvent(m_hEventDispatchThreadExit[1]);


			// _endthreadex(0);
			TRACE("CMaster::DispatchProc 线程退出\n");
			return 0;
			}

			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);
			@@ -156,12 +1187,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) {
			@@ -207,10 +1237,240 @@
			m_listener.onEqVcrEventReport(this, p, p2);
			}
			};
			listener.onPreFethedOutJob = [&](void* pEquipment, int port, CJobDataB* pJobDataB) -> BOOL {
			CEquipment* p = (CEquipment*)pEquipment;

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

			// 取片，更新当前搬送任务
			BOOL bOk = FALSE;
			lock();
			if (m_pActiveRobotTask != nullptr) {
			LOGI("<CMaster>onPreFethedOutJob 0001.");
			if (m_pActiveRobotTask->getSrcPosition() == p->getID()) {
			LOGI("<CMaster>onPreFethedOutJob 0002.");
			CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getSrcSlot());
			if (pGlass != nullptr) {
			LOGI("<CMaster>onPreFethedOutJob 0003.");
			CJobDataS* pJobDataS = pGlass->getJobDataS();
			if (pJobDataS != nullptr
			&& pJobDataS->getCassetteSequenceNo() == pJobDataB->getCassetteSequenceNo()
			&& pJobDataS->getJobSequenceNo() == pJobDataB->getJobSequenceNo()) {
			bOk = TRUE;
			LOGI("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
			}
			LOGI("<CMaster>onPreFethedOutJob 0004.");
			if (pJobDataS != nullptr) {
			LOGI("<CMaster>onPreFethedOutJob 0005. %d,%d,%d,%d",
			pJobDataS->getCassetteSequenceNo(),
			pJobDataB->getCassetteSequenceNo(),
			pJobDataS->getJobSequenceNo(),
			pJobDataB->getJobSequenceNo()
			);
			}
			}
			}
			else if (p->getID() == EQ_ID_ARM_TRAY1 \|\| p->getID() == EQ_ID_ARM_TRAY2) {
			bOk = TRUE;
			}
			}
			unlock();

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

			return bOk;

			};
			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->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, 已校验数据一致性.");
			}
			}

			// 是否回撤
			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>onPreFethedOutJob, 已校验数据一致性.");
			}
			}
			}
			unlock();

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

			return bOk;

			};
			listener.onDataChanged = [&](void* pEquipment, int code) -> void {
			m_bDataModify = TRUE;
			};
			CEquipment* p = (CEquipment*)pEquipment;
			if (m_listener.onEqDataChanged != nullptr) {
			m_listener.onEqDataChanged(this, p, 0);
			}

			// 取放片，更新当前搬送任务
			if (code == EDCC_FETCHOUT_JOB) {
			lock();
			if (m_pActiveRobotTask != nullptr && m_pActiveRobotTask->getSrcPosition() == p->getID()) {
			LOGI("开始取片...");
			}
			unlock();
			}
			else if (code == EDCC_STORED_JOB) {
			lock();
			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("放片完成...");
			// 完成此条搬送任务，但要把数据和消息上抛应用层

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

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



			unlock();


			lock();
			if (m_listener.onRobotTaskEvent != nullptr) {
			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);
			}
			};
			pEquipment->setListener(listener);
			pEquipment->setCcLink(&m_cclink);
			m_listEquipment.push_back(pEquipment);
			@@ -232,103 +1492,96 @@
			return nullptr;
			}

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

			return nullptr;
			}

			/*
			* 添加LoadPort1
			* index -- 0~3
			*/
			int CMaster::addLoadPort(int index)
			CLoadPort* CMaster::addLoadPort(int index)
			{
			ASSERT(index == 0 \|\| index == 1 \|\| index == 2 \|\| index == 3);
			static char* pszCassetteCtrlCmd[] = {
			STEP_EQ_P1_CASSETTE_CTRL_CMD,
			STEP_EQ_P2_CASSETTE_CTRL_CMD,
			STEP_EQ_P3_CASSETTE_CTRL_CMD,
			STEP_EQ_P4_CASSETTE_CTRL_CMD
			};
			int nWriteSignalDev[] = {0x120, 0x121, 0x122, 0x123};
			int nCtrlCmdDev[] = {0x45, 0x1a5, 0x305, 0x465};
			int nStepDev[] = { 0x480, 0x481, 0x482, 0x483 };


			char szName[64];
			sprintf_s(szName, 64, "LoadPort %d", index + 1);
			CLoadPort* pEquipment = new CLoadPort();
			pEquipment->setIndex(index);
			pEquipment->setID(EQ_ID_LOADPORT1 + index);
			pEquipment->setName(szName);
			pEquipment->setDescription(szName);
			pEquipment->setCompareMapsBeforeProceeding(m_isCompareMapsBeforeProceeding);
			addToEquipmentList(pEquipment);


			// step
			{
			CEqCassetteCtrlCmdStep* pStep = new CEqCassetteCtrlCmdStep();
			pStep->setName(pszCassetteCtrlCmd[index]);
			pStep->setWriteSignalDev(nWriteSignalDev[index]);
			pStep->setCtrlCmdDev(nCtrlCmdDev[index]);
			if (pEquipment->addStep(nStepDev[index], pStep) != 0) {
			delete pStep;
			}
			}


			pEquipment->init();
			LOGE("已添加“%s”.", pEquipment->getName().c_str());


			return 0;
			return pEquipment;
			}

			int CMaster::addFliper()
			CFliper* CMaster::addFliper()
			{
			CFliper* pEquipment = new CFliper();
			pEquipment->setID(EQ_ID_FLIPER);
			pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
			pEquipment->setName("Fliper");
			pEquipment->setDescription("Fliper.");
			pEquipment->setReadBitBlock(0x4000, 0x45ff);
			pEquipment->setName("Fliper(G2)");
			pEquipment->setDescription("Fliper(G2).");
			pEquipment->setReadBitBlock(0x0, 0x0);
			pEquipment->setStation(0, 255);
			addToEquipmentList(pEquipment);


			pEquipment->init();
			LOGE("已添加“Fliper”.");
			return 0;
			return pEquipment;
			}

			int CMaster::addVacuumBake()
			CVacuumBake* CMaster::addVacuumBake()
			{
			CVacuumBake* pEquipment = new CVacuumBake();
			pEquipment->setID(EQ_ID_VACUUMBAKE);
			pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
			pEquipment->setName("VacuumBake");
			pEquipment->setDescription("VacuumBake.");
			pEquipment->setReadBitBlock(0x4000, 0x45ff);
			pEquipment->setName("VacuumBake(G1)");
			pEquipment->setDescription("VacuumBake(G1).");
			pEquipment->setReadBitBlock(0x5c00, 0x66ff);
			pEquipment->setStation(0, 255);
			addToEquipmentList(pEquipment);


			pEquipment->init();
			LOGE("已添加“VacuumBake”.");
			return 0;

			return pEquipment;
			}

			int CMaster::addAligner()
			CAligner* CMaster::addAligner()
			{
			CAligner* pEquipment = new CAligner();
			pEquipment->setID(EQ_ID_ALIGNER);
			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);


			pEquipment->init();
			LOGE("已添加“Aligner”.");
			return 0;

			return pEquipment;
			}

			int CMaster::addEFEM()
			CEFEM* CMaster::addEFEM()
			{
			CEFEM* pEquipment = new CEFEM();
			pEquipment->setID(EQ_ID_EFEM);
			@@ -340,415 +1593,49 @@
			addToEquipmentList(pEquipment);


			// 添加 step
			{
			CEqModeStep* pStep = new CEqModeStep();
			pStep->setName(STEP_MODE);
			pStep->setWriteSignalDev(0x50);
			pStep->setModeDev(0x5d7d);
			if (pEquipment->addStep(STEP_ID_EQMODE_CHANGED, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqStatusStep* pStep = new CEqStatusStep();
			pStep->setName(STEP_STATUS);
			pStep->setWriteSignalDev(0x51);
			pStep->setStatusDev(0x5d59);
			if (pEquipment->addStep(STEP_ID_EQSTATUS_CHANGED, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqAlarmStep* pStep = new CEqAlarmStep();
			pStep->setName(STEP_ALARM_BLOCK1);
			pStep->setWriteSignalDev(0x52);
			pStep->setAlarmDev(0x5f0e);
			if (pEquipment->addStep(STEP_ID_EQALARM1, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqAlarmStep* pStep = new CEqAlarmStep();
			pStep->setName(STEP_ALARM_BLOCK2);
			pStep->setWriteSignalDev(0x53);
			pStep->setAlarmDev(0x5f3b);
			if (pEquipment->addStep(STEP_ID_EQALARM2, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqAlarmStep* pStep = new CEqAlarmStep();
			pStep->setName(STEP_ALARM_BLOCK3);
			pStep->setWriteSignalDev(0x54);
			pStep->setAlarmDev(0x5f68);
			if (pEquipment->addStep(STEP_ID_EQALARM3, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqAlarmStep* pStep = new CEqAlarmStep();
			pStep->setName(STEP_ALARM_BLOCK4);
			pStep->setWriteSignalDev(0x55);
			pStep->setAlarmDev(0x5f95);
			if (pEquipment->addStep(STEP_ID_EQALARM4, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqAlarmStep* pStep = new CEqAlarmStep();
			pStep->setName(STEP_ALARM_BLOCK5);
			pStep->setWriteSignalDev(0x56);
			pStep->setAlarmDev(0x5fc2);
			if (pEquipment->addStep(STEP_ID_EQALARM5, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqProcessStep* pStep = new CEqProcessStep();
			pStep->setName(STEP_PROCESS);
			pStep->setWriteSignalDev(0x57);
			pStep->setProcessDev(0x6b55);
			if (pEquipment->addStep(STEP_ID_PROCESS_DATA_REPORT, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqCimModeChangeStep* pStep = new CEqCimModeChangeStep();
			pStep->setName(STEP_CIM_MODE_CHANGE);
			pStep->setWriteSignalDev(0x70);
			pStep->setCimModeDev(0x15);
			if (pEquipment->addStep(STEP_ID_CIMMODE_CHANGED_CMD_REPLY, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqCimMessageCmdStep* pStep = new CEqCimMessageCmdStep();
			pStep->setName(STEP_CIM_MESSAGE_CMD);
			pStep->setWriteSignalDev(0x71);
			pStep->setCimMessageDev(0x0);
			if (pEquipment->addStep(STEP_ID_CIM_MSG_SET_CMD_REPLY, pStep) != 0) {
			delete pStep;
			}
			}
			{
			// CIM Message Confirm
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x5f80);
			pStep->setName(STEP_EQ_CIM_MESSAGE_CONFIRM);
			pStep->setWriteSignalDev(0x59);
			if (pEquipment->addStep(STEP_ID_CIM_MSG_CONFIRM_REPORT, pStep) != 0) {
			delete pStep;
			}
			}
			{
			// VCR1 Event Report
			CEqVcrEventStep* pStep = new CEqVcrEventStep();
			pStep->setName(STEP_EQ_VCR1_EVENT_REPORT);
			pStep->setWriteSignalDev(0x4a);
			pStep->setReturnDev(0x91e);
			pStep->setVcrEventReportDev(0x5fef);
			if (pEquipment->addStep(STEP_ID_VCR1_EVENT_REPORT, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqCimMessageClearStep* pStep = new CEqCimMessageClearStep();
			pStep->setName(STEP_CIM_MESSAGE_CLEAR);
			pStep->setWriteSignalDev(0x72);
			pStep->setClearCimMessageDev(0x13);
			if (pEquipment->addStep(STEP_ID_CIM_MSG_CLEAR_CMD_REPLY, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqDateTimeSetCmdStep* pStep = new CEqDateTimeSetCmdStep();
			pStep->setName(STEP_DATETIME_SET_CMD);
			pStep->setWriteSignalDev(0x73);
			pStep->setDateTimeDev(0x16);
			if (pEquipment->addStep(STEP_ID_DATETIME_SET_CMD_REPLY, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqVCREnableStep* pStep = new CEqVCREnableStep();
			pStep->setName(STEP_EQ_VCR_ENABLE);
			pStep->setWriteSignalDev(0x74);
			pStep->setEqVCRModeDev(0x1F);
			if (pEquipment->addStep(STEP_ID_VCR_ENABLE_CMD_REPLY, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqModeChangeStep* pStep = new CEqModeChangeStep();
			pStep->setName(STEP_EQ_MODE_CHANGE);
			pStep->setWriteSignalDev(0x75);
			pStep->setEqModeDev(0x1E);
			if (pEquipment->addStep(STEP_ID_EQMODE_CHANGE_CMD_REPLY, pStep) != 0) {
			delete pStep;
			}
			}

			// Port1
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6010);
			pStep->setName(STEP_EQ_PORT1_TYPE);
			pStep->setWriteSignalDev(0xa0);
			if (pEquipment->addStep(STEP_ID_PORT1_TYPE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6011);
			pStep->setName(STEP_EQ_PORT1_MODE);
			pStep->setWriteSignalDev(0xa8);
			if (pEquipment->addStep(STEP_ID_PORT1_MODE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x6012);
			pStep->setName(STEP_EQ_PORT1_CASSETTE_TYPE);
			pStep->setWriteSignalDev(0xb0);
			if (pEquipment->addStep(STEP_ID_PORT1_CASSETTE_TYPE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6014);
			pStep->setName(STEP_EQ_PORT1_TRANSFER_MODE);
			pStep->setWriteSignalDev(0xb8);
			if (pEquipment->addStep(STEP_ID_PORT1_TRANSFER_MODE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6015);
			pStep->setName(STEP_EQ_PORT1_ENABLE);
			pStep->setWriteSignalDev(0xc0);
			if (pEquipment->addStep(STEP_ID_PORT1_ENABLE_MODE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6016);
			pStep->setName(STEP_EQ_PORT1_TYPE_ATUO);
			pStep->setWriteSignalDev(0xc8);
			if (pEquipment->addStep(STEP_ID_PORT1_TYPE_AUTO_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}

			// Port2
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6020);
			pStep->setName(STEP_EQ_PORT2_TYPE);
			pStep->setWriteSignalDev(0xa1);
			if (pEquipment->addStep(STEP_ID_PORT2_TYPE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6021);
			pStep->setName(STEP_EQ_PORT2_MODE);
			pStep->setWriteSignalDev(0xa9);
			if (pEquipment->addStep(STEP_ID_PORT2_MODE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x6022);
			pStep->setName(STEP_EQ_PORT2_CASSETTE_TYPE);
			pStep->setWriteSignalDev(0xb1);
			if (pEquipment->addStep(STEP_ID_PORT2_CASSETTE_TYPE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6024);
			pStep->setName(STEP_EQ_PORT2_TRANSFER_MODE);
			pStep->setWriteSignalDev(0xb9);
			if (pEquipment->addStep(STEP_ID_PORT2_TRANSFER_MODE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6025);
			pStep->setName(STEP_EQ_PORT2_ENABLE);
			pStep->setWriteSignalDev(0xc1);
			if (pEquipment->addStep(STEP_ID_PORT2_ENABLE_MODE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6026);
			pStep->setName(STEP_EQ_PORT2_TYPE_ATUO);
			pStep->setWriteSignalDev(0xc9);
			if (pEquipment->addStep(STEP_ID_PORT2_TYPE_AUTO_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}

			// Port3
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6030);
			pStep->setName(STEP_EQ_PORT3_TYPE);
			pStep->setWriteSignalDev(0xa2);
			if (pEquipment->addStep(STEP_ID_PORT3_TYPE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6031);
			pStep->setName(STEP_EQ_PORT3_MODE);
			pStep->setWriteSignalDev(0xaa);
			if (pEquipment->addStep(STEP_ID_PORT3_MODE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x6032);
			pStep->setName(STEP_EQ_PORT3_CASSETTE_TYPE);
			pStep->setWriteSignalDev(0xb2);
			if (pEquipment->addStep(STEP_ID_PORT3_CASSETTE_TYPE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6034);
			pStep->setName(STEP_EQ_PORT3_TRANSFER_MODE);
			pStep->setWriteSignalDev(0xba);
			if (pEquipment->addStep(STEP_ID_PORT3_TRANSFER_MODE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6035);
			pStep->setName(STEP_EQ_PORT3_ENABLE);
			pStep->setWriteSignalDev(0xc2);
			if (pEquipment->addStep(STEP_ID_PORT3_ENABLE_MODE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6036);
			pStep->setName(STEP_EQ_PORT3_TYPE_ATUO);
			pStep->setWriteSignalDev(0xca);
			if (pEquipment->addStep(STEP_ID_PORT3_TYPE_AUTO_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}

			// Port4
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6040);
			pStep->setName(STEP_EQ_PORT4_TYPE);
			pStep->setWriteSignalDev(0xa3);
			if (pEquipment->addStep(STEP_ID_PORT4_TYPE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6041);
			pStep->setName(STEP_EQ_PORT4_MODE);
			pStep->setWriteSignalDev(0xab);
			if (pEquipment->addStep(STEP_ID_PORT4_MODE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x6042);
			pStep->setName(STEP_EQ_PORT4_CASSETTE_TYPE);
			pStep->setWriteSignalDev(0xb3);
			if (pEquipment->addStep(STEP_ID_PORT4_CASSETTE_TYPE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6044);
			pStep->setName(STEP_EQ_PORT4_TRANSFER_MODE);
			pStep->setWriteSignalDev(0xbb);
			if (pEquipment->addStep(STEP_ID_PORT4_TRANSFER_MODE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6045);
			pStep->setName(STEP_EQ_PORT4_ENABLE);
			pStep->setWriteSignalDev(0xc3);
			if (pEquipment->addStep(STEP_ID_PORT4_ENABLE_MODE_CHANGE, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6046);
			pStep->setName(STEP_EQ_PORT4_TYPE_ATUO);
			pStep->setWriteSignalDev(STEP_ID_PORT4_TYPE_AUTO_CHANGE);
			if (pEquipment->addStep(0xcb, pStep) != 0) {
			delete pStep;
			}
			}


			// CEqCassetteTranserStateStep
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_EMPTY, 0xd8,
			STEP_ID_PORT1_CASSETTIE_EMPTY, 0x6050);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_LOAD_EADY, 0xe0,
			STEP_ID_PORT1_CASSETTIE_LOAD_READY, 0x6050);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_LOADED, 0xe8,
			STEP_ID_PORT1_CASSETTIE_LOADED, 0x6050);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_INUSE, 0xf0,
			STEP_ID_PORT1_CASSETTIE_INUSE, 0x6050);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_UNLOAD_EADY, 0xf8,
			STEP_ID_PORT1_CASSETTIE_UNLOAD_READY, 0x60f50);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_BLOCKED, 0x100,
			STEP_ID_PORT1_CASSETTIE_BLOCKED, 0x6050);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_EMPTY, 0xd9,
			STEP_ID_PORT2_CASSETTIE_EMPTY, 0x6070);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_LOAD_EADY, 0xe1,
			STEP_ID_PORT2_CASSETTIE_LOAD_READY, 0x6070);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_LOADED, 0xe9,
			STEP_ID_PORT2_CASSETTIE_LOADED, 0x6070);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_INUSE, 0xf1,
			STEP_ID_PORT2_CASSETTIE_INUSE, 0x6070);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_UNLOAD_EADY, 0xf9,
			STEP_ID_PORT2_CASSETTIE_UNLOAD_READY, 0x6070);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_BLOCKED, 0x101,
			STEP_ID_PORT2_CASSETTIE_BLOCKED, 0x6070);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_EMPTY, 0xda,
			STEP_ID_PORT3_CASSETTIE_EMPTY, 0x6090);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_LOAD_EADY, 0xe2,
			STEP_ID_PORT3_CASSETTIE_LOAD_READY, 0x6090);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_LOADED, 0xea,
			STEP_ID_PORT3_CASSETTIE_INUSE, 0x6090);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_INUSE, 0xf2,
			STEP_ID_PORT3_CASSETTIE_INUSE, 0x6090);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_UNLOAD_EADY, 0xfa,
			STEP_ID_PORT3_CASSETTIE_UNLOAD_READY, 0x6090);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_BLOCKED, 0x102,
			STEP_ID_PORT3_CASSETTIE_BLOCKED, 0x6090);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_EMPTY, 0xdb,
			STEP_ID_PORT4_CASSETTIE_EMPTY, 0x60b0);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_LOAD_EADY, 0xe3,
			STEP_ID_PORT4_CASSETTIE_LOAD_READY, 0x60b0);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_LOADED, 0xeb,
			STEP_ID_PORT4_CASSETTIE_LOADED, 0x60b0);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_INUSE, 0xf3,
			STEP_ID_PORT4_CASSETTIE_INUSE, 0x60b0);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_UNLOAD_EADY, 0xfb,
			STEP_ID_PORT4_CASSETTIE_UNLOAD_READY, 0x60b0);
			ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_BLOCKED, 0x103,
			STEP_ID_PORT4_CASSETTIE_BLOCKED, 0x60b0);

			pEquipment->init();
			LOGE("已添加“EFEM(ROBOT)”.");
			return 0;

			return pEquipment;
			}

			CArm* CMaster::addArm()
			{
			CArm* pEquipment = new CArm();
			pEquipment->setID(EQ_ID_ARM);
			pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
			pEquipment->setName("ARM");
			pEquipment->setDescription("ARM.");
			addToEquipmentList(pEquipment);


			pEquipment->init();
			LOGE("已添加“ARM”.");

			return pEquipment;
			}

			CArmTray* CMaster::addArmTray(int index)
			{
			CArmTray* pEquipment = new CArmTray();
			pEquipment->setID(index == 0 ? EQ_ID_ARM_TRAY1 : EQ_ID_ARM_TRAY2);
			pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
			pEquipment->setName(index == 0 ? "Arm Tray1" : "Arm Tray2");
			pEquipment->setDescription(index == 0 ? "Arm Tray1." : "Arm Tray2.");
			addToEquipmentList(pEquipment);


			pEquipment->init();
			LOGE("已添加“%s”.", pEquipment->getName().c_str());

			return pEquipment;
			}

			/* 添加bonder1 或 bonder2
			* index -- 0, bonder1
			* index -- 1, bonder2
			*/
			int CMaster::addBonder(int index)
			CBonder* CMaster::addBonder(int index)
			{
			ASSERT(index == 0 \|\| index == 1);
			CBonder* pEquipment = new CBonder();
			@@ -758,196 +1645,49 @@
			pEquipment->setStation(0, 255);
			pEquipment->setReadBitBlock(index == 0 ? 0x3b00 : 0x4600,
			index == 0 ? 0x5600 : 0x6100);
			pEquipment->setIndex(index);
			addToEquipmentList(pEquipment);


			// 添加 step
			{
			CEqModeStep* pStep = new CEqModeStep();
			pStep->setName(STEP_MODE);
			pStep->setWriteSignalDev(index == 0 ? 0x350 : 0x650);
			pStep->setModeDev(index == 0 ? 0x9d7d : 0xdd7d);
			if (pEquipment->addStep(STEP_ID_EQMODE_CHANGED, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqStatusStep* pStep = new CEqStatusStep();
			pStep->setName(STEP_STATUS);
			pStep->setWriteSignalDev(index == 0 ? 0x351 : 0x651);
			pStep->setStatusDev(index == 0 ? 0x9d59 : 0xdd59);
			if (pEquipment->addStep(STEP_ID_EQSTATUS_CHANGED, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqAlarmStep* pStep = new CEqAlarmStep();
			pStep->setName(STEP_ALARM_BLOCK1);
			pStep->setWriteSignalDev(index == 0 ? 0x352 : 0x652);
			pStep->setAlarmDev(index == 0 ? 0x9f0e : 0xdf0e);
			if (pEquipment->addStep(STEP_ID_EQALARM1, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqAlarmStep* pStep = new CEqAlarmStep();
			pStep->setName(STEP_ALARM_BLOCK2);
			pStep->setWriteSignalDev(index == 0 ? 0x353 : 0x653);
			pStep->setAlarmDev(index == 0 ? 0x9f3b : 0xdf3b);
			if (pEquipment->addStep(STEP_ID_EQALARM2, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqAlarmStep* pStep = new CEqAlarmStep();
			pStep->setName(STEP_ALARM_BLOCK3);
			pStep->setWriteSignalDev(index == 0 ? 0x354 : 0x654);
			pStep->setAlarmDev(index == 0 ? 0x9f68 : 0xdf68);
			if (pEquipment->addStep(STEP_ID_EQALARM3, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqAlarmStep* pStep = new CEqAlarmStep();
			pStep->setName(STEP_ALARM_BLOCK4);
			pStep->setWriteSignalDev(index == 0 ? 0x355 : 0x655);
			pStep->setAlarmDev(index == 0 ? 0x9f95 : 0xdf95);
			if (pEquipment->addStep(STEP_ID_EQALARM4, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqAlarmStep* pStep = new CEqAlarmStep();
			pStep->setName(STEP_ALARM_BLOCK5);
			pStep->setWriteSignalDev(index == 0 ? 0x356 : 0x656);
			pStep->setAlarmDev(index == 0 ? 0x9fc2 : 0xdfc2);
			if (pEquipment->addStep(STEP_ID_EQALARM5, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqProcessStep* pStep = new CEqProcessStep();
			pStep->setName(STEP_PROCESS);
			pStep->setWriteSignalDev(index == 0 ? 0x357 : 0x657);
			pStep->setProcessDev(index == 0 ? 0xab55 : 0xeb55);
			if (pEquipment->addStep(STEP_ID_PROCESS_DATA_REPORT, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqCimModeChangeStep* pStep = new CEqCimModeChangeStep();
			pStep->setName(STEP_CIM_MODE_CHANGE);
			pStep->setWriteSignalDev(index == 0 ? 0x370 : 0x670);
			pStep->setCimModeDev(index == 0 ? 0x965 : 0x12b5);
			if (pEquipment->addStep(STEP_ID_CIMMODE_CHANGED_CMD_REPLY, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqCimMessageCmdStep* pStep = new CEqCimMessageCmdStep();
			pStep->setName(STEP_CIM_MESSAGE_CMD);
			pStep->setWriteSignalDev(index == 0 ? 0x371 : 0x671);
			pStep->setCimMessageDev(index == 0 ? 0x950 : 0x12a0);
			if (pEquipment->addStep(STEP_ID_CIM_MSG_SET_CMD_REPLY, pStep) != 0) {
			delete pStep;
			}
			}
			{
			// CIM Message Confirm
			CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, index == 0 ? 0x9d80 : 0xdd80);
			pStep->setName(STEP_EQ_CIM_MESSAGE_CONFIRM);
			pStep->setWriteSignalDev(index == 0 ? 0x359 : 0x659);
			if (pEquipment->addStep(STEP_ID_CIM_MSG_CONFIRM_REPORT, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqCimMessageClearStep* pStep = new CEqCimMessageClearStep();
			pStep->setName(STEP_CIM_MESSAGE_CLEAR);
			pStep->setWriteSignalDev(index == 0 ? 0x372 : 0x672);
			pStep->setClearCimMessageDev(index == 0 ? 0x963 : 0x12b3);
			if (pEquipment->addStep(STEP_ID_CIM_MSG_CLEAR_CMD_REPLY, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqDateTimeSetCmdStep* pStep = new CEqDateTimeSetCmdStep();
			pStep->setName(STEP_DATETIME_SET_CMD);
			pStep->setWriteSignalDev(index == 0 ? 0x373 : 0x673);
			pStep->setDateTimeDev(index == 0 ? 0x966 : 0x12b6);
			if (pEquipment->addStep(STEP_ID_DATETIME_SET_CMD_REPLY, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqModeChangeStep* pStep = new CEqModeChangeStep();
			pStep->setName(STEP_EQ_MODE_CHANGE);
			pStep->setWriteSignalDev(index == 0 ? 0x375 : 0x675);
			pStep->setEqModeDev(index == 0 ? 0x96E : 0x12be);
			if (pEquipment->addStep(STEP_ID_EQMODE_CHANGE_CMD_REPLY, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqJobEventStep* pStep = new CEqJobEventStep();
			pStep->setName(STEP_EQ_RECEIVED_JOB_UPS1);
			pStep->setWriteSignalDev(index == 0 ? 0x300 : 0x600);
			pStep->setJobDataDev(index == 0 ? 0x8c90 : 0xcc90);
			if (pEquipment->addStep(STEP_ID_RECIVE_JOB_UPS1, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqJobEventStep* pStep = new CEqJobEventStep();
			pStep->setName(STEP_EQ_RECEIVED_JOB_UPS2);
			pStep->setWriteSignalDev(index == 0 ? 0x301 : 0x601);
			pStep->setJobDataDev(index == 0 ? 0x8dd0 : 0xcdd0);
			if (pEquipment->addStep(STEP_ID_RECIVE_JOB_UPS2, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqJobEventStep* pStep = new CEqJobEventStep();
			pStep->setName(STEP_EQ_SENT_OUT_JOB_DOWNS1);
			pStep->setWriteSignalDev(index == 0 ? 0x310 : 0x610);
			pStep->setJobDataDev(index == 0 ? 0x8000 : 0xc000);
			if (pEquipment->addStep(STEP_ID_SENT_OUT_JOB_DOWNS1, pStep) != 0) {
			delete pStep;
			}
			}
			{
			CEqJobEventStep* pStep = new CEqJobEventStep();
			pStep->setName(STEP_EQ_SENT_OUT_JOB_DOWNS2);
			pStep->setWriteSignalDev(index == 0 ? 0x311 : 0x611);
			pStep->setJobDataDev(index == 0 ? 0x8140 : 0xc140);
			if (pEquipment->addStep(STEP_ID_SENT_OUT_JOB_DOWNS2, pStep) != 0) {
			delete pStep;
			}
			}


			pEquipment->init();
			LOGE("已添加“%s”.", pEquipment->getName().c_str());


			return 0;
			return pEquipment;
			}

			int CMaster::addBakeCooling()
			CBakeCooling* CMaster::addBakeCooling()
			{
			CBakeCooling* pEquipment = new CBakeCooling();
			pEquipment->setID(EQ_ID_BAKE_COOLING);
			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);


			pEquipment->init();
			LOGE("已添加“Aligner”.");
			return 0;

			return pEquipment;
			}

			CMeasurement* CMaster::addMeasurement()
			{
			CMeasurement* pEquipment = new CMeasurement();
			pEquipment->setID(EQ_ID_MEASUREMENT);
			pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
			pEquipment->setName("Measurement");
			pEquipment->setDescription("Measurement.");
			pEquipment->setReadBitBlock(0x6700, 0x6e00);
			pEquipment->setStation(0, 255);
			addToEquipmentList(pEquipment);

			pEquipment->init();
			LOGE("已添加“Measurement”.");

			return pEquipment;
			}

			void CMaster::onTimer(UINT nTimerid)
			@@ -957,27 +1697,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) {
			@@ -987,6 +1708,38 @@
			}
			}



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

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


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

			void CMaster::connectEquipments()
			@@ -1002,43 +1755,42 @@
			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);

			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"));
			@@ -1051,12 +1803,17 @@
			LOGE("连接Bonder2-BakeCooling失败");
			}

			nRet = pBakeCooling->getPin("Out1")->connectPin(pLoadPort3->getPin("In"));
			nRet = pBakeCooling->getPin("Out")->connectPin(pMeasurement->getPin("In"));
			if (nRet < 0) {
			LOGE("连接BakeCooling-LoadPort3失败");
			}

			nRet = pBakeCooling->getPin("Out2")->connectPin(pLoadPort4->getPin("In"));
			nRet = pMeasurement->getPin("Out1")->connectPin(pLoadPort3->getPin("In"));
			if (nRet < 0) {
			LOGE("连接BakeCooling-LoadPort3失败");
			}

			nRet = pMeasurement->getPin("Out2")->connectPin(pLoadPort4->getPin("In"));
			if (nRet < 0) {
			LOGE("连接BakeCooling-LoadPort4失败");
			}
			@@ -1108,15 +1865,23 @@

			int CMaster::readCache()
			{
			CFile file;
			if (!file.Open(m_strFilepath.c_str(), CFile::modeRead)) {
			return -1;
			}
			try {
			CFile file;
			if (!file.Open(m_strFilepath.c_str(), CFile::modeRead)) {
			return -1;
			}

			CArchive ar(&file, CArchive::load);
			serialize(ar);
			ar.Close();
			file.Close();
			CArchive ar(&file, CArchive::load);
			serialize(ar);
			ar.Close();
			file.Close();
			}
			catch (CFileException* e) {
			TCHAR szErr[512];
			e->GetErrorMessage(szErr, 512);
			AfxMessageBox(szErr);
			e->Delete();
			}

			return 0;
			}
			@@ -1127,4 +1892,656 @@
			item->serialize(ar);
			}
			}

			void CMaster::setState(MASTERSTATE state)
			{
			m_state = state;
			if (m_listener.onMasterStateChanged != nullptr) {
			m_listener.onMasterStateChanged(this, m_state);
			}
			}

			static int taskSeqNo = 0;
			CRobotTask* CMaster::createTransferTask(CEquipment* pSrcEq, CEquipment* pTarEq,
			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;
			pTarSlot = pTarEq->getAvailableSlotForGlass(primaryType);
			pSrcSlot = pSrcEq->getProcessedSlot(primaryType, bJobMode);
			if (pSrcSlot == nullptr \|\| nullptr == pTarSlot) {
			pTarSlot = pTarEq->getAvailableSlotForGlass(secondaryType);
			pSrcSlot = pSrcEq->getProcessedSlot(secondaryType, bJobMode);
			}


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

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

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

			CRobotTask* pTask = nullptr;
			CSlot* pSrcSlot, * pTarSlot;
			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->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);
			}

			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;
			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(const std::string& path)
			{
			// 保存文件路径
			m_strStatePath = path;


			std::ifstream ifs(path, 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;
			}


			// 读取 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);


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


			return true;
			}

			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
			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::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) {
			CGlass* pGlass = (CGlass*)g;
			if (pGlass->state() != GlsState::Aborted
			&& pGlass->state() != GlsState::Completed
			&& pGlass->state() != GlsState::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;
			}
			}