From adf46e4da2f53d171cc5a0e95340d751ebacf763 Mon Sep 17 00:00:00 2001
From: mrDarker <mr.darker@163.com>
Date: 星期四, 26 六月 2025 14:25:31 +0800
Subject: [PATCH] Merge branch 'clh' into liuyang

---
 SourceCode/Bond/Servo/CEquipment.cpp | 1188 +++++++++++++++++++++++++++++++++++++++++++++++------------
 1 files changed, 946 insertions(+), 242 deletions(-)

diff --git a/SourceCode/Bond/Servo/CEquipment.cpp b/SourceCode/Bond/Servo/CEquipment.cpp
index b14e096..5518246 100644
--- a/SourceCode/Bond/Servo/CEquipment.cpp
+++ b/SourceCode/Bond/Servo/CEquipment.cpp
@@ -3,6 +3,8 @@
 #include "ToolUnits.h"
 #include <regex>
 #include "CArm.h"
+#include "CGlassPool.h"
+#include "Servo.h"
 
 
 #define CHECK_READ_STEP_SIGNAL(addr, data, size) {							\
@@ -25,7 +27,7 @@
 
 	CEquipment::CEquipment() : m_nID(0), m_strName(""), m_strDescription(""), m_station(0, 255)
 	{
-		m_listener = { nullptr, nullptr, nullptr, nullptr, nullptr };
+		m_listener = { };
 		m_alive = { FALSE, 0, FALSE };
 		m_bCimState = FALSE;
 		m_bUpstreamInline = FALSE;
@@ -33,18 +35,24 @@
 		m_bLocalAlarm = FALSE;
 		m_bAutoRecipeChange = FALSE;
 		m_bVCREnable[0] = FALSE;
+		memset(m_bLinkSignalToUpstream, 0, sizeof(m_bLinkSignalToUpstream));
+		memset(m_bLinkSignalToDownstream, 0, sizeof(m_bLinkSignalToDownstream));
 		m_pCclink = nullptr;
 		m_nBaseAlarmId = 0;
 		m_pArm = nullptr;
+		m_processState = PROCESS_STATE::Ready;
+		m_blockReadBit = { 0 };
 		InitializeCriticalSection(&m_criticalSection);
 	}
 
 	CEquipment::~CEquipment()
 	{
-		for (auto item : m_glassList) {
-			item->release();
+		for (int i = 0; i < SLOT_MAX; i++) {
+			CContext* pContext = m_slot[i].getContext();
+			if (pContext != nullptr) {
+				m_slot[i].setContext(nullptr);
+			}
 		}
-		m_glassList.clear();
 
 		for (auto item : m_mapStep) {
 			delete item.second;
@@ -66,11 +74,7 @@
 
 	void CEquipment::setListener(EquipmentListener listener)
 	{
-		m_listener.onAlive = listener.onAlive;
-		m_listener.onCimStateChanged = listener.onCimStateChanged;
-		m_listener.onAlarm = listener.onAlarm;
-		m_listener.onDataChanged = listener.onDataChanged;
-		m_listener.onVcrEventReport = listener.onVcrEventReport;
+		m_listener = listener;
 	}
 
 	void CEquipment::setCcLink(CCCLinkIEControl* pCcLink)
@@ -83,6 +87,11 @@
 		ASSERT(pEquipment->isArm());
 		ASSERT(!this->isArm());
 		m_pArm = pEquipment;
+	}
+
+	CEquipment* CEquipment::getArm()
+	{
+		return m_pArm;
 	}
 
 	void CEquipment::setBaseAlarmId(int nBaseId)
@@ -138,10 +147,21 @@
 		return 0;
 	}
 
+	void CEquipment::setProcessState(PROCESS_STATE state)
+	{
+		m_processState = state;
+		onProcessStateChanged(m_processState);
+
+		if (m_listener.onProcessStateChanged != nullptr) {
+			m_listener.onProcessStateChanged(this, m_processState);
+		}
+	}
+
 	void CEquipment::init()
 	{
 		initPins();
 		initSteps();
+		initSlots();
 		for (auto item : m_mapStep) {
 			item.second->init();
 		}
@@ -203,48 +223,68 @@
 	void CEquipment::getAttributeVector(CAttributeVector& attrubutes)
 	{
 		attrubutes.clear();
+
+		unsigned int weight = 0;
 		attrubutes.addAttribute(new CAttribute("Network",
-			std::to_string(m_station.nNetNo).c_str(), ""));
+			std::to_string(m_station.nNetNo).c_str(), "", weight++));
 		attrubutes.addAttribute(new CAttribute("Station",
-			std::to_string(m_station.nStNo).c_str(), ""));
+			std::to_string(m_station.nStNo).c_str(), "", weight++));
 		attrubutes.addAttribute(new CAttribute("ID",
-			std::to_string(m_nID).c_str(), ""));
+			std::to_string(m_nID).c_str(), "", weight++));
 		attrubutes.addAttribute(new CAttribute("Name",
-			m_strName.c_str(), ""));
+			m_strName.c_str(), "", weight++));
 		attrubutes.addAttribute(new CAttribute("Description",
-			m_strDescription.c_str(), ""));
+			m_strDescription.c_str(), "", weight++));
 		attrubutes.addAttribute(new CAttribute("Alive",
-			this->isAlive() ? _T("TRUE") : _T("FALSE"), ""));
+			this->isAlive() ? _T("TRUE") : _T("FALSE"), "", weight++));
 		attrubutes.addAttribute(new CAttribute("CIM State",
-			m_bCimState ? _T("ON") : _T("OFF"), ""));
+			m_bCimState ? _T("ON") : _T("OFF"), "", weight++));
 		attrubutes.addAttribute(new CAttribute("Upstream",
-			m_bUpstreamInline ? _T("Inline") : _T("Offline"), ""));
+			m_bUpstreamInline ? _T("Inline") : _T("Offline"), "", weight++));
 		attrubutes.addAttribute(new CAttribute("Downstream",
-			m_bDownstreamInline ? _T("Inline") : _T("Offline"), ""));
+			m_bDownstreamInline ? _T("Inline") : _T("Offline"), "", weight++));
 		attrubutes.addAttribute(new CAttribute("Local Alarm",
-			m_bLocalAlarm ? _T("TRUE") : _T("FALSE"), ""));
+			m_bLocalAlarm ? _T("TRUE") : _T("FALSE"), "", weight++));
 		attrubutes.addAttribute(new CAttribute("Auto Recipe Change",
-			m_bAutoRecipeChange ? _T("TRUE") : _T("FALSE"), ""));
+			m_bAutoRecipeChange ? _T("TRUE") : _T("FALSE"), "", weight++));
 		char szTemp[256];
 		for (int i = 0; i < VCR_MAX; i++) {
 			sprintf_s(szTemp, 256, "VCR-%d", i + 1);
 			attrubutes.addAttribute(new CAttribute(szTemp,
-				m_bVCREnable[i] ? _T("Enable") : _T("Disable"), ""));
+				m_bVCREnable[i] ? _T("Enable") : _T("Disable"), "", weight++));
 		}
 
 		for (auto item : m_inputPins) {
 			attrubutes.addAttribute(new CAttribute(item->getName().c_str(),
-				std::to_string((int)item->getType()).c_str(), ""));
+				std::to_string((int)item->getType()).c_str(), "", weight++));
 		}
 
 		for (auto item : m_outputPins) {
 			attrubutes.addAttribute(new CAttribute(item->getName().c_str(),
-				std::to_string((int)item->getType()).c_str(), ""));
+				std::to_string((int)item->getType()).c_str(), "", weight++));
 		}
 
