~chenluhua/Bond2.git

			@@ -1,7 +1,22 @@
			#include "pch.h"
			#include "pch.h"
			#include "CHsmsActive.h"
			#include "Log.h"


			static unsigned short DATAID = 1;

			// Truncated SECS message logging to avoid overly long strings crashing UI/log
			static void LogSecsMessageBrief(const char* tag, IMessage* pMessage, size_t maxLen = 1024)
			{
			if (pMessage == nullptr) return;
			const char* msgStr = pMessage->toString();
			if (msgStr == nullptr) return;
			std::string buf(msgStr);
			if (buf.size() > maxLen) {
			buf = buf.substr(0, maxLen) + "...<truncated>";
			}
			LOGI("%s%s", tag, buf.c_str());
			}

			CHsmsActive::CHsmsActive()
			{
			@@ -62,13 +77,17 @@
			HEADER* pHeader = pMessage->getHeader();
			int nStream = (pHeader->stream & 0x7F);

			TRACE("收到消息 S%dF%d================\n", pHeader->stream & 0x7F, pHeader->function);
			TRACE("Body:%s\n", pMessage->toString());
			LOGI("onRecvDataMessage(%s).", pMessage->toString());
			TRACE("收到消息 S%dF%d================\n", pHeader->stream & 0x7F, pHeader->function);
			LogSecsMessageBrief("Body:", pMessage);
			LogSecsMessageBrief("onRecvDataMessage:", pMessage);

			if (nStream == 5 && pHeader->function == 1) {
			// S1F1
			// S5F1
			replyAck(5, 2, pMessage->getHeader()->systemBytes, 0, _T("ACK0"));
			}
			else if (nStream == 6 && pHeader->function == 11) {
			// S5F1
			replyAck(6, 12, pMessage->getHeader()->systemBytes, 0, _T("ACK0"));
			}
			};

			@@ -134,6 +153,48 @@
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);

			return 0;
			}

			int CHsmsActive::hsmsRequestOnline()
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 1 \| REPLY, 17, ++m_nSystemByte);
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);
			return 0;
			}

			int CHsmsActive::hsmsRequestOffline()
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 1 \| REPLY, 15, ++m_nSystemByte);
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);
			return 0;
			}

			int CHsmsActive::hsmsGoLocal()
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 2 \| REPLY, 41, ++m_nSystemByte);
			ISECS2Item* pBody = pMessage->getBody();
			pBody->addItem("GoLocal", "RCMD");
			pBody->addItem(); // L: empty params
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);
			return 0;
			}

			int CHsmsActive::hsmsGoRemote()
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 2 \| REPLY, 41, ++m_nSystemByte);
			ISECS2Item* pBody = pMessage->getBody();
			pBody->addItem("GoRemote", "RCMD");
			pBody->addItem(); // L: empty params
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);
			return 0;
			}

			@@ -222,12 +283,338 @@
			return 0;
			}

			int CHsmsActive::hsmsLinkEventReport(std::map<unsigned int, std::vector<unsigned int>>& mapEvent)
			{
			if (mapEvent.empty()) return 0;

			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 2 \| REPLY, 35, ++m_nSystemByte);
			ISECS2Item* pItem = pMessage->getBody();
			pItem->addU4Item(1, "DATAID");
			ISECS2Item* pItemEventList = pItem->addItem();
			for (auto item : mapEvent) {
			ISECS2Item* pItemEvent = pItemEventList->addItem();
			pItemEvent->addU4Item(item.first, "CEID");
			ISECS2Item* pItemRptidList = pItemEvent->addItem();
			for (auto vid : item.second) {
			pItemRptidList->addU4Item(vid, "RPTID");
			}
			}
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);

			return 0;
			}

			int CHsmsActive::hsmsConfigureSpooling(std::map<unsigned int, std::set<unsigned int>>& spoolingConfig)
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 2 \| REPLY, 43, ++m_nSystemByte);
			if (spoolingConfig.size() > 0) {
			for (auto s : spoolingConfig) {
			ISECS2Item* pItemStreamList = pMessage->getBody()->addItem();
			pItemStreamList->addU1Item(s.first, "STRID");
			ISECS2Item* pItemFcnList = pItemStreamList->addItem();
			for (auto f : s.second) {
			pItemFcnList->addU1Item(f, "FCNID");
			}
			}
			}

			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);

			return 0;
			}

			int CHsmsActive::hsmsTransmitSpooledData()
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 6 \| REPLY, 23, ++m_nSystemByte);
			pMessage->getBody()->setU1(0, "RSDC");
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);

			return 0;
			}

			int CHsmsActive::hsmsPurgeSpooledData()
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 6 \| REPLY, 23, ++m_nSystemByte);

			pMessage->getBody()->setU1(1, "RSDC");
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);

			return 0;
			}

			int CHsmsActive::hsmsSelectedEquipmentStatusRequest(unsigned int SVID)
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 1 \| REPLY, 3, ++m_nSystemByte);

			pMessage->getBody()->addU2Item(static_cast<unsigned short>(SVID), "SVID");
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);

			return 0;
			}

			int CHsmsActive::hsmsQueryAllStatusVariables()
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 1 \| REPLY, 11, ++m_nSystemByte);
			// Host sends L:0 (empty list) to request all SVIDs.
			pMessage->getBody()->addItem(); // empty list
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);
			return 0;
			}

			int CHsmsActive::hsmsQueryAllDataVariables()
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 1 \| REPLY, 21, ++m_nSystemByte);
			// Host sends L:0 (empty list) to request all DVIDs.
			pMessage->getBody()->addItem(); // empty list
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);
			return 0;
			}

			int CHsmsActive::hsmsQueryAllCollectionEvents()
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 1 \| REPLY, 23, ++m_nSystemByte);
			// Host sends L:0 (empty list) to request all CEIDs.
			pMessage->getBody()->addItem(); // empty list
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);
			return 0;
			}

			int CHsmsActive::hsmsEquipmentConstantRequest(const std::vector<unsigned short>& ecids)
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 2 \| REPLY, 13, ++m_nSystemByte);
			for (auto id : ecids) {
			pMessage->getBody()->addU2Item(id, "ECID");
			}
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);
			return 0;
			}

			int CHsmsActive::hsmsEquipmentConstantSend(const std::vector<std::pair<unsigned short, std::string>>& ecidValues)
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 2 \| REPLY, 15, ++m_nSystemByte);
			ISECS2Item* pBody = pMessage->getBody();
			for (const auto& kv : ecidValues) {
			ISECS2Item* pEntry = pBody->addItem();
			pEntry->addU2Item(kv.first, "ECID");
			pEntry->addItem(kv.second.c_str(), "ECV");
			}
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);
			return 0;
			}

			int CHsmsActive::hsmsQueryPPIDList()
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 7 \| REPLY, 19, ++m_nSystemByte);
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);

			return 0;
			}

			int CHsmsActive::hsmsDeletePPID(const std::vector<std::string>& ppids)
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 7 \| REPLY, 17, ++m_nSystemByte);
			if (nRet != 0 \|\| pMessage == nullptr) return -1;
			ISECS2Item* pBody = pMessage->getBody();
			for (const auto& ppid : ppids) {
			pBody->addItem(ppid.c_str(), "PPID");
			}
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);
			return 0;
			}

			int CHsmsActive::hsmsProcessProgramRequest(const char* pszPPID)
			{
			if (pszPPID == nullptr \|\| strlen(pszPPID) == 0) return -1;
			IMessage* pMessage = nullptr;
			if (HSMS_Create1Message(pMessage, m_nSessionId, 7 \| REPLY, 5, ++m_nSystemByte) != 0 \|\| pMessage == nullptr) {
			return -1;
			}
			pMessage->getBody()->setString(pszPPID, "PPID");
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);
			return 0;
			}

			int CHsmsActive::hsmsCarrierActionRequest(unsigned int DATAID,
			const char* pszCarrierAction,
			const char* pszCarrierId,
			unsigned char PTN)
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 3 \| REPLY, 17, ++m_nSystemByte);
			pMessage->getBody()->addU4Item(DATAID, "DATAID");
			pMessage->getBody()->addItem(pszCarrierAction, "CARRIERACTION");
			pMessage->getBody()->addItem(pszCarrierId, "CARRIERID");
			pMessage->getBody()->addU1Item(PTN, "PTN");
			pMessage->getBody()->addItem();
			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);

			return 0;
			}

			int CHsmsActive::hsmsProceedWithCarrier(unsigned int DATAID,
			const char* pszCarrierId,
			unsigned char PTN)
			{
			return hsmsCarrierActionRequest(DATAID, "ProceedWithCarrier", pszCarrierId, PTN);
			}

			int CHsmsActive::hsmsCarrierRelease(unsigned int DATAID,
			const char* pszCarrierId,
			unsigned char PTN)
			{
			return hsmsCarrierActionRequest(DATAID, "CarrierRelease", pszCarrierId, PTN);
			}

			int CHsmsActive::hsmsProceedWithSlotMap(unsigned int DATAID,
			const char* pszCarrierId,
			unsigned char PTN,
			const char* pszLotId,
			const std::vector<std::string>& panelIds,
			const std::vector<unsigned char>& slotMap)
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 3 \| REPLY, 17, ++m_nSystemByte);
			if (nRet != 0 \|\| pMessage == nullptr) {
			return nRet;
			}

			pMessage->getBody()->addU4Item(DATAID, "DATAID");
			pMessage->getBody()->addItem("ProceedWithSlotMap", "CARRIERACTION");
			pMessage->getBody()->addItem(pszCarrierId, "CARRIERID");
			pMessage->getBody()->addU1Item(PTN, "PTN");

			// Extended params (currently not parsed by Servo side): { LOTID, PANELID_LIST, SLOTMAP_LIST }
			ISECS2Item* pParams = pMessage->getBody()->addItem(); // L
			pParams->addItem(pszLotId != nullptr ? pszLotId : "", "LOTID");

			ISECS2Item* pPanelList = pParams->addItem(); // L
			for (const auto& id : panelIds) {
			pPanelList->addItem(id.c_str(), "PANELID");
			}

			ISECS2Item* pSlotMapList = pParams->addItem(); // L
			for (auto v : slotMap) {
			pSlotMapList->addU1Item(v, "SLOTSTATE");
			}

			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);

			return 0;
			}

			int CHsmsActive::hsmsPRJobMultiCreate(std::vector<SERVO::CProcessJob*>& pjs)
			{
			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 16 \| REPLY, 15, ++m_nSystemByte);
			char szMF[32] = {14};
			pMessage->getBody()->addU2Item(++DATAID, "DATAID");
			auto itemPjs = pMessage->getBody()->addItem();
			for (auto pj : pjs) {
			auto itemPj = itemPjs->addItem();
			itemPj->addItem(pj->id().c_str(), "PRJOBID");
			itemPj->addBinaryItem(szMF, 1, "MF");
			auto itemCarriers = itemPj->addItem();
			for (auto c : pj->carriers()) {
			auto itemCarrier = itemCarriers->addItem();
			itemCarrier->addItem(c.carrierId.c_str(), "CARRIERID");
			auto itemSlots = itemCarrier->addItem();
			for (auto s : c.slots) {
			itemSlots->addU1Item(s, "SLOTID");
			}
			}

			auto recipeItems = itemPj->addItem();
			recipeItems->addU1Item(1, "PRRECIPEMETHOD");
			recipeItems->addItem(pj->recipeSpec().c_str(), "RCPSPEC");
			recipeItems->addItem();

			itemPj->addBoolItem(false, "PRPROCESSSTART");
			itemPj->addItem();
			}

			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);

			return 0;
			}

			int CHsmsActive::hsmsCreateControlJob(const char* pszControlJobId, std::vector<std::string>& processJobIds)
			{
			char szBuffer[256];
			sprintf_s(szBuffer, 256, "ControlJob:%s>", pszControlJobId);

			IMessage* pMessage = nullptr;
			int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 14 \| REPLY, 9, ++m_nSystemByte);
			pMessage->getBody()->addItem(szBuffer, "OBJSPEC");
			pMessage->getBody()->addItem("ControlJob", "OBJTYPE");
			auto itemAttrs = pMessage->getBody()->addItem();

			{
			auto itemAttr = itemAttrs->addItem();
			itemAttr->addItem("Priority", "ATTRID");
			itemAttr->addU1Item(8, "ATTRDATA");
			}

			{
			auto itemAttr = itemAttrs->addItem();
			itemAttr->addItem("weight", "ATTRID");
			itemAttr->addF4Item(60.5, "ATTRDATA");
			}

			{
			auto itemAttr = itemAttrs->addItem();
			itemAttr->addItem("tel", "ATTRID");
			itemAttr->addItem("15919875007", "ATTRDATA");
			}

			{
			auto itemAttr = itemAttrs->addItem();
			itemAttr->addItem("PRJOBLIST", "ATTRID");
			auto itemProcessJobs = itemAttr->addItem();
			for (auto& item : processJobIds) {
			itemProcessJobs->addItem(item.c_str(), "");
			}
			}

			m_pActive->sendMessage(pMessage);
			HSMS_Destroy1Message(pMessage);

			return 0;
			}

			int CHsmsActive::replyAck0(IMessage* pMessage)
			{
			return 0;
			}

			// 通用的reply ack函数
			// 通用的reply ack函数
			void CHsmsActive::replyAck(int s, int f, unsigned int systemBytes, BYTE ack, const char* pszAckName)
			{
			IMessage* pMessage = NULL;