~chenluhua/Bond2.git

			@@ -1,4 +1,4 @@
			#include "stdafx.h"
			#include "stdafx.h"
			#include "Common.h"
			#include "CMaster.h"
			#include <future>
			@@ -6,9 +6,15 @@
			#include "RecipeManager.h"
			#include <fstream>
			#include "SerializeUtil.h"
			#include "CServoUtilsTool.h"


			namespace SERVO {
			static inline int64_t now_ms_epoch() {
			using namespace std::chrono;
			return duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
			}

			CMaster* g_pMaster = NULL;

			unsigned __stdcall DispatchThreadFunction(LPVOID lpParam)
			@@ -53,20 +59,25 @@
			m_ullRunTime = 0;
			m_state = MASTERSTATE::READY;
			m_pActiveRobotTask = nullptr;
			m_nLastError = 0;
			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相关
			// 释放Job相关
			for (auto item : m_processJobs) {
			delete item;
			}
			@@ -116,36 +127,36 @@

			int CMaster::init()
			{
			LOGI("<Master>正在初始化...");
			LOGI("<Master>正在初始化...");


			// cclink
			if (m_cclink.Connect(CC_LINK_IE_CONTROL_CHANNEL(1)) != 0) {
			LOGE("连接CC-Link失败.");
			LOGE("连接CC-Link失败.");
			}
			else {
			LOGI("连接CC-Link成功.");
			LOGI("连接CC-Link成功.");
			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版本信息失败.");
			LOGE("获取CC-Link版本信息失败.");
			}

			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状态失败.");
			LOGE("获取CC-Link状态失败.");
			}
			}


			// 初始化添加各子设备
			// 初始化添加各子设备
			CLoadPort* pPort1, * pPort2, * pPort3, * pPort4;
			CBonder* pBonder1, * pBonder2;
			CEFEM* pEfem;
			@@ -208,28 +219,34 @@





			// 读缓存数据
			// 读缓存数据
			readCache();
			loadState();
			if (m_listener.onControlJobChanged) {
			m_listener.onControlJobChanged(this);
			}


			// 定时器
			// 定时器
			g_pMaster = this;
			SetTimer(NULL, 1, 250, (TIMERPROC)MasterTimerProc);


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


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


			LOGI("<Master>初始化完成.");
			// 曲线服务
			CreateDAQBridgeServer();


			LOGI("<Master>初始化完成.");
			return 0;
			}

			@@ -240,7 +257,7 @@
			::WaitForSingleObject(m_hEventReadBitsThreadExit[1], INFINITE);
			::WaitForSingleObject(m_hEventDispatchThreadExit[1], INFINITE);

			LOGI("<Master>正在结束程序.");
			LOGI("<Master>正在结束程序.");
			for (auto item : m_listEquipment) {
			item->term();
			}
			@@ -259,6 +276,12 @@
			m_listEquipment.clear();


			if (m_pCollector != nullptr) {
			m_pCollector->stopLoop();
			delete m_pCollector;
			m_pCollector = nullptr;
			}

			return 0;
			}

			@@ -269,6 +292,7 @@
			}

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

			@@ -282,21 +306,53 @@
			}

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

			return 0;
			}

			int CMaster::stop()
			int CMaster::startBatch()
			{
			// 运行时间为累加结果，本次停止时刷新；
			if (m_state != MASTERSTATE::RUNNING && m_state != MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER) {
			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;
			}
			@@ -310,7 +366,8 @@

			ULONGLONG CMaster::getRunTime()
			{
			if (m_state == MASTERSTATE::RUNNING \|\| m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER)
			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;
			@@ -323,14 +380,14 @@

			unsigned CMaster::DispatchProc()
			{
			// 优先考虑的类型和次要类型
			// 一种情况，如果不分主次，一直搬G1, 等到Bonder1和Bonder2都放了G1, Aligner也放了G1,
			// Bonder1和Bonder2需要的G2就过不来了
			// 最基本的实现，可以G2和G2轮流搬送，但最好根据Bonder的需求来决定
			// 优先考虑的类型和次要类型
			// 一种情况，如果不分主次，一直搬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);
			@@ -359,7 +416,7 @@
			ASSERT(pMeasurement);

			while (1) {
			// 待退出信号或时间到
			// 待退出信号或时间到
			HANDLE hEvents[] = { m_hEventDispatchThreadExit[0], m_hDispatchEvent };
			int nRet = WaitForMultipleObjects(2, hEvents, FALSE, 500);
			if (nRet == WAIT_OBJECT_0) {
			@@ -367,11 +424,11 @@
			}


			// 如果状态为STARTING，开始工作并切换到RUNNING状态
			// 如果状态为STARTING，开始工作并切换到RUNNING状态
			lock();
			if (m_state == MASTERSTATE::STARTING) {
			// 发送indexerOperationModeChange到各个机台，成功后切换到RUNNING状态
			// 否则切换到MSERROR状态
			// 发送indexerOperationModeChange到各个机台，成功后切换到RUNNING状态
			// 否则切换到MSERROR状态
			int nRet;
			CEquipment* pEq[6] = { pEFEM, pBonder1, pBonder2, pBakeCooling,
			pVacuumBake, pMeasurement};
			@@ -386,8 +443,9 @@
			TRACE("a0001\n", writeCode, retCode);
			});
			if (nRet != 0) {
			LOGI("<Master>EFEM切换Start状态失败");
			m_strLastError = "EFEM切换Start状态失败.";
			LOGE("<Master>EFEM切换Start状态失败");
			m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
			m_strLastError = "EFEM切换Start状态失败.";
			goto WAIT;
			}
			futures.push_back(promises[0].get_future());
			@@ -399,8 +457,9 @@
			TRACE("a0002\n");
			});
			if (nRet != 0) {
			LOGI("<Master>Bonder1切换Start状态失败");
			m_strLastError = "Bonder1切换Start状态失败.";
			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());
			@@ -412,8 +471,9 @@
			TRACE("a0003\n");
			});
			if (nRet != 0) {
			LOGI("<Master>Bonder2切换Start状态失败");
			m_strLastError = "Bonder2切换Start状态失败.";
			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());
			@@ -425,8 +485,9 @@
			TRACE("a0004\n");
			});
			if (nRet != 0) {
			LOGI("<Master>BakeCooling切换Start状态失败");
			m_strLastError = "BakeCooling切换Start状态失败.";
			LOGE("<Master>BakeCooling切换Start状态失败");
			m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
			m_strLastError = "BakeCooling切换Start状态失败.";
			goto WAIT;
			}
			futures.push_back(promises[3].get_future());
			@@ -438,8 +499,9 @@
			TRACE("a0005\n");
			});
			if (nRet != 0) {
			LOGI("<Master>VacuumBake切换Start状态失败");
			m_strLastError = "VacuumBake切换Start状态失败.";
			LOGE("<Master>VacuumBake切换Start状态失败");
			m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
			m_strLastError = "VacuumBake切换Start状态失败.";
			goto WAIT;
			}
			futures.push_back(promises[4].get_future());
			@@ -451,8 +513,9 @@
			TRACE("a0006\n");
			});
			if (nRet != 0) {
			LOGI("<Master>Measurement切换Start状态失败");
			m_strLastError = "Measurement切换Start状态失败.";
			LOGE("<Master>Measurement切换Start状态失败");
			m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
			m_strLastError = "Measurement切换Start状态失败.";
			goto WAIT;
			}
			futures.push_back(promises[5].get_future());
			@@ -460,37 +523,38 @@

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

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


			unlock();
			if(!m_bContinuousTransfer)
			setState(MASTERSTATE::RUNNING);
			else
			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 模式...");
			LOGI("<Master>开始切换各设备到 Stop 模式...");

			std::vector<std::promise<void>> promises(6);
			std::vector<std::future<void>> futures;
			@@ -508,22 +572,23 @@
			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状态发送失败.";
			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 阻塞
			promises[i].set_value(); // 避免 wait 阻塞
			}
			futures.push_back(promises[i].get_future());
			}

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

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

			@@ -532,15 +597,19 @@
			continue;
			}

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

			continue;
			}


			// 调度逻辑处理
			// 调度逻辑处理
			else if (m_state == MASTERSTATE::RUNNING) {
			// 检测判断robot状态
			// 检测判断robot状态
			RMDATA& rmd = pEFEM->getRobotMonitoringData();
			if (rmd.status != ROBOT_STATUS::Idle && rmd.status != ROBOT_STATUS::Run) {
			unlock();
			@@ -552,43 +621,68 @@
			m_pActiveRobotTask->place();
			}
			unlock();
			// 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
			// LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
			// 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
			// 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;
			}
			// Bonder1、Bonder2、Fliper、VacuumBake、Aligner，统计G2和G1的数量, 配对组数, 多出的类型
			int nG2Count = 0, nG1Count = 0, nGlassGroup, nExtraType;
			if (pBonder1->slotHasGlass(0)) {
			nG2Count++;
			}
			else if ((pBonder1->canPlaceGlassInSlot(0) && !pBonder1->canPlaceGlassInSlot(1))
			\|\| (pBonder2->canPlaceGlassInSlot(0) && !pBonder2->canPlaceGlassInSlot(1))) {
			primaryType = MaterialsType::G2;
			secondaryType = MaterialsType::G1;
			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
			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);
			m_pActiveRobotTask = createTransferTask(pMeasurement, pLoadPorts[s], MaterialsType::G1, secondaryType);
			if (m_pActiveRobotTask != nullptr) {
			goto PORT_PUT;
			}
			@@ -600,7 +694,7 @@


			// Measurement NG -> LoadPort
			// NG回原位
			// NG回原位
			if (!rmd.armState[1]) {
			m_pActiveRobotTask = createTransferTask_restore(pMeasurement, pLoadPorts);
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			@@ -614,7 +708,7 @@
			}


			// BakeCooling内部
			// BakeCooling内部
			// Bake -> Cooling
			if (!rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask_bake_to_cooling(pBakeCooling);
			@@ -635,25 +729,30 @@


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

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

			if (!rmd.armState[0]) {
			m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, primaryType, secondaryType);
			// 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;
			}


			@@ -679,13 +781,33 @@


			// 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);
			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;
			}
			@@ -700,9 +822,228 @@
			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状态
			// 检测判断robot状态
			RMDATA& rmd = pEFEM->getRobotMonitoringData();
			if (rmd.status != ROBOT_STATUS::Idle && rmd.status != ROBOT_STATUS::Run) {
			unlock();
			@@ -714,21 +1055,23 @@
			m_pActiveRobotTask->place();
			}
			unlock();
			// 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
			// LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
			// 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
			// LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
			continue;
			}

			// Measurement -> LoadPort
			for (int s = 0; s < 4; s++) {
			PortType pt = pLoadPorts[s]->getPortType();
			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[s]->isEnable()
			&& !rmd.armState[0] && pLoadPorts[p]->isEnable()
			&& (pt == PortType::Unloading \|\| pt == PortType::Both)
			&& pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
			&& 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[s], slot);
			0, pLoadPorts[p], slot);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_Measurement_LoadPort;
			m_nContinuousTransferStep = CTStep_end;
			@@ -749,20 +1092,20 @@
			3, pMeasurement, 0);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_BakeCooling_Measurement;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling -> Measurement)...");
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling -> Measurement)...");
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}


			// BakeCooling内部
			// 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)...");
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling-2 -> BakeCooling-3)...");
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}
			@@ -772,7 +1115,7 @@
			1, pBakeCooling, 2);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_BakeCooling_BakeCooling2;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling-1 -> BakeCooling-2)...");
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling-1 -> BakeCooling-2)...");
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}
			@@ -782,7 +1125,7 @@
			0, pBakeCooling, 1);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_BakeCooling_BakeCooling1;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling-0 -> BakeCooling-1)...");
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling-0 -> BakeCooling-1)...");
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}
			@@ -794,7 +1137,7 @@
			1, pBakeCooling, 0);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_VacuumBake_BakeCooling;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(VacuumBake(G1) -> BakeCooling)...");
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(VacuumBake(G1) -> BakeCooling)...");
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}
			@@ -806,7 +1149,7 @@
			0, pVacuumBake, 1);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_VacuumBake_VacuumBake;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(VacuumBake(G1-0) -> VacuumBake(G1-1))...");
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(VacuumBake(G1-0) -> VacuumBake(G1-1))...");
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}
			@@ -818,31 +1161,31 @@
			1, pVacuumBake, 0);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_Bonder2_VacuumBake;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Bonder2 -> VacuumBake(G1))...");
			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()) {
			&& !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)...");
			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()) {
			&&!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)...");
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Fliper(G2) -> Bonder1)...");
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
			}
			@@ -854,24 +1197,26 @@
			0, pFliper, 0);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_Aligner_Fliper;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Aligner -> Fliper(G2))...");
			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();
			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[s]->isEnable()
			&& !rmd.armState[0] && pLoadPorts[p]->isEnable()
			&& (pt == PortType::Loading \|\| pt == PortType::Both)
			&& pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
			&& pLoadPorts[p]->getPortStatus() == PORT_INUSE) {
			for (int slot = 0; slot < SLOT_MAX; slot++) {
			m_pActiveRobotTask = createTransferTask_continuous_transfer(pLoadPorts[s],
			m_pActiveRobotTask = createTransferTask_continuous_transfer(pLoadPorts[p],
			slot, pAligner, 0);
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_LoadPort_Aligner;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(LoadPort -> Aligner)...");
			m_nContinuousWorkingPort = p;
			m_nContinuousWorkingSlot = slot;
			LOGI("<ContinuousTransfer>千传测试，开始搬送任务(LoadPort -> Aligner)...");
			pEFEM->setContext(m_pActiveRobotTask->getContext());
			goto CT_PORT_GET;
			}
			@@ -882,7 +1227,7 @@
			CT_PORT_GET:
			if (m_pActiveRobotTask != nullptr) {
			m_nContinuousTransferStep = CTStep_begin;
			LOGI("<ContinuousTransfer>千传测试，开始第 %d 轮", m_nContinuousTransferCount + 1);
			LOGI("<ContinuousTransfer>千传测试，开始第 %d 轮", m_nContinuousTransferCount + 1);
			}
			CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);

			@@ -899,13 +1244,13 @@


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

			unsigned CMaster::ReadBitsProc()
			{
			// 标志位清0复位
			// 标志位清0复位
			{
			StationIdentifier station;
			station.nNetNo = 0;
			@@ -916,13 +1261,13 @@


			while (1) {
			// 待退出信号或时间到
			// 待退出信号或时间到
			int nRet = ::WaitForSingleObject(m_hEventReadBitsThreadExit[0], 1000);
			if (nRet == WAIT_OBJECT_0) {
			break;
			}

			// 读标志位
			// 读标志位
			for (auto item : m_listEquipment) {
			const StationIdentifier& station = item->getStation();
			MemoryBlock& block = item->getReadBitBlock();
			@@ -940,7 +1285,7 @@


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

			@@ -975,22 +1320,34 @@
			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) {
			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()
			);
			}
			}
			}
			@@ -1001,7 +1358,7 @@
			unlock();

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

			return bOk;
			@@ -1010,14 +1367,14 @@
			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))
			@@ -1026,32 +1383,32 @@
			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 (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, 已校验数据一致性.");
			LOGI("<CMaster>onPreStoredJob, 已校验数据一致性.");
			}
			}
			}
			unlock();

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

			return bOk;
			@@ -1064,11 +1421,11 @@
			m_listener.onEqDataChanged(this, p, 0);
			}

			// 取放片，更新当前搬送任务
			// 取放片，更新当前搬送任务
			if (code == EDCC_FETCHOUT_JOB) {
			lock();
			if (m_pActiveRobotTask != nullptr && m_pActiveRobotTask->getSrcPosition() == p->getID()) {
			LOGI("开始取片...");
			LOGI("开始取片...");
			}
			unlock();
			}
			@@ -1079,7 +1436,7 @@
			&& ((m_pActiveRobotTask->getArmNo() == 1 && p->getID() == EQ_ID_ARM_TRAY1)
			\|\| (m_pActiveRobotTask->getArmNo() == 2 && p->getID() == EQ_ID_ARM_TRAY2))
			) {
			LOGI("取片完成.");
			LOGI("取片完成.");
			m_pActiveRobotTask->fetchOut();
			m_pActiveRobotTask->picked();
			}
			@@ -1093,15 +1450,64 @@
			if (m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER) {
			if (m_nContinuousTransferStep == CTStep_end) {
			m_nContinuousTransferCount++;
			LOGI("<ContinuousTransfer>千传测试，第 %d 轮结束", m_nContinuousTransferCount);
			LOGI("<ContinuousTransfer>千传测试，第 %d 轮结束", m_nContinuousTransferCount);
			if (m_listener.onCTRoundEnd != nullptr) {
			m_listener.onCTRoundEnd(this, m_nContinuousTransferCount);
			}
			}
			}

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

			// 如果是搬送回从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());
			processJobFromInPorcessToComplete(pJob);
			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);
			}

			completeControlJob();
			}
			}
			}



			unlock();


			@@ -1118,8 +1524,8 @@
			&& m_pActiveRobotTask->getSrcPosition() == p->getID()) {
			m_pActiveRobotTask->stored();
			m_pActiveRobotTask->restored();
			LOGI("回撤完成...");
			// 完成此条搬送任务，但要把数据和消息上抛应用层
			LOGI("回撤完成...");
			// 完成此条搬送任务，但要把数据和消息上抛应用层
			unlock();


			@@ -1134,37 +1540,266 @@
			unlock();
			}
			};
			listener.onProcessStateChanged = [&](void* pEquipment, PROCESS_STATE state) -> void {
			listener.onProcessStateChanged = [&](void* pEquipment, int slotNo, PROCESS_STATE state) -> void {
			ASSERT(1 <= slotNo && slotNo <= 8);
			int eqid = ((CEquipment*)pEquipment)->getID();
			CGlass* pGlass = ((CEquipment*)pEquipment)->getGlassFromSlot(slotNo);
			LOGI("<Master>onProcessStateChanged<%d>", (int)state);
			if (state == PROCESS_STATE::Processing) {
			if (pGlass != nullptr) {
			m_pCollector->batchStart(SlotToMid(eqid, slotNo),
			pGlass->getID().c_str(), 10 * 60 * 1000ULL);
			}
			}
			else if (state == PROCESS_STATE::Complete) {
			if (pGlass != nullptr) {
			m_pCollector->batchStop(SlotToMid(eqid, slotNo));
			}
			}

			if (m_listener.onProcessStateChanged != nullptr) {
			m_listener.onProcessStateChanged(this, (CEquipment*)pEquipment, slotNo, state);
			}
			};
			listener.onMapMismatch = [&](void* pEquipment, short scanMap, short downMap) {
			LOGE("<Master-%s>Port InUse, map(%d!=%d)不一致，请检查。",
			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);
			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) {
			carrier->contexts.clear();
			for (auto slot : carrier->slots) {
			CGlass* pGlass = pPort->getGlassFromSlot(slot);
			carrier->contexts.push_back((void*)pGlass);
			if (pGlass != nullptr) {
			pGlass->setProcessJob(pj);

			PJWarp& jpWarp = pj->getPjWarp();
			int nRecipeID = RecipeManager::getInstance().getIdByPPID(pj->recipeSpec());
			RecipeInfo stRecipeInfo = RecipeManager::getInstance().getRecipeByPPID(pj->recipeSpec());
			std::vector<DeviceRecipe> vecRecipeInfo = stRecipeInfo.vecDeviceList;

			pGlass->setScheduledForProcessing(jpWarp.checkSlot[slot-1]);
			pGlass->setType(static_cast<SERVO::MaterialsType>(jpWarp.material[slot-1]));

			SERVO::CJobDataS* pJobDataS = pGlass->getJobDataS();
			if (pJobDataS != nullptr) {
			SERVO::CJobDataS* pJobDataS = pGlass->getJobDataS();
			pJobDataS->setLotId(pj->getLotId().c_str());
			pJobDataS->setProductId(pj->getProductId().c_str());
			pJobDataS->setOperationId(pj->getOperationId().c_str());
			pJobDataS->setMaterialsType(jpWarp.material[slot - 1]);
			pJobDataS->setMasterRecipe(nRecipeID);
			for (const auto& info : vecRecipeInfo) {
			const std::string& name = info.strDeviceName;
			short nRecipeID = (short)info.nRecipeID;

			if (name == EQ_NAME_EFEM) {
			pJobDataS->setDeviceRecipeId(0, nRecipeID);
			}
			else if (name == EQ_NAME_BONDER1) {
			pJobDataS->setDeviceRecipeId(1, nRecipeID);
			}
			else if (name == EQ_NAME_BONDER2) {
			pJobDataS->setDeviceRecipeId(2, nRecipeID);
			}
			else if (name == EQ_NAME_BAKE_COOLING) {
			pJobDataS->setDeviceRecipeId(3, nRecipeID);
			}
			else if (name == EQ_NAME_VACUUMBAKE) {
			pJobDataS->setDeviceRecipeId(4, nRecipeID);
			}
			else if (name == EQ_NAME_MEASUREMENT) {
			pJobDataS->setDeviceRecipeId(5, nRecipeID);
			}
			}

			}
			}
			}
			}
			}


			}

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


			// 以下加入到曲线数据中
			LOGD("<Master>onSVDataReport 001");

			const int64_t ts = now_ms_epoch();
			int eqid = ((CEquipment*)pEquipment)->getID();
			if (eqid == EQ_ID_Bonder1 \|\| eqid == EQ_ID_Bonder2) {
			LOGD("<Master>onSVDataReport 002A");
			// 定义 Bonder 的特定映射
			std::vector<std::pair<int, int>> bonderMapping = {
			{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7},
			{8, 8}, {9, 9}, {10, 10}, {11, 11}, {12, 12}, {13, 13}, {14, 14}, {15, 15}, {16, 16}
			};

			CGlass* pGlass = ((CEquipment*)pEquipment)->getGlassFromSlot(2);
			auto& dataTypes = CServoUtilsTool::getEqDataTypes();
			auto& bonderTypes = dataTypes[SlotToMid(eqid, 2)];
			for (const auto& mapping : bonderMapping) {
			int paramIndex = mapping.first;
			int channel = mapping.second;

			if (paramIndex < params.size() && channel - 1 < bonderTypes.size()) {
			if(m_pCollector != nullptr)
			m_pCollector->buffersPush(SlotToMid(eqid, 2), channel, ts, params.at(paramIndex).getDoubleValue());
			if(pGlass != nullptr)
			pGlass->addSVData(eqid, bonderTypes[channel - 1], ts, params.at(paramIndex).getDoubleValue());
			}
			}
			}
			else if (eqid == EQ_ID_VACUUMBAKE) {
			LOGD("<Master>onSVDataReport 002");
			// 定义 VACUUMBAKE 的特定映射
			std::vector<std::pair<int, int>> vacuumMapping = {
			{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7},
			{10, 8}, {11, 9}, {12, 10}, {13, 11}, {14, 12}, {15, 13}, {16, 14}
			};

			CGlass* pGlass1 = ((CEquipment*)pEquipment)->getGlassFromSlot(1);
			CGlass* pGlass2 = ((CEquipment*)pEquipment)->getGlassFromSlot(2);
			auto& dataTypes = CServoUtilsTool::getEqDataTypes();
			auto& vacuumbakeTypes = dataTypes[SlotToMid(eqid, 1)];
			LOGD("<Master>onSVDataReport 003 : %d", vacuumMapping.size());
			for (const auto& mapping : vacuumMapping) {
			int paramIndex = mapping.first;
			int channel = mapping.second;

			if (paramIndex < params.size() && channel - 1 < vacuumbakeTypes.size()) {
			auto& param = params.at(paramIndex);
			double value = param.getDoubleValue();
			const std::string& dataType = vacuumbakeTypes[channel - 1];
			const std::string& paramName = param.getName();
			const char slotTag = !paramName.empty() ? paramName[0] : '\0';

			if (m_pCollector != nullptr) {
			if (slotTag == 'A')
			m_pCollector->buffersPush(SlotToMid(eqid, 1), channel, ts, value);
			else if (slotTag == 'B')
			m_pCollector->buffersPush(SlotToMid(eqid, 2), channel, ts, value);
			}

			// 根据腔体前缀写入对应 Slot 的玻璃
			if (pGlass1 != nullptr && !dataType.empty() && slotTag == 'A')
			pGlass1->addSVData(eqid, dataType, ts, value);
			if (pGlass2 != nullptr && !dataType.empty() && slotTag == 'B')
			pGlass2->addSVData(eqid, dataType, ts, value);
			}
			}
			}
			else if (eqid == EQ_ID_BAKE_COOLING) {
			LOGD("<Master>onSVDataReport 002B");
			// 定义 BAKE_COOLING 的特定映射
			std::vector<std::pair<int, int>> coolingMapping = {
			{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6},
			{11, 7}, {12, 8}, {13, 9}, {14, 10}, {15, 11}, {16, 12}
			};

			CGlass* pGlass1 = ((CEquipment*)pEquipment)->getGlassFromSlot(1); // A Bake
			CGlass* pGlass2 = ((CEquipment*)pEquipment)->getGlassFromSlot(2); // A Cool
			CGlass* pGlass3 = ((CEquipment*)pEquipment)->getGlassFromSlot(3); // B Bake
			CGlass* pGlass4 = ((CEquipment*)pEquipment)->getGlassFromSlot(4); // B Cool
			auto& dataTypes = CServoUtilsTool::getEqDataTypes();
			auto& coolingTypes = dataTypes[SlotToMid(eqid, 1)];
			LOGD("<Master>onSVDataReport 003B : %d", coolingMapping.size());
			auto addToGlass = [&](CGlass* glass, const std::string& type, double val) {
			if (glass != nullptr)
			glass->addSVData(eqid, type, ts, val);
			};
			for (const auto& mapping : coolingMapping) {
			int paramIndex = mapping.first;
			int channel = mapping.second;

			if (paramIndex < params.size() && channel - 1 < coolingTypes.size()) {
			auto& param = params.at(paramIndex);
			double value = param.getDoubleValue();
			const std::string& dataType = coolingTypes[channel - 1];
			const std::string& paramName = param.getName();
			const char slotTag = !paramName.empty() ? paramName[0] : '\0';
			const bool paramIsBake = paramName.find("烘烤") != std::string::npos;
			const bool paramIsCooling = paramName.find("冷却") != std::string::npos;

			if (m_pCollector != nullptr && paramIsBake) {
			if (slotTag == 'A')
			m_pCollector->buffersPush(SlotToMid(eqid, 1), channel, ts, value);
			else if (slotTag == 'B')
			m_pCollector->buffersPush(SlotToMid(eqid, 3), channel, ts, value);
			}

			if (!dataType.empty()) {
			switch (slotTag) {
			case 'A':
			if (paramIsBake)
			addToGlass(pGlass1, dataType, value);
			else if (paramIsCooling)
			addToGlass(pGlass2, dataType, value);
			break;
			case 'B':
			if (paramIsBake)
			addToGlass(pGlass3, dataType, value);
			else if (paramIsCooling)
			addToGlass(pGlass4, dataType, value);
			break;
			default:
			break;
			}
			}
			}
			}
			}


			// 以下是输出测试
			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);
			@@ -1197,7 +1832,7 @@
			}

			/*
			* 添加LoadPort1
			* 添加LoadPort1
			* index -- 0~3
			*/
			CLoadPort* CMaster::addLoadPort(int index)
			@@ -1217,7 +1852,7 @@


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


			return pEquipment;
			@@ -1236,7 +1871,7 @@


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

			@@ -1253,7 +1888,7 @@


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

			return pEquipment;
			}
			@@ -1271,7 +1906,7 @@


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

			return pEquipment;
			}
			@@ -1289,7 +1924,7 @@


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

			return pEquipment;
			}
			@@ -1305,7 +1940,7 @@


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

			return pEquipment;
			}
			@@ -1321,12 +1956,12 @@


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

			return pEquipment;
			}

			/* 添加bonder1 或 bonder2
			/* 添加bonder1 或 bonder2
			* index -- 0, bonder1
			* index -- 1, bonder2
			*/
			@@ -1345,7 +1980,7 @@


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


			return pEquipment;
			@@ -1363,7 +1998,7 @@
			addToEquipmentList(pEquipment);

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

			return pEquipment;
			}
			@@ -1380,7 +2015,7 @@
			addToEquipmentList(pEquipment);

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

			return pEquipment;
			}
			@@ -1395,7 +2030,7 @@
			static int i = 0;
			i++;

			// 自动保存缓存
			// 自动保存缓存
			if (i % (4 * 2) == 0) {
			if (m_bDataModify) {
			saveCacheAndBackups();
			@@ -1403,6 +2038,230 @@
			}
			}


			// 模拟测试（无机器联机时用于联调 EAP）
			// 读取 test.ini（当前目录或 exe 同目录）
			{
			struct SimCfg {
			bool enabled{ false };
			DWORD intervalMs{ 5000 };
			int step{ 0 };
			};
			auto loadCfg = [&]() -> SimCfg {
			SimCfg cfg;

			// Try INI: current dir, then exe dir
			char iniPath[MAX_PATH] = { 0 };
			strcpy_s(iniPath, "test.ini");
			auto readIni = [&](const char* path) -> bool {
			const UINT en = GetPrivateProfileIntA("SimEap", "Enabled", 0, path);
			if (en == 0) return false; // treat as missing/disabled
			cfg.enabled = (en != 0);
			cfg.intervalMs = (DWORD)GetPrivateProfileIntA("SimEap", "IntervalMs", 5000, path);
			cfg.intervalMs = max(500u, cfg.intervalMs);
			cfg.step = (int)GetPrivateProfileIntA("SimEap", "Step", 0, path);
			return true;
			};
			if (!readIni(iniPath)) {
			char exePath[MAX_PATH] = { 0 };
			GetModuleFileNameA(NULL, exePath, MAX_PATH);
			char* lastSlash = strrchr(exePath, '\\');
			if (lastSlash != nullptr) {
			*(lastSlash + 1) = '\0';
			strcat_s(exePath, "test.ini");
			readIni(exePath);
			}
			}
			return cfg;
			};

			const SimCfg cfg = loadCfg();
			if (cfg.enabled) {
			static DWORD lastTick = 0;
			static int lastExecutedStep = -1;
			static bool inited = false;
			static SERVO::CGlass simGlass;
			static SERVO::CVcrEventReport simVcr;
			static SERVO::CProcessJob simPj("PJ1001");
			static SERVO::CControlJob simCj("CJ5007");

			if (!inited) {
			inited = true;
			simGlass.setID("SIM_PANEL_001");
			simVcr.getGlassId() = "SIM_PANEL_001";
			}

			DWORD now = GetTickCount();
			if (lastTick == 0) lastTick = now;
			if ((now - lastTick) < cfg.intervalMs) {
			return;
			}
			lastTick = now;

			// 单步触发：每个 Step 只执行一次；你手动修改 ini 的 Step 值后会再次触发
			const int step = cfg.step;
			if (step <= 0 \|\| step == lastExecutedStep) {
			return;
			}
			lastExecutedStep = step;

			// 取一个 LoadPort 作为模拟目标
			SERVO::CLoadPort* pLpEq = (SERVO::CLoadPort*)getEquipment(EQ_ID_LOADPORT1);

			auto fireLoadPortStatus = [&](short status) {
			pLpEq->simulateSetCassetteId("Test-Cassette-001");
			if (m_listener.onLoadPortStatusChanged != nullptr && pLpEq != nullptr) {
			m_listener.onLoadPortStatusChanged(this, pLpEq, status, 0);
			}
			};
			auto fireProcessState = [&](SERVO::CEquipment* pEq, int slotNo, SERVO::PROCESS_STATE st) {
			if (m_listener.onProcessStateChanged != nullptr && pEq != nullptr) {
			m_listener.onProcessStateChanged(this, pEq, slotNo, st);
			}
			};

			LOGI("<Master>SIM_EAP single-step=%d", step);
			switch (step) {
			// ===== 业务流程步骤（1~23）=====
			case 1: // E87_06 Material Arrived(TransferBlock) -> Port Blocked
			fireLoadPortStatus(PORT_BLOCKED);
			break;
			case 2: // E87_03 CarrierID Readed -> Port InUse
			fireLoadPortStatus(PORT_INUSE);
			break;
			case 3: // S1F3 Query CJ Space (Host->EQ) - wait host
			LOGI("<Master>SIM_EAP step3: wait host S1F3");
			break;
			case 4: // S16F21 Query PJ Space (Host->EQ) - wait host
			LOGI("<Master>SIM_EAP step4: wait host S16F21");
			break;
			case 5: // S7F19 Query PPID List (Host->EQ) - wait host
			LOGI("<Master>SIM_EAP step5: wait host S7F19");
			break;
			case 6: // S3F17 ProceedWithCarrier (Host->EQ) - wait host
			LOGI("<Master>SIM_EAP step6: wait host S3F17 ProceedWithCarrier");
			break;
			case 7: // E87_14 Check SlotMap (设备上报/进入 WFH) - 由 PORT_INUSE 内部触发
			fireLoadPortStatus(PORT_INUSE);
			break;
			case 8: // S3F17 ProceedWithSlotMap (Host->EQ) - wait host
			LOGI("<Master>SIM_EAP step8: wait host S3F17 ProceedWithSlotMap");
			break;
			case 9: // SlotMap Verify OK (本项目在收到 ProceedWithSlotMap 后上报) - wait host
			LOGI("<Master>SIM_EAP step9: wait host ProceedWithSlotMap to trigger VerifyOK");
			break;
			case 10: // Create PJ (Host->EQ) - wait host
			LOGI("<Master>SIM_EAP step10: wait host S16F15 CreateMultiPJ");
			break;
			case 11: // PJ Queued（本项目在创建 PJ 后上报） - wait host
			LOGI("<Master>SIM_EAP step11: wait host CreateMultiPJ to trigger PJ_Queued");
			break;
			case 12: // Create CJ (Host->EQ) - wait host
			LOGI("<Master>SIM_EAP step12: wait host S14F9 CreateCJ");
			break;
			case 13: // CJ Start
			if (m_listener.onCjStart != nullptr) m_listener.onCjStart(this, &simCj);
			break;
			case 14: // PJ Start
			if (m_listener.onPjStart != nullptr) m_listener.onPjStart(this, &simPj);
			break;
			case 15: // OCR
			if (m_listener.onEqVcrEventReport != nullptr && pLpEq != nullptr) {
			m_listener.onEqVcrEventReport(this, pLpEq, &simVcr);
			}
			break;
			case 16: // Panel Start
			if (m_listener.onPanelStart != nullptr) m_listener.onPanelStart(this, &simGlass);
			// 同时触发一次子机台开始（示例：Bonder1, slot 1）
			fireProcessState(getEquipment(EQ_ID_Bonder1), 1, SERVO::PROCESS_STATE::Processing);
			break;
			case 17: // Panel End
			// 同时触发一次子机台结束（示例：Bonder1, slot 1）
			fireProcessState(getEquipment(EQ_ID_Bonder1), 1, SERVO::PROCESS_STATE::Complete);
			if (m_listener.onPanelEnd != nullptr) m_listener.onPanelEnd(this, &simGlass);
			break;
			case 18: // PJ End
			if (m_listener.onPjEnd != nullptr) m_listener.onPjEnd(this, &simPj);
			break;
			case 19: // CJ End
			if (m_listener.onCjEnd != nullptr) m_listener.onCjEnd(this, &simCj);
			break;
			case 20: // Ready to Release (Port Unload Ready; with prev INUSE will also trigger ReadyToRelease)
			fireLoadPortStatus(PORT_UNLOAD_READY);
			break;
			case 21: // CarrierRelease (Host->EQ) - optional / wait host
			LOGI("<Master>SIM_EAP step21: wait host S3F17 CarrierRelease");
			break;
			case 22: // Ready to Unload
			fireLoadPortStatus(PORT_UNLOAD_READY);
			break;
			case 23: // Material Removed (and ReadyToLoad)
			fireLoadPortStatus(PORT_LOAD_READY);
			fireLoadPortStatus(PORT_EMPTY); // will also raise LoadPortNotAssoc via Model
			break;
			default:
			break;
			}
			}
			}


			// 模拟测试
			/*
			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()
			@@ -1422,63 +2281,63 @@

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

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

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

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

			nRet = pBonder1->getPin("Out")->connectPin(pBakeCooling->getPin("In1"));
			if (nRet < 0) {
			LOGE("连接Bonder1-BakeCooling失败");
			LOGE("连接Bonder1-BakeCooling失败");
			}

			nRet = pBonder2->getPin("Out")->connectPin(pBakeCooling->getPin("In2"));
			if (nRet < 0) {
			LOGE("连接Bonder2-BakeCooling失败");
			LOGE("连接Bonder2-BakeCooling失败");
			}

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

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

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

			@@ -1502,7 +2361,7 @@
			saveCache();


			// 创建备份目录
			// 创建备份目录
			CString strNewFile;
			CString strFileDir = m_strFilepath.c_str();
			int index = strFileDir.ReverseFind('\\');
			@@ -1567,21 +2426,22 @@
			static int taskSeqNo = 0;
			CRobotTask* CMaster::createTransferTask(CEquipment* pSrcEq, CEquipment* pTarEq,
			MaterialsType primaryType/* = MaterialsType::G1/, MaterialsType secondaryType/ = MaterialsType::G2*/,
			int armNo/* = 1*/)
			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();
			@@ -1755,8 +2615,8 @@
			}
			unlock();

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

			return 0;
			@@ -1786,11 +2646,19 @@
			return 0;
			}

			void CMaster::setPortType(unsigned int index, BOOL enable, int type, int mode,
			int cassetteType, int transferMode, BOOL autoChangeEnable)
			void CMaster::setPortType(unsigned int index, int 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->localSetPortType((SERVO::PortType)type);
			}

			void CMaster::setPortTypeEx(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);
			@@ -1816,9 +2684,30 @@
			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)
			@@ -1883,9 +2772,51 @@
			temp.push_back(p);
			}
			}

			m_processJobs = temp;

			// 重置各端口 DownloadMap（Host/本地勾选的期望加工槽位）
			for (int i = 0; i < 4; i++) {
			auto* pPort = (CLoadPort*)getEquipment(EQ_ID_LOADPORT1 + i);
			if (pPort != nullptr) {
			pPort->setDownloadCassetteMap(0);
			}
			}


			// 更新context
			for (auto pj : m_processJobs) {
			for (auto& c : pj->carriers()) {
			auto pPort = getPortWithCarrierId(c.carrierId);
			if (pPort == nullptr) continue;

			short downloadMap = 0;
			for (auto s : c.slots) {
			if (s >= 1 && s <= 8) {
			downloadMap \|= (short)(1 << (s - 1));
			}
			}
			pPort->setDownloadCassetteMap((short)(pPort->getDownloadCassetteMap() \| downloadMap));

			std::vector<uint8_t> newSlots;
			std::vector<void*> newContexts;
			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();
			if (m_listener.onControlJobChanged) {
			m_listener.onControlJobChanged(this);
			}

			return (int)m_processJobs.size();
			}
			@@ -1906,23 +2837,23 @@

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


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

			// 回调：是否可加入 CJ（这里定义：必须是 Queued）
			// 回调：是否可加入 CJ（这里定义：必须是 Queued）
			auto pjJoinable = [&](const std::string& id) -> bool {
			auto pj = getProcessJob(id);
			if (pj == nullptr) return false;
			@@ -1943,6 +2874,9 @@
			}
			m_pControlJob->setPJs(temps);
			this->saveState();
			if (m_listener.onControlJobChanged) {
			m_listener.onControlJobChanged(this);
			}


			return 0;
			@@ -2003,47 +2937,43 @@
			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
			// 保存 ControlJob
			bool hasCJ = (m_pControlJob != nullptr);
			ofs.write(reinterpret_cast<const char*>(&hasCJ), sizeof(hasCJ));
			if (hasCJ) {
			m_pControlJob->serialize(ofs);
			}

			// 保存 ProcessJob 列表
			// 保存 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)
			bool CMaster::loadState()
			{
			// 保存文件路径
			m_strStatePath = path;


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

			@@ -2052,16 +2982,18 @@
			m_pControlJob = nullptr;
			}

			// 读取 ControlJob
			// 读取 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 列表
			// 读取 ProcessJob 列表
			uint32_t count = 0;
			ifs.read(reinterpret_cast<char*>(&count), sizeof(count));
			m_processJobs.clear();
			@@ -2072,7 +3004,7 @@
			}


			// 找到CProcessJob指针加入列表中
			// 找到CProcessJob指针加入列表中
			std::vector<CProcessJob*> tempPjs;
			auto ids = m_pControlJob->pjIds();
			for (auto id : ids) {
			@@ -2084,9 +3016,440 @@
			m_pControlJob->setPJs(tempPjs);


			// 如果版本升级，可在这里判断 version 来加载新字段
			// 更新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()
			{
			if (m_pControlJob == nullptr) {
			return false;
			}
			for (auto item : m_processJobs) {
			if (item->state() != PJState::Completed) return false;
			}
			if (m_pControlJob->state() != CJState::Completed)
			return false;



			// 释放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();
			if (m_listener.onControlJobChanged) {
			m_listener.onControlJobChanged(this);
			}

			return true;
			}

			bool CMaster::forceCompleteControlJob(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();
			if (m_listener.onControlJobChanged) {
			m_listener.onControlJobChanged(this);
			}

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

			void CMaster::CreateDAQBridgeServer()
			{
			auto connectionStatusCallback = [&](int code, const std::string& status) {
			LOGI("<DAQBridge>status:", status.c_str());
			};
			auto rawDataCallback = [](const std::vector<uint8_t>& bytes) {

			};

			// 事件：有人连入/断开就上日志
			auto clieintEventCallback = [](const std::string& ip, uint16_t port, bool connected) {
			LOGI("<DAQBridge>[Client %s] %s:%u", connected ? _T("JOIN") : _T("LEAVE"), ip.c_str(), port);
			};

			if (m_pCollector == nullptr) {
			m_pCollector = new Collector();
			m_pCollector->setConnectionStatusCallback(connectionStatusCallback);
			m_pCollector->setRawDataCallback(rawDataCallback);
			m_pCollector->setClientEventCallback(clieintEventCallback);
			m_pCollector->createServer(8081);
			m_pCollector->startLoop(10);

			// 1) 注册机台（推荐：先注册 id + 机器名称）
			RetentionPolicy defP; defP.mode = RetainMode::ByCount; defP.maxSamples = 200;
			m_pCollector->registryAddMachine(MID_Bonder1, "Bonder1", defP);
			m_pCollector->registryAddMachine(MID_Bonder2, "Bonder2", defP);
			m_pCollector->registryAddMachine(MID_VacuumBakeA, "前烘-A", defP);
			m_pCollector->registryAddMachine(MID_VacuumBakeB, "前烘-B", defP);
			m_pCollector->registryAddMachine(MID_BakeCoolingA, "后烘-A", defP);
			m_pCollector->registryAddMachine(MID_BakeCoolingB, "后烘-B", defP);


			// 2) 为通道设置“曲线名称”
			auto& dataTypes = CServoUtilsTool::getEqDataTypes();
			auto& bonderTypes = dataTypes[MID_Bonder1];
			for (size_t i = 0; i < bonderTypes.size(); ++i) {
			m_pCollector->buffersSetChannelName(MID_Bonder1, i + 1, bonderTypes[i].c_str());
			m_pCollector->buffersSetChannelName(MID_Bonder2, i + 1, bonderTypes[i].c_str());
			}

			auto& vacuumbakeTypes = dataTypes[MID_VacuumBakeA];
			for (size_t i = 0; i < vacuumbakeTypes.size(); ++i) {
			m_pCollector->buffersSetChannelName(MID_VacuumBakeA, i + 1, vacuumbakeTypes[i].c_str());
			m_pCollector->buffersSetChannelName(MID_VacuumBakeB, i + 1, vacuumbakeTypes[i].c_str());
			}

			auto& coolingTypes = dataTypes[MID_BakeCoolingA];
			for (size_t i = 0; i < coolingTypes.size(); ++i) {
			m_pCollector->buffersSetChannelName(MID_BakeCoolingA, i + 1, coolingTypes[i].c_str());
			m_pCollector->buffersSetChannelName(MID_BakeCoolingB, i + 1, coolingTypes[i].c_str());
			}
			}
			}

			uint32_t CMaster::SlotToMid(int eqid, int slot)
			{
			if (eqid == EQ_ID_Bonder1) {
			return MID_Bonder1;
			}

			if (eqid == EQ_ID_Bonder2) {
			return MID_Bonder2;
			}

			if (eqid == EQ_ID_VACUUMBAKE) {
			if(slot == 1)
			return MID_VacuumBakeA;
			if (slot == 2)
			return MID_VacuumBakeB;
			}

			if (eqid == EQ_ID_BAKE_COOLING) {
			if (slot == 1)
			return MID_BakeCoolingA;
			if (slot == 3)
			return MID_BakeCoolingB;
			}

			return 0;
			}
			}