-		for (auto item : m_glassList) {
-			attrubutes.addAttribute(new CAttribute("Glass",
-				item->getID().c_str(), ""));
+		for (int i = 0; i < SLOT_MAX; i++) {
+			if (!m_slot[i].isEnable()) continue;
+
+			CGlass* pGlass = (CGlass*)m_slot[i].getContext();
+			CGlass* pBuddy = nullptr;
+			if (pGlass == nullptr) {
+				attrubutes.addAttribute(new CAttribute(m_slot[i].getName().c_str(),
+					"", "", weight++));
+			}
+			else {
+				pBuddy = pGlass->getBuddy();
+				if (pBuddy == nullptr) {
+					attrubutes.addAttribute(new CAttribute(m_slot[i].getName().c_str(),
+						pGlass->getID().c_str(), "", weight++));
+				}
+				else {
+					attrubutes.addAttribute(new CAttribute(m_slot[i].getName().c_str(),
+						(pGlass->getID() + " -> " + pBuddy->getID()).c_str(), "", weight++));
+				}
+			}
+
 		}
 	}
 
@@ -296,23 +336,54 @@
 	{
 		if (ar.IsStoring()) {
 			Lock();
-			int count = (int)m_glassList.size();
-			ar << count;
-			for (auto item : m_glassList) {
-				item->serialize(ar);
+			for (int i = 0; i < SLOT_MAX; i++) {
+				m_slot[i].serialize(ar);
+				CGlass* pGlass = (CGlass *)m_slot[i].getContext();
+				if (pGlass != nullptr) {					
+					pGlass->serialize(ar);
+					CGlass* pBuddy = pGlass->getBuddy();
+					if (pBuddy != nullptr) {
+						pBuddy->serialize(ar);
+					}
+				}
 			}
 			Unlock();
 		}
 		else {
+			for (int i = 0; i < SLOT_MAX; i++) {
+				m_slot[i].serialize(ar);
+				if (m_slot[i].getTempContext() != nullptr) {
+					CGlass* pGlass = theApp.m_model.m_glassPool.allocaGlass();
+					pGlass->serialize(ar);
+					m_slot[i].setContext(pGlass);
+					if (pGlass->getBuddy() != nullptr) {
+						CGlass* pBuddy = theApp.m_model.m_glassPool.allocaGlass();
+						pBuddy->serialize(ar);
+						pGlass->forceSetBuddy(pBuddy);
+					}
+				}
+			}
+			
+			// 梳理各玻璃之间的绑定关系
+			/*
 			Lock();
-			int count;
-			ar >> count;
-			for (int i = 0; i < count; i++) {
-				CGlass* pGlass = new CGlass();
-				pGlass->serialize(ar);
-				addGlassToList(pGlass);
+			for (int i = 0; i < SLOT_MAX; i++) {
+				CGlass* pGlass = (CGlass*)m_slot[i].getContext();
+				if (pGlass != nullptr) {
+					std::string& strBuddyId = pGlass->getBuddyId();
+					if (!strBuddyId.empty()) {
+						for (int j = 0; j < SLOT_MAX; j++) {
+							CGlass* pBudy = (CGlass*)m_slot[j].getContext();
+							if (pBudy != nullptr && strBuddyId.compare(pBudy->getID()) == 0) {
+								pGlass->setBuddy(pBudy);
+								TRACE("绑定关系: %s <- %s\n", pGlass->getID().c_str(), pBudy->getID().c_str());
+							}
+						}
+					}
+				}
 			}
 			Unlock();
+			*/
 		}
 	}
 
@@ -326,9 +397,34 @@
 		}
 		*/
 
-		// 以下解释和处理数据
+		// 连接信号解释和保存
 		BOOL bFlag;
-		int index = 0x540;
+		int index = 0;
+		for (int i = 0; i < 8; i++) {
+			m_bLinkSignalToUpstream[i][SIGNAL_UPSTREAM_INLINE] = isBitOn(pszData, size, index + 0);
+			m_bLinkSignalToUpstream[i][SIGNAL_UPSTREAM_TROUBLE] = isBitOn(pszData, size, index + 1);
+			m_bLinkSignalToUpstream[i][SIGNAL_INTERLOCK] = isBitOn(pszData, size, index + 2);
+			m_bLinkSignalToUpstream[i][SIGNAL_SEND_ABLE] = isBitOn(pszData, size, index + 3);
+			index += 0x40;
+		}		 
+		if(m_bLinkSignalToUpstream[0][SIGNAL_SEND_ABLE]) {
+			onSendAble();
+		}
+
+		index += 0x40 * 2;
+		for (int i = 0; i < 8; i++) {
+			m_bLinkSignalToDownstream[i][SIGNAL_UPSTREAM_INLINE] = isBitOn(pszData, size, index + 0);
+			m_bLinkSignalToDownstream[i][SIGNAL_UPSTREAM_TROUBLE] = isBitOn(pszData, size, index + 1);
+			m_bLinkSignalToDownstream[i][SIGNAL_INTERLOCK] = isBitOn(pszData, size, index + 2);
+			m_bLinkSignalToDownstream[i][SIGNAL_RECEIVE_ABLE] = isBitOn(pszData, size, index + 3);
+			index += 0x40;
+		}
+		if (m_bLinkSignalToDownstream[0][SIGNAL_RECEIVE_ABLE]) {
+			onReceiveAble();
+		}
+
+		// 其它信号及响应
+		index = 0x540;
 
 
 		// alive
@@ -469,30 +565,45 @@
 
 
 		// CEqCassetteTranserStateStep
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_EMPTY, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_LOAD_READY, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_LOADED, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_INUSE, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_UNLOAD_READY, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_BLOCKED, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_EMPTY, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_LOAD_READY, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_LOADED, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_INUSE, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_UNLOAD_READY, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_BLOCKED, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_EMPTY, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_LOAD_READY, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_LOADED, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_INUSE, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_UNLOAD_READY, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_BLOCKED, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_EMPTY, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_LOAD_READY, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_LOADED, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_INUSE, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_UNLOAD_READY, pszData, size);
-		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_BLOCKED, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_EMPTY, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_LOAD_READY, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_LOADED, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_INUSE, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_UNLOAD_READY, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_BLOCKED, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_EMPTY, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_LOAD_READY, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_LOADED, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_INUSE, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_UNLOAD_READY, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_BLOCKED, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_EMPTY, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_LOAD_READY, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_LOADED, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_INUSE, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_UNLOAD_READY, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_BLOCKED, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_EMPTY, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_LOAD_READY, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_LOADED, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_INUSE, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_UNLOAD_READY, pszData, size);
+		CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_BLOCKED, pszData, size);
+
+		// robot cmd reply
+		CHECK_WRITE_STEP_SIGNAL(STEP_ID_ROBOT_CMD_REPLY, pszData, size);
+
+		// Indexer Operation Mode Change
+		CHECK_WRITE_STEP_SIGNAL(STEP_ID_IN_OP_CMD_REPLY, pszData, size);
+
+		// Panel Data Report
+		CHECK_WRITE_STEP_SIGNAL(STEP_ID_PANEL_DATA_REPORT, pszData, size);
+
+		// Panel Data Request
+		CHECK_WRITE_STEP_SIGNAL(STEP_ID_PANEL_DATA_REQUEST, pszData, size);	
+
+		// Job Data Request
+		CHECK_READ_STEP_SIGNAL(STEP_ID_JOB_DATA_REQUEST, pszData, size);
 	}
 
 	BOOL CEquipment::isBitOn(const char* pszData, size_t size, int index)
@@ -545,6 +656,50 @@
 		return m_bVCREnable[index];
 	}
 
+	BOOL CEquipment::isLinkSignalUpstreamOn(unsigned int path, unsigned int signal)
+	{
+		if (path >= PATH_MAX) return FALSE;
+		if (signal >= SIGNAL_MAX) return FALSE;
+		return m_bLinkSignalToUpstream[path][signal];
+	}
+
+	BOOL CEquipment::isLinkSignalDownstreamOn(unsigned int path, unsigned int signal)
+	{
+		if (path >= PATH_MAX) return FALSE;
+		if (signal >= SIGNAL_MAX) return FALSE;
+		return m_bLinkSignalToDownstream[path][signal];
+	}
+
+	void CEquipment::setLinkSignalUpstream(unsigned int path, unsigned int signal, BOOL bOn)
+	{
+		if (path >= PATH_MAX) return;
+		if (signal >= SIGNAL_MAX) return;
+		m_bLinkSignalToUpstream[path][signal] = bOn;
+	}
+
+	void CEquipment::setLinkSignalUpstreamBlock(unsigned int path, BOOL* pSignal)
+	{
+		if (path >= PATH_MAX) return;
+		for (int i = 0; i < SIGNAL_MAX; i++) {
+			m_bLinkSignalToUpstream[path][i] = pSignal[i];
+		}
+	}
+
+	void CEquipment::setLinkSignalDownstream(unsigned int path, unsigned int signal, BOOL bOn)
+	{
+		if (path >= PATH_MAX) return;
+		if (signal >= SIGNAL_MAX) return;
+		m_bLinkSignalToDownstream[path][signal] = bOn;
+	}
+
+	void CEquipment::setLinkSignalDownstreamBlock(unsigned int path, BOOL* pSignal)
+	{
+		if (path >= PATH_MAX) return;
+		for (int i = 0; i < SIGNAL_MAX; i++) {
+			m_bLinkSignalToDownstream[path][i] = pSignal[i];
+		}
+	}
+
 	int CEquipment::onStepEvent(CStep* pStep, int code)
 	{
 		if (code == STEP_EVENT_READDATA) {
@@ -571,6 +726,7 @@
 				panelNo = (value & 0xffff);
 				LOGI("Cim Message Confirm(msgID = %d, panel no.=%d).", msgId, panelNo);
 			}
+			/*
 			else if (isVcrEventStep(pStep)) {
 				SERVO::CEqVcrEventStep* pEqVcrEventStep = (SERVO::CEqVcrEventStep*)pStep;
 				CVcrEventReport* pVcrEventReport = pEqVcrEventStep->getVcrEventReport();
@@ -583,6 +739,7 @@
 				pEqVcrEventStep->setReturnCode(1);		
 				return 1;
 			}
+			*/
 		}
 
 
@@ -638,6 +795,11 @@
 		return m_outputPins;
 	}
 
+	CRecipeList* CEquipment::getRecipeList(int unitNo)
+	{
+		return m_recipesManager.getRecipeList(unitNo);
+	}
+
 	int CEquipment::recvIntent(CPin* pPin, CIntent* pIntent)
 	{
 		ASSERT(pPin);
@@ -664,163 +826,13 @@
 		// 测试
 		if (code == FLOW_TEST) {
 			AfxMessageBox(pIntent->getMsg());
-			return FLOW_ACCEPT;
 		}
 
-
-		// 信号
-		if (code == FLOW_SIGNAL) {
-			return FLOW_ACCEPT;
-		}
-
-
-		// 数据
-		if (code == FLOW_SIGNAL) {
-			return FLOW_ACCEPT;
-		}
-
-
-		// 物料
-		if (code == FLOW_MOVE_MATERIAL) {
-			CGlass* pGlass = (CGlass*)pIntent->getContext();
-			ASSERT(pGlass);
-			if (!glassWillArrive(pGlass)) {
-				return FLOW_REJECT;
-			}
-			return glassArrived(pGlass);
-		}
-
-
-
-		return FLOW_ACCEPT;
-	}
-
-	int CEquipment::outputGlass(int port)
-	{
-		CPin* pOutPin = nullptr;
-		if (port == 0) {
-			pOutPin = getPin("Out");
-			if (pOutPin == nullptr) {
-				pOutPin = getPin("Out1");
-			}
-		}
-		else if (port == 1) {
-			pOutPin = getPin("Out2");
-		}
-		if (pOutPin == nullptr) {
-			return -1;
-		}
-
-
-		// 模拟取出第一张Panel,传送到下一环节
-		ULONGLONG time = CToolUnits::getTimestamp();
-		Lock();
-		if (m_glassList.empty()) {
-			Unlock();
-			return -2;
-		}
-		CGlass* pContext = m_glassList.front();
-		pContext->addRef();
-
-		CIntent intent(FLOW_MOVE_MATERIAL, "", pContext);
-		int nRet = pOutPin->sendIntent(&intent);
-		if (nRet == FLOW_REJECT) {
-			LOGE("<CEquipment>对方拒绝接收Intent.");
-		}
-		else if (nRet == FLOW_ACCEPT) {
-			CPath* pPath = pContext->getPathWithSiteID(m_nID);
-			if (pPath != nullptr) {
-				pPath->setOutTime(time);
-			}
-			m_glassList.pop_front();
-			pContext->release();		// 添加到列队时addRef, 取出时release
-			if (m_listener.onDataChanged != nullptr) {
-				m_listener.onDataChanged(this, 0);
-			}
-		}
-
-		pContext->release();
-		Unlock();
 
 		return 0;
 	}
 
-	BOOL CEquipment::glassWillArrive(CGlass* pGlass)
-	{
-		return TRUE;
-	}
-
-	int CEquipment::glassArrived(CGlass* pGlass)
-	{
-		Lock();
-		pGlass->addPath(m_nID);
-		pGlass->addRef();
-		m_glassList.push_back(pGlass);
-		Unlock();
-
-		if (m_listener.onDataChanged != nullptr) {
-			m_listener.onDataChanged(this, 0);
-		}
-
-		return FLOW_ACCEPT;
-	}
-
-	void CEquipment::addGlassToList(CGlass* pGlass)
-	{
-		ASSERT(pGlass);
-
-		Lock();
-		pGlass->addRef();
-		m_glassList.push_back(pGlass);
-		Unlock();
-
-		if (m_listener.onDataChanged != nullptr) {
-			m_listener.onDataChanged(this, 0);
-		}
-	}
-
-	BOOL CEquipment::removeClass(CGlass* pGlass)
-	{
-		Lock();
-		bool bExist = std::find(m_glassList.begin(), m_glassList.end(), pGlass) != m_glassList.end();
-		if (bExist) {
-			pGlass->addPath(EQ_ID_OPERATOR_REMOVE);
-			pGlass->release();
-			m_glassList.remove(pGlass);
-		}
-		Unlock();
-
-		if (bExist && m_listener.onDataChanged != nullptr) {
-			m_listener.onDataChanged(this, 0);
-		}
-
-		return bExist;
-	}
-
-	void CEquipment::getGlassList(std::list<CGlass*>& list)
-	{
-		Lock();
-		for (auto item : m_glassList) {
-			item->addRef();
-			list.push_back(item);
-		}
-		Unlock();
-	}
-
-	CGlass* CEquipment::getFrontGlass()
-	{
-		CGlass* pGlass = nullptr;
-
-		Lock();
-		if (!m_glassList.empty()) {
-			pGlass = m_glassList.front();
-		}
-		Unlock();
-
-		return pGlass;
-	}
-
-	int CEquipment::fetchedOut(const char* pszGlassId)
+	int CEquipment::fetchedOutJob(CJobDataB* pJobDataB)
 	{
 		if (m_pArm == nullptr) {
 			return -1;
@@ -828,16 +840,13 @@
 
 		// 找到指定的glass id, 
 		Lock();
-		if (m_glassList.empty()) {
-			Unlock();
-			return -2;
-		}
-
 		CGlass* pContext = nullptr;
-		for (auto iter = m_glassList.begin(); iter != m_glassList.end(); iter++) {
-			if ((*iter)->getID().compare(pszGlassId) == 0) {
-				pContext = (*iter);
-				m_glassList.erase(iter);
+		for (int i = 0; i < SLOT_MAX; i++) {
+			CGlass* pGlass = (CGlass*)m_slot[i].getContext();
+			if (pGlass != nullptr && compareJobData(pJobDataB, pGlass->getJobDataS())) {
+				pContext = pGlass;
+				if (pGlass != nullptr) pGlass->addRef();
+				m_slot[i].setContext(nullptr);
 				break;
 			}
 		}
@@ -846,18 +855,24 @@
 			return -3;
 		}
 
+
 		((CArm*)m_pArm)->tempStore(pContext);
 		pContext->release();
 		Unlock();
 
+
+		if (m_processState != PROCESS_STATE::Ready) {
+			setProcessState(PROCESS_STATE::Ready);
+		}
+
 		if (m_listener.onDataChanged != nullptr) {
-			m_listener.onDataChanged(this, 0);
+			m_listener.onDataChanged(this, EDCC_FETCHOUT_JOB);
 		}
 
 		return 0;
 	}
 
-	int CEquipment::storedJob(const char* pszGlassId)
+	int CEquipment::storedJob(CJobDataB* pJobDataB, short putSlot)
 	{
 		if (m_pArm == nullptr) {
 			return -1;
@@ -871,22 +886,100 @@
 
 		ASSERT(pGlass);
 		Lock();
-		pGlass->addPath(m_nID);
-		pGlass->addRef();					// 加入list,addRef
-		m_glassList.push_back(pGlass);
+		pGlass->addPath(m_nID, getSlotUnit(putSlot));
+		m_slot[putSlot - 1].setContext(pGlass);
 		pGlass->release();				// tempFetchOut需要调用一次release
 		Unlock();
 
-		if (m_listener.onDataChanged != nullptr) {
-			m_listener.onDataChanged(this, 0);
+		if (m_processState != PROCESS_STATE::Processing) {
+			setProcessState(PROCESS_STATE::Processing);
 		}
 
+		if (m_listener.onDataChanged != nullptr) {
+			m_listener.onDataChanged(this, EDCC_STORED_JOB);
+		}
+		
 		return 0;
 	}
 
-	BOOL CEquipment::isGlassListEmpty()
+	BOOL CEquipment::hasGlass()
 	{
-		return m_glassList.empty();
+		for (int i = 0; i < SLOT_MAX; i++) {
+			if (m_slot[i].isEnable() && !m_slot[i].isEmpty()) {
+				return TRUE;
+			}
+		}
+
+		return FALSE;
+	}
+
+	CGlass* CEquipment::getGlass(const char* pszGlassId)
+	{
+		for (int i = 0; i < SLOT_MAX; i++) {
+			if (!m_slot[i].isEnable()) continue;
+			CGlass* pGlass = (CGlass*)m_slot[i].getContext();
+			if (pGlass == nullptr) continue;
+			if (pGlass->getID().compare(pszGlassId) == 0) {
+				return pGlass;
+			}
+		}
+
+		return nullptr;
+	}
+
+	CGlass* CEquipment::getGlassFromSlot(int slotNo)
+	{
+		CSlot* pSlot = nullptr;
+		for (int i = 0; i < SLOT_MAX; i++) {
+			if (!m_slot[i].isEnable()) continue;
+			if (m_slot[i].getNo() != slotNo) continue;
+			pSlot = &m_slot[i];
+			break;
+		}
+
+		if (pSlot != nullptr) {
+			return (CGlass*)pSlot->getContext();
+		}
+
+		return nullptr;
+	}
+
+	CGlass* CEquipment::getGlassWithCassette(int cassetteSequenceNo, int jobSequenceNo)
+	{
+		CSlot* pSlot = nullptr;
+		for (int i = 0; i < SLOT_MAX; i++) {
+			if (!m_slot[i].isEnable()) continue;
+			CGlass* pGlass = (CGlass*)m_slot[i].getContext();
+			if (pGlass == nullptr) continue;
+			CJobDataS* pJobDataS = pGlass->getJobDataS();
+			ASSERT(pJobDataS);
+			if (pJobDataS->getCassetteSequenceNo() == cassetteSequenceNo
+				&& pJobDataS->getJobSequenceNo() == jobSequenceNo) {
+				return pGlass;
+			}
+		}
+
+
+		return nullptr;
+	}
+
+	CJobDataS* CEquipment::getJobDataSWithCassette(int cassetteSequenceNo, int jobSequenceNo)
+	{
+		CSlot* pSlot = nullptr;
+		for (int i = 0; i < SLOT_MAX; i++) {
+			if (!m_slot[i].isEnable()) continue;
+			CGlass* pGlass = (CGlass*)m_slot[i].getContext();
+			if (pGlass == nullptr) continue;
+			CJobDataS* pJobDataS = pGlass->getJobDataS();
+			ASSERT(pJobDataS);
+			if (pJobDataS->getCassetteSequenceNo() == cassetteSequenceNo
+				&& pJobDataS->getJobSequenceNo() == jobSequenceNo) {
+				return pJobDataS;
+			}
+		}
+
+
+		return nullptr;
 	}
 
 	bool CEquipment::isAlarmStep(SERVO::CStep* pStep)
@@ -999,7 +1092,67 @@
 		return pStep->setDateTime(year, month, day, hour, minute, second);
 	}
 
-	int CEquipment::masterRecipeListRequest(short unitNo)
+	int CEquipment::setDispatchingMode(DISPATCHING_MODE mode, ONWRITED onWritedBlock/* = nullptr*/)
+	{
+		SERVO::CEqWriteStep* pStep = (SERVO::CEqWriteStep*)getStepWithName(STEP_EQ_DISPATCHINT_MODE_CHANGE);
+		if (pStep == nullptr) {
+			return -1;
+		}
+
+		LOGI("<CEquipment-%s>准备设置DispatchingMode<%d>", m_strName.c_str(), (int)mode);
+		if (onWritedBlock != nullptr) {
+			pStep->writeShort((short)mode, onWritedBlock);
+		}
+		else {
+			pStep->writeShort((short)mode, [&, mode](int code) -> int {
+				if (code == WOK) {
+					LOGI("<CEquipment-%s>设置DispatchingMode成功.", m_strName.c_str());
+				}
+				else {
+					LOGI("<CEquipment-%s>设置DispatchingMode失败，code:%d", m_strName.c_str(), code);
+				}
+
+				return 0;
+				});
+		}
+
+		return 0;
+	}
+
+	int CEquipment::indexerOperationModeChange(IDNEXER_OPERATION_MODE mode, ONWRITEDRET onWritedRetBlock)
+	{
+		SERVO::CEqWriteStep* pStep = (SERVO::CEqWriteStep*)getStepWithName(STEP_EQ_IN_OP_MODE_CHANGE);
+		if (pStep == nullptr) {
+			return -1;
+		}
+
+		unsigned short operationMode = (unsigned short)((unsigned short)mode + getIndexerOperationModeBaseValue());
+		LOGI("<CEquipment-%s>准备设置indexerOperationMode<%d>", m_strName.c_str(), (int)mode);
+		pStep->writeShort(operationMode, [&, pStep, mode, onWritedRetBlock](int code) -> int {
+			int retCode = 0;
+			if (code == WOK) {
+				LOGI("<CEquipment-%s>设置indexerOperationMode成功.", m_strName.c_str());
+				const char* pszRetData = nullptr;
+				pStep->getReturnData(pszRetData);
+				ASSERT(pszRetData);
+				retCode = (unsigned int)CToolUnits::toInt16(pszRetData);
+				LOGI("<CEquipment-%s>返回值: %d", m_strName.c_str(), retCode);
+			}
+			else {
+				LOGI("<CEquipment-%s>设置indexerOperationMode失败，code:%d", m_strName.c_str(), code);
+			}
+
+			if (onWritedRetBlock != nullptr) {
+				onWritedRetBlock(code, retCode);
+			}
+
+			return 0;
+		});
+
+		return 0;
+	}
+
+	int CEquipment::masterRecipeListRequest(short unitNo, ONSYNCINGSTATECHANGED block)
 	{
 		SERVO::CEqWriteStep* pStep = (SERVO::CEqWriteStep*)getStepWithName(STEP_EQ_MASTER_RECIPE_LIST_REQ);
 		if (pStep == nullptr) {
@@ -1007,6 +1160,7 @@
 		}
 
 		LOGI("<CEquipment-%s>正在请求单元<%d>主配方列表", m_strName.c_str(), unitNo);
+		m_recipesManager.setOnSyncingStateChanged(block);
 		if (m_recipesManager.syncing() != 0) {
 			return -2;
 		}
@@ -1049,6 +1203,190 @@
 		return 0;
 	}
 
+	CSlot* CEquipment::getAvailableSlot()
+	{
+		for (int i = 0; i < SLOT_MAX; i++) {
+			if (!m_slot[i].isEnable()) continue;
+			if (m_slot[i].isLock()) continue;
+			if (!m_slot[i].isEmpty()) continue;
+
+			return &m_slot[i];
+		}
+
+		return nullptr;
+	}
+
+	CSlot* CEquipment::getAvailableSlotForGlass(MaterialsType type)
+	{
+		for (int i = 0; i < SLOT_MAX; i++) {
+			if (!m_slot[i].isEnable()) continue;
+			if (m_slot[i].isLock()) continue;
+			if (!m_slot[i].isEmpty()) continue;
+			int lsPath = m_slot[i].getLinkSignalPath();
+			if (!m_bLinkSignalToDownstream[lsPath][SIGNAL_UPSTREAM_INLINE]
+				|| m_bLinkSignalToDownstream[lsPath][SIGNAL_UPSTREAM_TROUBLE]
+				|| !m_bLinkSignalToDownstream[lsPath][SIGNAL_INTERLOCK]
+				|| !m_bLinkSignalToDownstream[lsPath][SIGNAL_RECEIVE_ABLE]) continue;
+
+			MaterialsType slotType = m_slot[i].getType();
+			if (type == MaterialsType::G1 && slotType == MaterialsType::G2) continue;
+			if (type == MaterialsType::G2 && slotType == MaterialsType::G1) continue;
+
+			return &m_slot[i];
+		}
+
+		return nullptr;
+	}
+
+	CSlot* CEquipment::getAvailableSlotForGlassExcludeSignal(MaterialsType type)
+	{
+		for (int i = 0; i < SLOT_MAX; i++) {
+			if (!m_slot[i].isEnable()) continue;
+			if (m_slot[i].isLock()) continue;
+			if (!m_slot[i].isEmpty()) continue;
+
+			MaterialsType slotType = m_slot[i].getType();
+			if (type == MaterialsType::G1 && slotType == MaterialsType::G2) continue;
+			if (type == MaterialsType::G2 && slotType == MaterialsType::G1) continue;
+
+			return &m_slot[i];
+		}
+
+		return nullptr;
+	}
+
+	CSlot* CEquipment::getAvailableSlotForGlass2(MaterialsType type, const std::vector<int>& candidates)
+	{
+		for (auto item : candidates) {
+			for (int i = 0; i < SLOT_MAX; i++) {
+				if (item == i + 1) {
+					if (!m_slot[i].isEnable()) continue;
+					if (m_slot[i].isLock()) continue;
+					if (!m_slot[i].isEmpty()) continue;
+
+					MaterialsType slotType = m_slot[i].getType();
+					if (type == MaterialsType::G1 && slotType == MaterialsType::G2) continue;
+					if (type == MaterialsType::G2 && slotType == MaterialsType::G1) continue;
+
+					return &m_slot[i];
+				}
+			}
+		}
+
+		return nullptr;
+	}
+
+	CSlot* CEquipment::getNonEmptySlot(MaterialsType putSlotType)
+	{
+		for (int i = 0; i < SLOT_MAX; i++) {
+			if (!m_slot[i].isEnable()) continue;
+			if (m_slot[i].isLock()) continue;
+			CGlass* pGlass = (CGlass*)m_slot[i].getContext();
+			if (pGlass == nullptr) continue;
+
+			MaterialsType glassType = pGlass->getType();
+			if (glassType == MaterialsType::G1 && putSlotType == MaterialsType::G2) continue;
+			if (glassType == MaterialsType::G2 && putSlotType == MaterialsType::G1) continue;
+
+			return &m_slot[i];
+		}
+
+		return nullptr;
+	}
+
+	CSlot* CEquipment::getProcessedSlot(MaterialsType putSlotType)
+	{
+		for (int i = 0; i < SLOT_MAX; i++) {
+			if (!m_slot[i].isEnable()) continue;
+			if (m_slot[i].isLock()) continue;
+			CGlass* pGlass = (CGlass*)m_slot[i].getContext();
+			if (pGlass == nullptr) continue;
+			int lsPath = m_slot[i].getLinkSignalPath();
+			if(!m_bLinkSignalToUpstream[lsPath][SIGNAL_UPSTREAM_INLINE]
+				|| m_bLinkSignalToUpstream[lsPath][SIGNAL_UPSTREAM_TROUBLE]
+				|| !m_bLinkSignalToUpstream[lsPath][SIGNAL_INTERLOCK]
+				|| !m_bLinkSignalToUpstream[lsPath][SIGNAL_SEND_ABLE] ) continue;
+
+			MaterialsType glassType = pGlass->getType();
+			if (glassType == MaterialsType::G1 && putSlotType == MaterialsType::G2) continue;
+			if (glassType == MaterialsType::G2 && putSlotType == MaterialsType::G1) continue;
+
+			return &m_slot[i];
+		}
+
+		return nullptr;
+	}
+
+	CSlot* CEquipment::getProcessedSlot2(MaterialsType putSlotType, const std::vector<int>& candidates)
+	{
+		for (auto item : candidates) {
+			for (int i = 0; i < SLOT_MAX; i++) {
+				if (item == i + 1) {
+					if (!m_slot[i].isEnable()) continue;
+					if (m_slot[i].isLock()) continue;
+					CGlass* pGlass = (CGlass*)m_slot[i].getContext();
+					if (pGlass == nullptr) continue;
+					int lsPath = m_slot[i].getLinkSignalPath();
+					if (!m_bLinkSignalToUpstream[lsPath][SIGNAL_UPSTREAM_INLINE]
+						|| m_bLinkSignalToUpstream[lsPath][SIGNAL_UPSTREAM_TROUBLE]
+						|| !m_bLinkSignalToUpstream[lsPath][SIGNAL_INTERLOCK]
+						|| !m_bLinkSignalToUpstream[lsPath][SIGNAL_SEND_ABLE]) continue;
+
+					MaterialsType glassType = pGlass->getType();
+					if (glassType == MaterialsType::G1 && putSlotType == MaterialsType::G2) continue;
+					if (glassType == MaterialsType::G2 && putSlotType == MaterialsType::G1) continue;
+
+					return &m_slot[i];
+				}
+			}
+		}
+
+		return nullptr;
+	}
+
+	CSlot* CEquipment::getSlot(int index)
+	{
+		if (index >= SLOT_MAX) return nullptr;
+		return &m_slot[index];
+	}
+
+	CGlass* CEquipment::getAnyGlass()
+	{
+		CSlot* pSlot = nullptr;
+		for (int i = 0; i < SLOT_MAX; i++) {
+			if (!m_slot[i].isEnable()) continue;
+			CGlass* pGlass = (CGlass*)m_slot[i].getContext();
+			if (pGlass == nullptr) continue;
+			return pGlass;
+		}
+
+		return nullptr;
+	}
+
+	BOOL CEquipment::canPlaceGlassInSlot(const short slotIndex)
+	{
+		if (slotIndex >= SLOT_MAX) return FALSE;
+		if (!m_slot[slotIndex].isEnable()) return FALSE;
+		if (m_slot[slotIndex].getContext() != nullptr) return FALSE;
+
+		return TRUE;
+	}
+
+	int CEquipment::removeGlass(int slotNo)
+	{
+		CSlot* pSlot = nullptr;
+		for (int i = 0; i < SLOT_MAX; i++) {
+			if (!m_slot[i].isEnable()) continue;
+			if (m_slot[i].getNo() != slotNo) continue;
+			pSlot = &m_slot[i];
+			break;
+		}
+
+		if (pSlot == nullptr) return -1;
+		pSlot->setContext(nullptr);
+		return 0;
+	}
+
 	short CEquipment::decodeRecipeListReport(const char* pszData, size_t size)
 	{
 		return m_recipesManager.decodeRecipeListReport(pszData, size);
@@ -1059,12 +1397,90 @@
 		return m_recipesManager.decodeRecipeParameterReport(pszData, size);
 	}
 
-	int CEquipment::decodeFetchedOutJobReport(int port, const char* pszData, size_t size)
+	int CEquipment::decodeProcessDataReport(CStep* pStep, const char* pszData, size_t size)
+	{
+		CProcessData processData;
+		int nRet = processData.unserialize(&pszData[0], (int)size);
+		if (nRet < 0) return nRet;
+
+		// 缓存Attribute，用于调试时显示信息
+		unsigned int weight = 201;
+		CAttributeVector attrubutes;
+		processData.getAttributeVector(attrubutes, weight);
+		pStep->addAttributeVector(attrubutes);
+
+
+		onProcessData(&processData);
+
+		return nRet;
+	}
+
+	int CEquipment::decodeReceivedJobReport(CStep* pStep, int port, const char* pszData, size_t size)
+	{
+		CJobDataS jobDataS;
+		int nRet = jobDataS.unserialize(&pszData[0], (int)size);
+		if (nRet < 0) return nRet;
+
+		// 缓存Attribute，用于调试时显示信息
+		unsigned int weight = 201;
+		CAttributeVector attrubutes;
+		jobDataS.getAttributeVector(attrubutes, weight);
+		pStep->addAttributeVector(attrubutes);
+
+
+		onReceivedJob(port, &jobDataS);
+
+		return nRet;
+	}
+
+	int CEquipment::onReceivedJob(int port, CJobDataS* pJobDataS)
+	{
+		LOGI("<CEquipment-%s>onReceivedJob.", m_strName.c_str());
+		return 0;
+	}
+
+	int CEquipment::decodeSentOutJobReport(CStep* pStep, int port, const char* pszData, size_t size)
+	{
+		CJobDataS jobDataS;
+		int nRet = jobDataS.unserialize(&pszData[0], (int)size);
+		if (nRet < 0) return nRet;
+
+		// 缓存Attribute，用于调试时显示信息
+		unsigned int weight = 201;
+		CAttributeVector attrubutes;
+		jobDataS.getAttributeVector(attrubutes, weight);
+		pStep->addAttributeVector(attrubutes);
+
+
+		onSentOutJob(port, &jobDataS);
+
+		return nRet;
+	}
+
+	int CEquipment::onSentOutJob(int port, CJobDataS* pJobDataS)
+	{
+		LOGI("<CEquipment-%s>onSentOutJob.", m_strName.c_str());
+
+
+		// 可以在此更新JobDataS数据了
+		CGlass* pGlass = getGlass(pJobDataS->getGlass1Id().c_str());
+		if (pGlass == nullptr) {
+			LOGE("<CEquipment-%s>onSentOutJob,没有找到对应的Glass(CassetteSequenceNo:%d, JobSequenceNo:%d, ID=%s)，请检查数据，注意风险。",
+				m_strName.c_str(), pJobDataS->getCassetteSequenceNo(), pJobDataS->getJobSequenceNo(),
+				pJobDataS->getGlass1Id().c_str());
+			return -1;
+		}
+		pGlass->updateJobDataS(pJobDataS);
+
+		return 0;
+	}
+
+	int CEquipment::decodeFetchedOutJobReport(CStep* pStep, int port, const char* pszData, size_t size)
 	{
 		int index = 0;
 		short unitOrPort, unitOrPortNo, subUnitNo, subSlotNo;
 		CJobDataB jobDataB;
-		int nRet = jobDataB.unserialize(&pszData[index], size);
+		int nRet = jobDataB.unserialize(&pszData[index], (int)size);
 		if (nRet < 0) return nRet;
 		index += nRet;
 
@@ -1077,22 +1493,63 @@
 		memcpy(&subSlotNo, &pszData[index], sizeof(short));
 		index += sizeof(short);
 
-		onFetchedOut(port, jobDataB.getGlassId().c_str());
+
+		// 缓存Attribute，用于调试时显示信息
+		unsigned int weight = 201;
+		pStep->addAttribute(new CAttribute("UnitOrPort",
+			std::to_string(unitOrPort).c_str(), "", weight++));
+		pStep->addAttribute(new CAttribute("UnitOrPortNo",
+			std::to_string(unitOrPortNo).c_str(), "", weight++));
+		pStep->addAttribute(new CAttribute("SubUnitNo",
+			std::to_string(subUnitNo).c_str(), "", weight++));
+		pStep->addAttribute(new CAttribute("SubSlotNo",
+			std::to_string(subSlotNo).c_str(), "", weight++));
+		pStep->addAttribute(new CAttribute("CassetteSequenceNo",
+			std::to_string(jobDataB.getCassetteSequenceNo()).c_str(), "", weight++));
+		pStep->addAttribute(new CAttribute("JobSequenceNo",
+			std::to_string(jobDataB.getJobSequenceNo()).c_str(), "", weight++));
+		pStep->addAttribute(new CAttribute("GlassId",
+			jobDataB.getGlassId().c_str(), "", weight++));
+
+
+		onFetchedOutJob(port, &jobDataB);
 
 		return index;
 	}
 
-	int CEquipment::onFetchedOut(int port, const char* pszGlassId)
+	BOOL CEquipment::onPreFetchedOutJob(int port, CJobDataB* pJobDataB)
 	{
-		return fetchedOut(pszGlassId);
+		LOGI("<CEquipment-%s>onPreFetchedOutJob:port:%d|GlassId:%s",
+			m_strName.c_str(), port, pJobDataB->getGlassId().c_str());
+		if (m_listener.onPreFethedOutJob != nullptr) {
+			return m_listener.onPreFethedOutJob(this, pJobDataB);
+		}
+
+		return TRUE;
 	}
 
-	int CEquipment::decodeStoredJobReport(int port, const char* pszData, size_t size)
+	int CEquipment::onFetchedOutJob(int port, CJobDataB* pJobDataB)
+	{
+		LOGI("<CEquipment-%s>onFetchedOutJob:port:%d|GlassId:%s", 
+			m_strName.c_str(), port, pJobDataB->getGlassId().c_str());
+
+		BOOL bCheck = onPreFetchedOutJob(port, pJobDataB);
+		if (bCheck) {
+			return fetchedOutJob(pJobDataB);
+		}
+
+		// 数据异常，处理或显示
+		LOGI("<CEquipment-%s>onFetchedOutJob Error.ort:%d|GlassId:%s",
+			m_strName.c_str(), port, pJobDataB->getGlassId().c_str());
+		return -1;
+	}
+
+	int CEquipment::decodeStoredJobReport(CStep* pStep, int port, const char* pszData, size_t size)
 	{
 		int index = 0;
 		short unitOrPort, unitOrPortNo, subUnitNo, subSlotNo;
 		CJobDataB jobDataB;
-		int nRet = jobDataB.unserialize(&pszData[index], size);
+		int nRet = jobDataB.unserialize(&pszData[index], (int)size);
 		if (nRet < 0) return nRet;
 		index += nRet;
 
@@ -1105,13 +1562,260 @@
 		memcpy(&subSlotNo, &pszData[index], sizeof(short));
 		index += sizeof(short);
 
-		onStore(port, jobDataB.getGlassId().c_str());
+
+		// 缓存Attribute，用于调试时显示信息
+		unsigned int weight = 201;
+		pStep->addAttribute(new CAttribute("UnitOrPort",
+			std::to_string(unitOrPort).c_str(), "", weight++));
+		pStep->addAttribute(new CAttribute("UnitOrPortNo",
+			std::to_string(unitOrPortNo).c_str(), "", weight++));
+		pStep->addAttribute(new CAttribute("SubUnitNo",
+			std::to_string(subUnitNo).c_str(), "", weight++));
+		pStep->addAttribute(new CAttribute("SubSlotNo",
+			std::to_string(subSlotNo).c_str(), "", weight++));
+		pStep->addAttribute(new CAttribute("CassetteSequenceNo",
+			std::to_string(jobDataB.getCassetteSequenceNo()).c_str(), "", weight++));
+		pStep->addAttribute(new CAttribute("JobSequenceNo",
+			std::to_string(jobDataB.getJobSequenceNo()).c_str(), "", weight++));
+		pStep->addAttribute(new CAttribute("GlassId",
+			jobDataB.getGlassId().c_str(), "", weight++));
+
+
+		onStoredJob(port, &jobDataB);
 
 		return index;
 	}
 
-	int CEquipment::onStore(int port, const char* pszGlassId)
+	int CEquipment::decodeVCREventReport(CStep* pStep, const char* pszData, size_t size)
 	{
-		return storedJob(pszGlassId);
+		CVcrEventReport vcrEventReport;
+		vcrEventReport.unserialize(pszData, size);
+		LOGI("<CEquipment-%s>decodeVCREventReport<Result:%d, GlassId:%s>\n", m_strName.c_str(),
+			vcrEventReport.getVcrResult(),
+			vcrEventReport.getGlassId().c_str());
+
+
+		// 缓存Attribute，用于调试时显示信息
+		unsigned int weight = 201;
+		CAttributeVector attrubutes;
+		vcrEventReport.getAttributeVector(attrubutes, weight);
+		pStep->addAttributeVector(attrubutes);
+
+		// 0426, 先固定返回1(OK)
+		((CReadStep*)pStep)->setReturnCode((short)VCR_Reply_Code::OK);
+
+		return 0;
+	}
+
+	int CEquipment::decodePanelDataReport(CStep* pStep, const char* pszData, size_t size)
+	{
+		short cassetteNo, jobSequenceNo;
+		int index = 0;
+		std::string strPanelJudgeData, strPanelGradeData;
+		memcpy(&cassetteNo, &pszData[index], sizeof(short));
+		index += sizeof(short);
+		memcpy(&jobSequenceNo, &pszData[index], sizeof(short));
+		index += sizeof(short);
+		CToolUnits::convertString(&pszData[index], 128 * 2, strPanelJudgeData);
+		index += 128 * 2;
+		CToolUnits::convertString(&pszData[index], 256 * 2, strPanelJudgeData);
+		index += 256 * 2;
+
+
+		// 缓存Attribute，用于调试时显示信息
+		unsigned int weight = 201;
+		pStep->addAttribute(new CAttribute("CassetteNo",
+			std::to_string(cassetteNo).c_str(), "", weight++));
+		pStep->addAttribute(new CAttribute("JobSequenceNo",
+			std::to_string(jobSequenceNo).c_str(), "", weight++));
+		pStep->addAttribute(new CAttribute("PanelJudgeData",
+			strPanelJudgeData.c_str(), "", weight++));
+		pStep->addAttribute(new CAttribute("PanelGradeData",
+			strPanelGradeData.c_str(), "", weight++));
+
+
+		return 0;
+	}
+
+	int CEquipment::decodeFacDataReport(CStep* pStep, const char* pszData, size_t size)
+	{
+		int index = 0;
+		std::string strSvTimeRecord, strSvData;
+		CToolUnits::convertString(&pszData[index], 8 * 2, strSvTimeRecord);
+		index += 128 * 2;
+		CToolUnits::convertString(&pszData[index], 640 * 2, strSvData);
+		index += 256 * 2;
+
+
+		// 缓存Attribute，用于调试时显示信息
+		unsigned int weight = 201;
+		pStep->addAttribute(new CAttribute("SV Time Record",
+			strSvTimeRecord.c_str(), "", weight++));
+		pStep->addAttribute(new CAttribute("SV Data",
+			strSvData.c_str(), "", weight++));
+
+
+		return 0;
+	}
+
+	int CEquipment::decodeJobDataRequest(CStep* pStep, const char* pszData, size_t size)
+	{
+		int index = 0;
+		short cassetteSequenceNo, jobSequenceNo;
+		memcpy(&cassetteSequenceNo, &pszData[index], sizeof(short));
+		index += sizeof(short);
+		memcpy(&jobSequenceNo, &pszData[index], sizeof(short));
+		index += sizeof(short);
+		cassetteSequenceNo = 4000;
+		jobSequenceNo = 1;
+
+
+
+		// 缓存Attribute，用于调试时显示信息
+		unsigned int weight = 201;
+		pStep->addAttribute(new CAttribute("CassetteSequenceNo",
+			(std::to_string(cassetteSequenceNo)).c_str(), "", weight++));
+		pStep->addAttribute(new CAttribute("JobSequenceNo",
+			(std::to_string(jobSequenceNo)).c_str(), "", weight++));
+
+
+		return 0;
+	}
+
+	int CEquipment::onPreStoredJob(int port, CJobDataB* pJobDataB, short& putSlot)
+	{
+		LOGI("<CEquipment-%s>onPreStoredJob:port:%d|GlassId:%s",
+			m_strName.c_str(), port, pJobDataB->getGlassId().c_str());
+
+		// 当前要存片，之前肯定有拔片，因此片子在Arm那里
+		CGlass* pGlass = ((CArm*)m_pArm)->getGlassFromSlot(1);
+		if (pGlass == nullptr) {
+			LOGE("<CFliper-%s>onPreStoredJob,缓存中没有找到对应的Glass(CassetteSequenceNo:%d, JobSequenceNo:%d)，请检查数据，注意风险。", m_strName.c_str(),
+				pJobDataB->getCassetteSequenceNo(), pJobDataB->getJobSequenceNo());
+			return FALSE;
+		}
+
+		CJobDataS* pJobDataS = pGlass->getJobDataS();
+		ASSERT(pJobDataS);
+		if (!compareJobData(pJobDataB, pJobDataS)) {
+			LOGE("<CEquipemnt-%s>onPreFetchedOutJob,JobData数据不匹配(JobDataB(%d, %d),JobDataS(%d, %d)), 注意排查风险!", m_strName.c_str(),
+				pJobDataB->getCassetteSequenceNo(), pJobDataB->getJobSequenceNo(),
+				pJobDataS->getCassetteSequenceNo(), pJobDataS->getJobSequenceNo());
+			return FALSE;
+		}
+
+		// 如果没有可用位置，报错
+		Lock();
+		CSlot* pSlot = getAvailableSlotForGlassExcludeSignal((MaterialsType)pJobDataS->getMaterialsType());
+		if (pSlot == nullptr) {
+			Unlock();
+			LOGE("<CEquipemnt-%s>onPreFetchedOutJob,找不到匹配的Slot，不能进料，请注意风险！", m_strName.c_str());
+			return FALSE;
+		}
+		Unlock();
+
+
+		if (m_listener.onPreStoredJob != nullptr) {
+			if (!m_listener.onPreStoredJob(this, pJobDataB, putSlot)) {
+				return FALSE;
+			}
+
+			if(!canPlaceGlassInSlot(putSlot - 1)) {
+				return FALSE;
+			}
+		}
+
+		return TRUE;
+	}
+
+	int CEquipment::onStoredJob(int port, CJobDataB* pJobDataB)
+	{
+		LOGI("<CEquipment-%s>onStore:port:%d|GlassId:%s",
+			m_strName.c_str(), port, pJobDataB->getGlassId().c_str());
+
+		short putSlot = 0;
+		BOOL bCheck = onPreStoredJob(port, pJobDataB, putSlot);
+		if (bCheck) {
+			return storedJob(pJobDataB, putSlot);
+		}
+
+		// 数据异常，处理或显示
+		LOGI("<CEquipment-%s>onStoredJob Error.ort:%d|GlassId:%s",
+			m_strName.c_str(), port, pJobDataB->getGlassId().c_str());
+		return -1;
+	}
+
+	int CEquipment::onProcessData(CProcessData* pProcessData)
+	{
+		LOGI("<CEquipment-%s>onProcessData.", m_strName.c_str());
+
+		return 0;
+	}
+
+	/*
+	 * 当从CC-Link检测到设备Send Able为On时调用此函数
+	 * 可能会多次重复调用(根据扫描频率), 注意防呆
+	 */
+	int CEquipment::onSendAble()
+	{
+		LOGI("<CEquipment-%s>onSendAble.", m_strName.c_str());
+
+		if (m_processState != PROCESS_STATE::Complete) {
+			setProcessState(PROCESS_STATE::Complete);
+		}
+
+		return 0;
+	}
+
+	int CEquipment::onReceiveAble()
+	{
+		LOGI("<CEquipment-%s>onReceiveAble.", m_strName.c_str());
+
+		return 0;
+	}
+
+	int CEquipment::onProcessStateChanged(PROCESS_STATE state)
+	{
+		return 0;
+	}
+
+	int CEquipment::getIndexerOperationModeBaseValue()
+	{
+		return 0;
+	}
+
+	BOOL CEquipment::compareJobData(CJobDataB* pJobDataB, CJobDataS* pJobDataS)
+	{
+		ASSERT(pJobDataB);
+		ASSERT(pJobDataS);
+
+		if (pJobDataB->getCassetteSequenceNo() != pJobDataS->getCassetteSequenceNo())
+			return FALSE;
+		if (pJobDataB->getJobSequenceNo() != pJobDataS->getJobSequenceNo())
+			return FALSE;
+
+		return TRUE;
+	}
+
+	void CEquipment::printDebugString001()
+	{
+		for (int i = 0; i < 8; i++) {
+			LOGI("<CEquipment-%s>Link Signal to UP stream Path#%d, Signal:%s, %s, %s, %s",
+				m_strName.c_str(), i,
+				m_bLinkSignalToUpstream[i][SIGNAL_UPSTREAM_INLINE] ? "ON" : "OFF",
+				m_bLinkSignalToUpstream[i][SIGNAL_UPSTREAM_TROUBLE] ? "ON" : "OFF",
+				m_bLinkSignalToUpstream[i][SIGNAL_INTERLOCK] ? "ON" : "OFF",
+				m_bLinkSignalToUpstream[i][SIGNAL_SEND_ABLE] ? "ON" : "OFF"
+			);
+		}
+		for (int i = 0; i < 8; i++) {
+			LOGI("<CEquipment-%s>Link Signal to Down stream Path#%d, Signal:%s, %s, %s, %s",
+				m_strName.c_str(), i,
+				m_bLinkSignalToDownstream[i][SIGNAL_UPSTREAM_INLINE] ? "ON" : "OFF",
+				m_bLinkSignalToDownstream[i][SIGNAL_UPSTREAM_TROUBLE] ? "ON" : "OFF",
+				m_bLinkSignalToDownstream[i][SIGNAL_INTERLOCK] ? "ON" : "OFF",
+				m_bLinkSignalToDownstream[i][SIGNAL_SEND_ABLE] ? "ON" : "OFF"
+			);
+		}
 	}
 }
\ No newline at end of file

--
Gitblit v1.9.3