#include "stdafx.h"
#include "Common.h"
#include "CMaster.h"
#include <future>
#include <vector>


namespace SERVO {
	CMaster* g_pMaster = NULL;

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

		return 0;
	}

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

		return 0;
	}

	void CALLBACK MasterTimerProc(HWND hWnd, UINT nMsg, UINT nTimerid, DWORD dwTime)
	{
		if (g_pMaster != NULL) {
			g_pMaster->onTimer(nTimerid);
		}
	}

	CMaster::CMaster()
	{
		m_listener = {};
		m_bDataModify = FALSE;
		m_hEventReadBitsThreadExit[0] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
		m_hEventReadBitsThreadExit[1] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
		m_hReadBitsThreadHandle = nullptr;
		m_nReadBitsThreadAddr = 0;
		m_hDispatchEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
		m_hEventDispatchThreadExit[0] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
		m_hEventDispatchThreadExit[1] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
		m_hDispatchThreadHandle = nullptr;
		m_nDispatchThreadAddr = 0;
		m_ullStartTime = 0;
		m_ullRunTime = 0;
		m_state = MASTERSTATE::READY;
		m_pActiveRobotTask = nullptr;
		m_nLastError = 0;
		m_bEnableEventReport = true;
		m_bEnableAlarmReport = true;
		InitializeCriticalSection(&m_criticalSection);
	}

	CMaster::~CMaster()
	{
		if (m_hEventReadBitsThreadExit[0] != nullptr) {
			::CloseHandle(m_hEventReadBitsThreadExit[0]);
			m_hEventReadBitsThreadExit[0] = nullptr;
		}

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

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

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

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

		DeleteCriticalSection(&m_criticalSection);
	}

	void CMaster::setListener(MasterListener listener)
	{
		m_listener = listener;
	}

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

	int CMaster::init()
	{
		LOGI("<Master>ÕýÔÚ³õʼ»¯...");


		// 	cclink
		if (m_cclink.Connect(CC_LINK_IE_CONTROL_CHANNEL(1)) != 0) {
			LOGE("Á¬½ÓCC-Linkʧ°Ü.");
		}
		else {
			LOGI("Á¬½ÓCC-Link³É¹¦.");
			BoardVersion version{};
			int nRet = m_cclink.GetBoardVersion(version);
			if (nRet == 0) {
				LOGI("°æ±¾ÐÅÏ¢£º%s.", version.toString().c_str());
			}
			else {
				LOGE("»ñÈ¡CC-Link°æ±¾ÐÅϢʧ°Ü.");
			}

			BoardStatus status;
			nRet = m_cclink.GetBoardStatus(status);
			if (nRet == 0) {
				LOGI("״̬£º%s.", status.toString().c_str());
			}
			else {
				LOGE("»ñÈ¡CC-Link״̬ʧ°Ü.");
			}
		}


		// ³õʼ»¯Ìí¼Ó¸÷×ÓÉ豸
		CLoadPort* pPort1, * pPort2, * pPort3, * pPort4;
		CBonder* pBonder1, * pBonder2;
		CEFEM* pEfem;
		CArm* pArm;
		CArmTray* pArmTray1, * pArmTray2;
		CFliper* pFliper;
		CVacuumBake* pVacuumBake;
		CAligner* pAligner;
		CBakeCooling* pBakeCooling;
		CMeasurement* pMeasurement;

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

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

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

		connectEquipments();




		
		// ¶Á»º´æÊý¾Ý
		readCache();


		// ¶¨Ê±Æ÷
		g_pMaster = this;
		SetTimer(NULL, 1, 250, (TIMERPROC)MasterTimerProc);


		// µ÷¶ÈÏß³Ì
		m_hDispatchThreadHandle = (HANDLE)_beginthreadex(NULL, 0, SERVO::DispatchThreadFunction, this,
			0, &m_nDispatchThreadAddr);


		// ¼à¿ØbitÏß³Ì
		m_hReadBitsThreadHandle = (HANDLE)_beginthreadex(NULL, 0, SERVO::ReadBitsThreadFunction, this,
			0, &m_nReadBitsThreadAddr);


		LOGI("<Master>³õʼ»¯Íê³É.");
		return 0;
	}

	int CMaster::term()
	{
		SetEvent(m_hEventReadBitsThreadExit[0]);
		SetEvent(m_hEventDispatchThreadExit[0]);
		::WaitForSingleObject(m_hEventReadBitsThreadExit[1], INFINITE);
		::WaitForSingleObject(m_hEventDispatchThreadExit[1], INFINITE);

		LOGI("<Master>ÕýÔÚ½áÊø³ÌÐò.");
		for (auto item : m_listEquipment) {
			item->term();
		}
		saveCache();

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

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


		return 0;
	}

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

		setState(MASTERSTATE::STARTING);
		m_ullStartTime = GetTickCount64();

		return 0;
	}

	int CMaster::stop()
	{
		// ÔËÐÐʱ¼äΪÀÛ¼Ó½á¹û£¬±¾´ÎֹͣʱˢУ»
		if (m_state != MASTERSTATE::RUNNING) {
			return -1;
		}

		m_ullRunTime += (GetTickCount64() - m_ullStartTime);
		setState(MASTERSTATE::STOPPING);

		return 0;
	}

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

	ULONGLONG CMaster::getRunTime()
	{
		if (m_state == MASTERSTATE::RUNNING)
			return m_ullRunTime + (GetTickCount64() - m_ullStartTime);
		else
			return m_ullRunTime;
	}

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

	unsigned CMaster::DispatchProc()
	{
		// ÓÅÏÈ¿¼ÂǵÄÀàÐͺʹÎÒªÀàÐÍ
		// Ò»ÖÖÇé¿ö£¬Èç¹û²»·ÖÖ÷´Î£¬Ò»Ö±°áG1, µÈµ½Bonder1ºÍBonder2¶¼·ÅÁËG1, AlignerÒ²·ÅÁËG1,
		// Bonder1ºÍBonder2ÐèÒªµÄG2¾Í¹ý²»À´ÁË
		// ×î»ù±¾µÄʵÏÖ£¬¿ÉÒÔG2ºÍG2ÂÖÁ÷°áËÍ£¬µ«×îºÃ¸ù¾ÝBonderµÄÐèÇóÀ´¾ö¶¨
		MaterialsType primaryType, secondaryType;


		// ¸÷ÖÖ»úÆ÷
		CLoadPort* pLoadPorts[4];
		CEFEM* pEFEM = (CEFEM*)getEquipment(EQ_ID_EFEM);
		pLoadPorts[0] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT1);
		pLoadPorts[1] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT2);
		pLoadPorts[2] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT3);
		pLoadPorts[3] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT4);
		CFliper* pFliper = (CFliper*)getEquipment(EQ_ID_FLIPER);
		CVacuumBake* pVacuumBake = (CVacuumBake*)getEquipment(EQ_ID_VACUUMBAKE);
		CAligner* pAligner = (CAligner*)getEquipment(EQ_ID_ALIGNER);
		CBonder* pBonder1 = (CBonder*)getEquipment(EQ_ID_Bonder1);
		CBonder* pBonder2 = (CBonder*)getEquipment(EQ_ID_Bonder2);
		CBakeCooling* pBakeCooling = (CBakeCooling*)getEquipment(EQ_ID_BAKE_COOLING);
		CMeasurement* pMeasurement = (CMeasurement*)getEquipment(EQ_ID_MEASUREMENT);

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

		while (1) {
			// ´ýÍ˳öÐźŻòʱ¼äµ½
			HANDLE hEvents[] = { m_hEventDispatchThreadExit[0], m_hDispatchEvent };
			int nRet = WaitForMultipleObjects(2, hEvents, FALSE, 1000);
			if (nRet == WAIT_OBJECT_0) {
				break;
			}
			

			// Èç¹û״̬ΪSTARTING£¬¿ªÊ¼¹¤×÷²¢Çл»µ½RUNNING״̬
			lock();
			if (m_state == MASTERSTATE::STARTING) {
				// ·¢ËÍindexerOperationModeChangeµ½¸÷¸ö»ų́£¬³É¹¦ºóÇл»µ½RUNNING״̬
				// ·ñÔòÇл»µ½MSERROR״̬
				int nRet;
				CEquipment* pEq[6] = { pEFEM, pBonder1, pBonder2, pBakeCooling, 
					pVacuumBake, pMeasurement};
				BOOL bIomcOk[7] = {FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE};
				std::vector<std::promise<void>> promises(6);
				std::vector<std::future<void>> futures;

				nRet = pEq[0]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
					[&](int writeCode, int retCode) -> void {
						bIomcOk[0] = retCode == (int)RET::OK;
						promises[0].set_value();
						TRACE("a0001\n", writeCode, retCode);
					});
				if (nRet != 0) {
					LOGI("<Master>EFEMÇл»Start״̬ʧ°Ü");
					m_strLastError = "EFEMÇл»Start״̬ʧ°Ü.";
					goto WAIT;
				}
				futures.push_back(promises[0].get_future());
				/*
				nRet = pEq[1]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
					[&](int writeCode, int retCode) -> void {
						bIomcOk[1] = retCode == (int)RET::OK;
						promises[1].set_value();
						TRACE("a0002\n");
					});
				if (nRet != 0) {
					LOGI("<Master>Bonder1Çл»Start״̬ʧ°Ü");
					m_strLastError = "Bonder1Çл»Start״̬ʧ°Ü.";
					goto WAIT;
				}
				futures.push_back(promises[1].get_future());

				nRet = pEq[2]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
					[&](int writeCode, int retCode) -> void {
						bIomcOk[2] = retCode == (int)RET::OK;
						promises[2].set_value();
						TRACE("a0003\n");
					});
				if (nRet != 0) {
					LOGI("<Master>Bonder2Çл»Start״̬ʧ°Ü");
					m_strLastError = "Bonder2Çл»Start״̬ʧ°Ü.";
					goto WAIT;
				}
				futures.push_back(promises[2].get_future());

				nRet = pEq[3]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
					[&](int writeCode, int retCode) -> void {
						bIomcOk[3] = retCode == (int)RET::OK;
						promises[3].set_value();
						TRACE("a0004\n");
					});
				if (nRet != 0) {
					LOGI("<Master>BakeCoolingÇл»Start״̬ʧ°Ü");
					m_strLastError = "BakeCoolingÇл»Start״̬ʧ°Ü.";
					goto WAIT;
				}
				futures.push_back(promises[3].get_future());

				nRet = pEq[4]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
					[&](int writeCode, int retCode) -> void {
						bIomcOk[4] = retCode == (int)RET::OK;
						promises[4].set_value();
						TRACE("a0005\n");
					});
				if (nRet != 0) {
					LOGI("<Master>VacuumBakeÇл»Start״̬ʧ°Ü");
					m_strLastError = "VacuumBakeÇл»Start״̬ʧ°Ü.";
					goto WAIT;
				}
				futures.push_back(promises[4].get_future());

				nRet = pEq[5]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
					[&](int writeCode, int retCode) -> void {
						bIomcOk[5] = retCode == (int)RET::OK;
						promises[5].set_value();
						TRACE("a0006\n");
					});
				if (nRet != 0) {
					LOGI("<Master>MeasurementÇл»Start״̬ʧ°Ü");
					m_strLastError = "MeasurementÇл»Start״̬ʧ°Ü.";
					goto WAIT;
				}
				futures.push_back(promises[5].get_future());
				*/

WAIT:
				for (auto& f : futures) {
					f.wait();  // ×èÈûµÈ´ý¶ÔÓ¦É豸Íê³É
				}
				for (int i = 0; i < 6; i++) {
					if (!bIomcOk[i]) {
						bIomcOk[6] = FALSE;
						LOGI("<Master>%sÇл»Start״̬ʧ°Ü", pEq[i]->getName().c_str());
					}
				}
				
				// ¼ì²é¿´ÊÇ·ñ¶¼ÒѾ­Çл»µ½START״̬
				if (!bIomcOk[6]) {
					unlock();
					setState(MASTERSTATE::MSERROR);
					continue;
				}


				unlock();
				setState(MASTERSTATE::RUNNING);
				continue;
			}


			// ´¦ÀíÍê³Éµ±Ç°ÊÂÎñºó£¬Çл»µ½Í£Ö¹»ò¾ÍÐ÷״̬
			else if (m_state == MASTERSTATE::STOPPING) {
				unlock();
				LOGI("<Master>¿ªÊ¼Çл»¸÷É豸µ½ Stop ģʽ...");

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

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

				for (int i = 0; i < 1; ++i) {
					nRet = pEq[i]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Stop,
						[i, &promises, &bIomcOk](int writeCode, int retCode) -> void {
							bIomcOk[i] = retCode == (int)RET::OK;
							promises[i].set_value();
							TRACE("s000%d: ret=%d\n", i + 1, retCode);
						});
					if (nRet != 0) {
						LOGI("<Master>%sÇл»Stop״̬·¢ËÍʧ°Ü", pEq[i]->getName().c_str());
						m_strLastError = pEq[i]->getName() + "Çл»Stop״̬·¢ËÍʧ°Ü.";
						bIomcOk[i] = FALSE;
						promises[i].set_value(); // ±ÜÃâ wait ×èÈû
					}
					futures.push_back(promises[i].get_future());
				}

				for (auto& f : futures) {
					f.wait();  // µÈ´ýËùÓÐÍê³É
				}

				for (int i = 0; i < 6; ++i) {
					if (!bIomcOk[i]) {
						bIomcOk[6] = FALSE;
						LOGI("<Master>%sÇл»Stop״̬ʧ°Ü", pEq[i]->getName().c_str());
					}
				}

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

				LOGI("<Master>ËùÓÐÉ豸³É¹¦Çл»µ½ Stop ģʽ");
				setState(MASTERSTATE::READY);
				continue;
			}


			// µ÷¶ÈÂß¼­´¦Àí
			else if (m_state == MASTERSTATE::RUNNING) {
				// ¼ì²âÅжÏrobot״̬
				RMDATA& rmd = pEFEM->getRobotMonitoringData();
				if (rmd.status != ROBOT_STATUS::Idle && rmd.status != ROBOT_STATUS::Run) {
					unlock();
					continue;
				}

				if (m_pActiveRobotTask != nullptr) {
					if (m_pActiveRobotTask->isPicked()) {
						m_pActiveRobotTask->place();
					}
					unlock();
					// ¼ì²âµ½µ±Ç°ÓÐÕýÔÚÏÂÎçµÄÈÎÎñ£¬È·±£µ±Ç°ÈÎÎñÍê³É»òÖÐÖ¹ºó¼ÌÐø
					// LOGI("¼ì²âµ½µ±Ç°ÓÐÕýÔÚÏÂÎçµÄÈÎÎñ£¬È·±£µ±Ç°ÈÎÎñÍê³É»òÖÐÖ¹ºó¼ÌÐø...");
					continue;
				}


				// ´Ë´¦¼ì²âÓÅÏÈÀàÐͺʹÎÒªÀàÐÍ£¨G1»òG2£©
				// Èç¹ûÆäÖÐÒ»BonderÓе¥¸ö²£Á§£¬ÓÅÏÈÈ¡ËüµÄÅä¶ÔÀàÐÍ£¬·ñÔòÎÞËùνÁË
				primaryType = MaterialsType::G1;
				secondaryType = MaterialsType::G2;
				if ((!pBonder1->canPlaceGlassInSlot(0) && !pBonder1->canPlaceGlassInSlot(1))
					&& (!pBonder2->canPlaceGlassInSlot(0) && !pBonder2->canPlaceGlassInSlot(1))) {
					// Èç¹ûG1ºÍG2¶¼ÂúÁË£¬ÄǾͿ´Aligner, Èç¹ûAlignerÓв£Á§ÎªG1, ÔòÈ¡G2
					CGlass* pGlass = pAligner->getGlassFromSlot(1);
					if (pGlass != nullptr && pGlass->getType() == MaterialsType::G1) {
						primaryType = MaterialsType::G2;
						secondaryType = MaterialsType::G1;
					}
				}
				else if ((pBonder1->canPlaceGlassInSlot(0) && !pBonder1->canPlaceGlassInSlot(1))
					|| (pBonder2->canPlaceGlassInSlot(0) && !pBonder2->canPlaceGlassInSlot(1))) {
					primaryType = MaterialsType::G2;
					secondaryType = MaterialsType::G1;
				}


				// Measurement -> LoadPort
				if (rmd.armState[0] || rmd.armState[1]) {
					LOGI("Arm1 %s, Arm2 %s.", rmd.armState[0] ? _T("²»¿ÉÓÃ") : _T("¿ÉÓÃ"),
						rmd.armState[1] ? _T("²»¿ÉÓÃ") : _T("¿ÉÓÃ"));
				}
				CEquipment* pEqTar[] = { pVacuumBake, pFliper };
				if (primaryType == MaterialsType::G2) {
					pEqTar[0] = pFliper;
					pEqTar[1] = pVacuumBake;
				}
				for (int s = 0; s < 4; s++) {
					if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
						&& pLoadPorts[s]->getPortType() == PortType::Unloading
						&& pLoadPorts[s]->getPortMode() == PortMode::ReadyToUnload) {
						m_pActiveRobotTask = createTransferTask(pMeasurement, pLoadPorts[s], primaryType, secondaryType);
						if (m_pActiveRobotTask != nullptr) {
							goto PORT_PUT;
						}
					}
				}

			PORT_PUT:
				if (m_pActiveRobotTask != nullptr) {
					m_pActiveRobotTask->pick();
					std::string strDescription = m_pActiveRobotTask->getDescription();
					unlock();
					if (m_listener.onRobotTaskEvent != nullptr) {
						m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
					}
					LOGI("´´½¨ÐÂÈÎÎñ<%s>...", strDescription.c_str());
					continue;
				}


				// Measurement NG -> LoadPort
				// NG»Øԭλ
				if (!rmd.armState[1]) {
					m_pActiveRobotTask = createTransferTask_restore(pMeasurement, pLoadPorts);
					if (m_pActiveRobotTask != nullptr) {
						m_pActiveRobotTask->pick();
						std::string strDescription = m_pActiveRobotTask->getDescription();
						unlock();
						if (m_listener.onRobotTaskEvent != nullptr) {
							m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
						}
						LOGI("´´½¨Measurement»ØÍËÈÎÎñ<%s>...", strDescription.c_str());
						continue;
					}
				}




				// BakeCooling ->Measurement
				if (!rmd.armState[0]) {
					m_pActiveRobotTask = createTransferTask_bakecooling_to_measurement(pBakeCooling, pMeasurement);
					if (m_pActiveRobotTask != nullptr) {
						m_pActiveRobotTask->pick();
						std::string strDescription = m_pActiveRobotTask->getDescription();
						unlock();
						if (m_listener.onRobotTaskEvent != nullptr) {
							m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
						}
						LOGI("´´½¨ÐÂÈÎÎñ<%s>...", strDescription.c_str());
						continue;
					}
				}


				
				// BakeCoolingÄÚ²¿
				// Bake -> Cooling
				if (!rmd.armState[0]) {
					m_pActiveRobotTask = createTransferTask_bake_to_cooling(pBakeCooling);
					if (m_pActiveRobotTask != nullptr) {
						m_pActiveRobotTask->pick();
						std::string strDescription = m_pActiveRobotTask->getDescription();
						unlock();
						if (m_listener.onRobotTaskEvent != nullptr) {
							m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
						}
						LOGI("´´½¨ÐÂÈÎÎñ<%s>...", strDescription.c_str());
						continue;
					}
				}


				// Bonder -> BakeCooling
				if (!rmd.armState[0]) {
					m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder1, pBakeCooling);
					if (m_pActiveRobotTask != nullptr) {
						m_pActiveRobotTask->pick();
						std::string strDescription = m_pActiveRobotTask->getDescription();
						unlock();
						if (m_listener.onRobotTaskEvent != nullptr) {
							m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
						}
						LOGI("´´½¨ÐÂÈÎÎñ<%s>...", strDescription.c_str());
						continue;
					}
				}

				if (!rmd.armState[0]) {
					m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder2, pBakeCooling);
					if (m_pActiveRobotTask != nullptr) {
						m_pActiveRobotTask->pick();
						std::string strDescription = m_pActiveRobotTask->getDescription();
						unlock();
						if (m_listener.onRobotTaskEvent != nullptr) {
							m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
						}
						LOGI("´´½¨ÐÂÈÎÎñ<%s>...", strDescription.c_str());
						continue;
					}
				}


				// Fliper(G2) -> Bonder
				// VacuumBake(G1) -> Bonder
				if (!rmd.armState[1] && !pBonder1->hasBondClass()) {
					m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, primaryType, secondaryType, 2);
					if (m_pActiveRobotTask != nullptr) {
						m_pActiveRobotTask->pick();
						std::string strDescription = m_pActiveRobotTask->getDescription();
						unlock();
						if (m_listener.onRobotTaskEvent != nullptr) {
							m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
						}
						LOGI("´´½¨ÐÂÈÎÎñ<%s>...", strDescription.c_str());
						continue;
					}
				}

				if (!rmd.armState[1] && !pBonder2->hasBondClass()) {
					m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, primaryType, secondaryType, 2);
					if (m_pActiveRobotTask != nullptr) {
						m_pActiveRobotTask->pick();
						std::string strDescription = m_pActiveRobotTask->getDescription();
						unlock();
						if (m_listener.onRobotTaskEvent != nullptr) {
							m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
						}
						LOGI("´´½¨ÐÂÈÎÎñ<%s>...", strDescription.c_str());
						continue;
					}
				}

				if (!rmd.armState[0] && !pBonder1->hasBondClass()) {
					m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder1, primaryType, secondaryType);
					if (m_pActiveRobotTask != nullptr) {
						m_pActiveRobotTask->pick();
						std::string strDescription = m_pActiveRobotTask->getDescription();
						unlock();
						if (m_listener.onRobotTaskEvent != nullptr) {
							m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
						}
						LOGI("´´½¨ÐÂÈÎÎñ<%s>...", strDescription.c_str());
						continue;
					}
				}

				if (!rmd.armState[0] && !pBonder2->hasBondClass()) {
					m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder2, primaryType, secondaryType);
					if (m_pActiveRobotTask != nullptr) {
						m_pActiveRobotTask->pick();
						std::string strDescription = m_pActiveRobotTask->getDescription();
						unlock();
						if (m_listener.onRobotTaskEvent != nullptr) {
							m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
						}
						LOGI("´´½¨ÐÂÈÎÎñ<%s>...", strDescription.c_str());
						continue;
					}
				}


				// Aligner -> Fliper(G2)
				// Aligner -> VacuumBake(G1)
				if (!rmd.armState[1]) {
					m_pActiveRobotTask = createTransferTask(pAligner, pFliper, primaryType, secondaryType);
					if (m_pActiveRobotTask != nullptr) {
						m_pActiveRobotTask->pick();
						std::string strDescription = m_pActiveRobotTask->getDescription();
						unlock();
						if (m_listener.onRobotTaskEvent != nullptr) {
							m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
						}
						LOGI("´´½¨ÐÂÈÎÎñ<%s>...", strDescription.c_str());
						continue;
					}
				}

				if (!rmd.armState[0]) {
					m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, primaryType, secondaryType);
					if (m_pActiveRobotTask != nullptr) {
						m_pActiveRobotTask->pick();
						std::string strDescription = m_pActiveRobotTask->getDescription();
						unlock();
						if (m_listener.onRobotTaskEvent != nullptr) {
							m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
						}
						LOGI("´´½¨ÐÂÈÎÎñ<%s>...", strDescription.c_str());
						continue;
					}
				}

				// Aligner -> LoadPort
				if (!rmd.armState[1]) {
					m_pActiveRobotTask = createTransferTask_restore(pAligner, pLoadPorts);
					if (m_pActiveRobotTask != nullptr) {
						m_pActiveRobotTask->pick();
						std::string strDescription = m_pActiveRobotTask->getDescription();
						unlock();
						if (m_listener.onRobotTaskEvent != nullptr) {
							m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
						}
						LOGI("´´½¨Aligner»ØÍËÈÎÎñ<%s>...", strDescription.c_str());
						continue;
					}
				}




				// LoadPort -> Aligner
				for (int s = 0; s < 4; s++) {
					if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
						&& pLoadPorts[s]->getPortType() == PortType::Loading
						&& pLoadPorts[s]->getPortMode() == PortMode::ReadyToLoad) {
						m_pActiveRobotTask = createTransferTask(pLoadPorts[s], pAligner, primaryType, secondaryType);
						if (m_pActiveRobotTask != nullptr) {
							pEFEM->setContext(m_pActiveRobotTask->getContext());
							goto PORT_GET;
						}
					}
				}

PORT_GET:
				if (m_pActiveRobotTask != nullptr) {
					m_pActiveRobotTask->pick();
					std::string strDescription = m_pActiveRobotTask->getDescription();
					unlock();
					if (m_listener.onRobotTaskEvent != nullptr) {
						m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
					}
					LOGI("´´½¨ÐÂÈÎÎñ<%s>...", strDescription.c_str());
					continue;
				}

				unlock();

			}
			unlock();
		}

		SetEvent(m_hEventDispatchThreadExit[1]);


		// _endthreadex(0);
		TRACE("CMaster::DispatchProc Ïß³ÌÍ˳ö\n");
		return 0;
	}

	unsigned CMaster::ReadBitsProc()
	{
		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();
				if (block.end > block.start) {
					int nRet = m_cclink.ReadData2(station, (DeviceType)block.type,
						block.start, block.size, block.buffer);
					if (0 == nRet) {
						item->onReceiveLBData(block.buffer, block.size);
					}
				}
			}
		}

		SetEvent(m_hEventReadBitsThreadExit[1]);


		// _endthreadex(0);
		TRACE("CMaster::ReadBitsProc Ïß³ÌÍ˳ö\n");
		return 0;
	}

	int CMaster::addToEquipmentList(CEquipment* pEquipment)
	{
		EquipmentListener listener;
		listener.onAlive = [&](void* pEquipment, BOOL bAlive) -> void {
			CEquipment* p = (CEquipment*)pEquipment;
			if (m_listener.onEqAlive != nullptr) {
				m_listener.onEqAlive(this, p, bAlive);
			}
		};
		listener.onCimStateChanged = [&](void* pEquipment, BOOL bOn) -> void {
			CEquipment* p = (CEquipment*)pEquipment;
			if (m_listener.onEqCimStateChanged != nullptr) {
				m_listener.onEqCimStateChanged(this, p, bOn);
			}
		};
		listener.onAlarm = [&](void* pEquipment, int state, int alarmId, int unitId, int level) -> void {
			CEquipment* p = (CEquipment*)pEquipment;
			if (m_listener.onEqAlarm != nullptr) {
				m_listener.onEqAlarm(this, p, state, alarmId, unitId, level);
			}
		};
		listener.onVcrEventReport = [&](void* pEquipment, void* pReport) -> void {
			CEquipment* p = (CEquipment*)pEquipment;
			CVcrEventReport* p2 = (CVcrEventReport*)pReport;
			if (m_listener.onEqVcrEventReport != nullptr) {
				m_listener.onEqVcrEventReport(this, p, p2);
			}
		};
		listener.onPreFethedOutJob = [&](void* pEquipment, int port, CJobDataB* pJobDataB) -> BOOL {
			CEquipment* p = (CEquipment*)pEquipment;


			// ȡƬ£¬¸üе±Ç°°áËÍÈÎÎñ
			BOOL bOk = FALSE;
			lock();
			if (m_pActiveRobotTask != nullptr) {
				if (m_pActiveRobotTask->getSrcPosition() == p->getID()) {
					CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getSrcSlot());
					if (pGlass != nullptr) {
						CJobDataS* pJobDataS = pGlass->getJobDataS();
						if (pJobDataS != nullptr
							&& pJobDataS->getCassetteSequenceNo() == pJobDataB->getCassetteSequenceNo()
							&& pJobDataS->getJobSequenceNo() == pJobDataB->getJobSequenceNo()) {
							bOk = TRUE;
							LOGI("<CMaster>onPreFethedOutJob, ÒÑУÑéÊý¾ÝÒ»ÖÂÐÔ.");
						}
					}
				}
				else if (p->getID() == EQ_ID_ARM_TRAY1 || p->getID() == EQ_ID_ARM_TRAY2) {
					bOk = TRUE;
				}
			}
			unlock();

			if (!bOk) {
				LOGE("<CMaster>onPreFethedOutJob, Êý¾ÝУÑéʧ°Ü.");
			}

			return bOk;

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


			// ·ÅƬ£¬¸üе±Ç°°áËÍÈÎÎñ
			BOOL bOk = FALSE;
			lock();
			if (m_pActiveRobotTask != nullptr) {
				// ÊÇ·ñÒѾ­½øÈëÊÖ±Û(¼´È¡Æ¬Íê³É),½øÈëÏÂÒ»²½£¬·ÅƬ
				if (m_pActiveRobotTask->isPicking() && 
					((m_pActiveRobotTask->getArmNo() == 1 && p->getID() == EQ_ID_ARM_TRAY1)
					|| (m_pActiveRobotTask->getArmNo() == 2 && p->getID() == EQ_ID_ARM_TRAY2))
					) {
					slot = 1;
					bOk = TRUE;
				}

				// ÊÇ·ñ·ÅƬÍê³É
				else if (m_pActiveRobotTask->isPlacing() &&
					m_pActiveRobotTask->getTarPosition() == p->getID()) {
					CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getTarSlot());
					if (pGlass == nullptr) {
						bOk = TRUE;
						slot = m_pActiveRobotTask->getTarSlot();
						LOGI("<CMaster>onPreFethedOutJob, ÒÑУÑéÊý¾ÝÒ»ÖÂÐÔ.");
					}
				}

				// ÊÇ·ñ»Ø³·
				else if (m_pActiveRobotTask->isRestoring() &&
					m_pActiveRobotTask->getSrcPosition() == p->getID()) {
					CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getSrcSlot());
					if (pGlass == nullptr && m_pActiveRobotTask->getSrcSlot() == port) {
						bOk = TRUE;
						slot = m_pActiveRobotTask->getSrcSlot();
						LOGI("<CMaster>onPreFethedOutJob, ÒÑУÑéÊý¾ÝÒ»ÖÂÐÔ.");
					}
				}
			}
			unlock();

			if (!bOk) {
				LOGE("<CMaster>onPreStoredJob, Êý¾ÝУÑéʧ°Ü.");
			}

			return bOk;

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

			// È¡·ÅƬ£¬¸üе±Ç°°áËÍÈÎÎñ
			if (code == EDCC_FETCHOUT_JOB) {
				lock();
				if (m_pActiveRobotTask != nullptr && m_pActiveRobotTask->getSrcPosition() == p->getID()) {
					LOGI("¿ªÊ¼È¡Æ¬...");
				}
				unlock();
			}
			else if (code == EDCC_STORED_JOB) {
				lock();
				if (m_pActiveRobotTask != nullptr
					&& m_pActiveRobotTask->isPicking()
					&& ((m_pActiveRobotTask->getArmNo() == 1 && p->getID() == EQ_ID_ARM_TRAY1)
						|| (m_pActiveRobotTask->getArmNo() == 2 && p->getID() == EQ_ID_ARM_TRAY2))
					) {
					LOGI("ȡƬÍê³É.");
					m_pActiveRobotTask->fetchOut();
					m_pActiveRobotTask->picked();
				}

				else if (m_pActiveRobotTask != nullptr
					&& m_pActiveRobotTask->isPlacing() 
					&& m_pActiveRobotTask->getTarPosition() == p->getID()) {
					m_pActiveRobotTask->stored();
					m_pActiveRobotTask->completed();
					LOGI("·ÅƬÍê³É...");
					// Íê³É´ËÌõ°áËÍÈÎÎñ£¬µ«Òª°ÑÊý¾ÝºÍÏûÏ¢ÉÏÅ×Ó¦Óòã
					unlock();


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

				else if (m_pActiveRobotTask != nullptr
					&& m_pActiveRobotTask->isRestoring()
					&& m_pActiveRobotTask->getSrcPosition() == p->getID()) {
					m_pActiveRobotTask->stored();
					m_pActiveRobotTask->restored();
					LOGI("»Ø³·Íê³É...");
					// Íê³É´ËÌõ°áËÍÈÎÎñ£¬µ«Òª°ÑÊý¾ÝºÍÏûÏ¢ÉÏÅ×Ó¦Óòã
					unlock();


					lock();
					if (m_listener.onRobotTaskEvent != nullptr) {
						m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_RESTORE);
					}
					delete m_pActiveRobotTask;
					m_pActiveRobotTask = nullptr;
					stop();
				}
				unlock();
			}
		};
		listener.onProcessStateChanged = [&](void* pEquipment, PROCESS_STATE state) -> void {
			LOGI("<Master>onProcessStateChanged<%d>", (int)state);
		};
		listener.onMapMismatch = [&](void* pEquipment, short scanMap, short downMap) {
			LOGE("<Master-%s>Port InUse, map(%d!=%d)²»Ò»Ö£¬Çë¼ì²é¡£",
				((CEquipment*)pEquipment)->getName().c_str(), scanMap, downMap);
		};
		pEquipment->setListener(listener);
		pEquipment->setCcLink(&m_cclink);
		m_listEquipment.push_back(pEquipment);

		return 0;
	}

	std::list<CEquipment*>& CMaster::getEquipmentList()
	{
		return m_listEquipment;
	}

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

		return nullptr;
	}

	/*
	 * Ìí¼ÓLoadPort1
	 * index -- 0~3
	 */
	CLoadPort* CMaster::addLoadPort(int index)
	{
		ASSERT(index == 0 || index == 1 || index == 2 || index == 3);


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


		pEquipment->init();
		LOGE("ÒÑÌí¼Ó¡°%s¡±.", pEquipment->getName().c_str());


		return pEquipment;
	}

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


		pEquipment->init();
		LOGE("ÒÑÌí¼Ó¡°Fliper¡±.");
		return pEquipment;
	}

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


		pEquipment->init();
		LOGE("ÒÑÌí¼Ó¡°VacuumBake¡±.");

		return pEquipment;
	}

	CAligner* CMaster::addAligner()
	{
		CAligner* pEquipment = new CAligner();
		pEquipment->setID(EQ_ID_ALIGNER);
		pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
		pEquipment->setName("Aligner");
		pEquipment->setDescription("Aligner.");
		pEquipment->setReadBitBlock(0x0, 0x0);
		pEquipment->setStation(0, 255);
		addToEquipmentList(pEquipment);


		pEquipment->init();
		LOGE("ÒÑÌí¼Ó¡°Aligner¡±.");

		return pEquipment;
	}

	CEFEM* CMaster::addEFEM()
	{
		CEFEM* pEquipment = new CEFEM();
		pEquipment->setID(EQ_ID_EFEM);
		pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
		pEquipment->setName("EFEM(ROBOT)");
		pEquipment->setDescription("EFEM(ROBOT).");
		pEquipment->setReadBitBlock(0x3000, 0x3aff);
		pEquipment->setStation(0, 255);
		addToEquipmentList(pEquipment);


		pEquipment->init();
		LOGE("ÒÑÌí¼Ó¡°EFEM(ROBOT)¡±.");

		return pEquipment;
	}

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


		pEquipment->init();
		LOGE("ÒÑÌí¼Ó¡°ARM¡±.");

		return pEquipment;
	}

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


		pEquipment->init();
		LOGE("ÒÑÌí¼Ó¡°%s¡±.", pEquipment->getName().c_str());

		return pEquipment;
	}

	/* Ìí¼Óbonder1 »ò bonder2 
	 * index -- 0, bonder1
	 * index -- 1, bonder2
	 */
	CBonder* CMaster::addBonder(int index)
	{
		ASSERT(index == 0 || index == 1);
		CBonder* pEquipment = new CBonder();
		pEquipment->setID(EQ_ID_Bonder1 + index);
		pEquipment->setName(index == 0 ? "Bonder 1" : "Bonder 2");
		pEquipment->setDescription(index == 0 ? "Bonder 1." : "Bonder 2.");
		pEquipment->setStation(0, 255);
		pEquipment->setReadBitBlock(index == 0 ? 0x3b00 : 0x4600,
			index == 0 ? 0x5600 : 0x6100);
		pEquipment->setIndex(index);
		addToEquipmentList(pEquipment);


		pEquipment->init();
		LOGE("ÒÑÌí¼Ó¡°%s¡±.", pEquipment->getName().c_str());


		return pEquipment;
	}

	CBakeCooling* CMaster::addBakeCooling()
	{
		CBakeCooling* pEquipment = new CBakeCooling();
		pEquipment->setID(EQ_ID_BAKE_COOLING);
		pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
		pEquipment->setName("BakeCooling");
		pEquipment->setDescription("BakeCooling.");
		pEquipment->setReadBitBlock(0x5100, 0x5bff);
		pEquipment->setStation(0, 255);
		addToEquipmentList(pEquipment);

		pEquipment->init();
		LOGE("ÒÑÌí¼Ó¡°Aligner¡±.");

		return pEquipment;
	}

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

		pEquipment->init();
		LOGE("ÒÑÌí¼Ó¡°Measurement¡±.");

		return pEquipment;
	}

	void CMaster::onTimer(UINT nTimerid)
	{
		for (auto item : m_listEquipment) {
			item->onTimer(nTimerid);
		}


		static int i = 0;
		i++;

		// ×Ô¶¯±£´æ»º´æ
		if (i % (4 * 2) == 0) {
			if (m_bDataModify) {
				saveCacheAndBackups();
				m_bDataModify = FALSE;
			}
		}

	}

	void CMaster::connectEquipments()
	{
		int nRet;
		CLoadPort* pLoadPort1 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT1);
		CLoadPort* pLoadPort2 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT2);
		CLoadPort* pLoadPort3 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT3);
		CLoadPort* pLoadPort4 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT4);
		CFliper* pFliper = (CFliper*)getEquipment(EQ_ID_FLIPER);
		CVacuumBake* pVacuumBake = (CVacuumBake*)getEquipment(EQ_ID_VACUUMBAKE);
		CAligner* pAligner = (CAligner*)getEquipment(EQ_ID_ALIGNER);
		CBonder* pBonder1 = (CBonder*)getEquipment(EQ_ID_Bonder1);
		CBonder* pBonder2 = (CBonder*)getEquipment(EQ_ID_Bonder2);
		CBakeCooling* pBakeCooling = (CBakeCooling*)getEquipment(EQ_ID_BAKE_COOLING);
		CMeasurement* pMeasurement = (CMeasurement*)getEquipment(EQ_ID_MEASUREMENT);

		nRet = pLoadPort1->getPin("Out")->connectPin(pAligner->getPin("In1"));
		if (nRet < 0) {
			LOGE("Á¬½ÓLoadPort1-Fliperʧ°Ü");
		}
		nRet = pLoadPort2->getPin("Out")->connectPin(pAligner->getPin("In2"));
		if (nRet < 0) {
			LOGE("Á¬½ÓLoadPort1-Fliperʧ°Ü");
		}

		nRet = pAligner->getPin("Out1")->connectPin(pFliper->getPin("In"));
		if (nRet < 0) {
			LOGE("Á¬½ÓAligner-Fliperʧ°Ü");
		}
		nRet = pAligner->getPin("Out2")->connectPin(pVacuumBake->getPin("In"));
		if (nRet < 0) {
			LOGE("Á¬½ÓAligner-VacuumBakeʧ°Ü");
		}

		nRet = pFliper->getPin("Out1")->connectPin(pBonder1->getPin("In1"));
		if (nRet < 0) {
			LOGE("Á¬½ÓFliper-Bonder1ʧ°Ü");
		}
		nRet = pFliper->getPin("Out2")->connectPin(pBonder2->getPin("In1"));
		if (nRet < 0) {
			LOGE("Á¬½ÓFliper-Bonder2ʧ°Ü");
		}

		nRet = pVacuumBake->getPin("Out1")->connectPin(pBonder1->getPin("In2"));
		if (nRet < 0) {
			LOGE("Á¬½ÓVacuumBake-Bonder1ʧ°Ü");
		}
		nRet = pVacuumBake->getPin("Out2")->connectPin(pBonder2->getPin("In2"));
		if (nRet < 0) {
			LOGE("Á¬½ÓVacuumBake-Bonder2ʧ°Ü");
		}

		nRet = pBonder1->getPin("Out")->connectPin(pBakeCooling->getPin("In1"));
		if (nRet < 0) {
			LOGE("Á¬½ÓBonder1-BakeCoolingʧ°Ü");
		}

		nRet = pBonder2->getPin("Out")->connectPin(pBakeCooling->getPin("In2"));
		if (nRet < 0) {
			LOGE("Á¬½ÓBonder2-BakeCoolingʧ°Ü");
		}

		nRet = pBakeCooling->getPin("Out")->connectPin(pMeasurement->getPin("In"));
		if (nRet < 0) {
			LOGE("Á¬½ÓBakeCooling-LoadPort3ʧ°Ü");
		}

		nRet = pMeasurement->getPin("Out1")->connectPin(pLoadPort3->getPin("In"));
		if (nRet < 0) {
			LOGE("Á¬½ÓBakeCooling-LoadPort3ʧ°Ü");
		}

		nRet = pMeasurement->getPin("Out2")->connectPin(pLoadPort4->getPin("In"));
		if (nRet < 0) {
			LOGE("Á¬½ÓBakeCooling-LoadPort4ʧ°Ü");
		}
	}

	int CMaster::saveCache()
	{
		CFile file;
		if (!file.Open(m_strFilepath.c_str(), CFile::modeCreate | CFile::modeWrite)) {
			return -1;
		}

		CArchive ar(&file, CArchive::store);
		serialize(ar);
		ar.Close();
		file.Close();

		return 0;
	}

	int CMaster::saveCacheAndBackups()
	{
		saveCache();


		// ´´½¨±¸·ÝĿ¼
		CString strNewFile;
		CString strFileDir = m_strFilepath.c_str();
		int index = strFileDir.ReverseFind('\\');
		ASSERT(index > 0);
		strFileDir = strFileDir.Left(index);
		strFileDir = strFileDir + _T("Backups");
		::CreateDirectory(strFileDir, nullptr);

		CTime time = CTime::GetCurrentTime();
		strNewFile.Format(_T("%s//Master_%d_%02d_%02d_%02d_%02d_%02d.dat"),
			(LPTSTR)(LPCTSTR)strFileDir,
			time.GetYear(), time.GetMonth(), time.GetDay(),
			time.GetHour(), time.GetMinute(), time.GetSecond());
		::CopyFile(m_strFilepath.c_str(), strNewFile, FALSE);

		return 0;
	}

	void CMaster::setCacheFilepath(const char* pszFilepath)
	{
		m_strFilepath = pszFilepath;
	}

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

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

		return 0;
	}

	void CMaster::serialize(CArchive& ar)
	{
		for (auto item : m_listEquipment) {
			item->serialize(ar);
		}
	}

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

	static int taskSeqNo = 0;
	CRobotTask* CMaster::createTransferTask(CEquipment* pSrcEq, CEquipment* pTarEq,
		MaterialsType primaryType/* = MaterialsType::G1*/, MaterialsType secondaryType/* = MaterialsType::G2*/,
		int armNo/* = 1*/)
	{
		CRobotTask* pTask = nullptr;
		CSlot* pSrcSlot, * pTarSlot;
		pTarSlot = pTarEq->getAvailableSlotForGlass(primaryType);
		pSrcSlot = pSrcEq->getProcessedSlot(primaryType);
		if (pSrcSlot == nullptr || nullptr == pTarSlot) {
			pTarSlot = pTarEq->getAvailableSlotForGlass(secondaryType);
			pSrcSlot = pSrcEq->getProcessedSlot(secondaryType);
		}


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


		return pTask;
	}

	CRobotTask* CMaster::createTransferTask_bonder_to_bakecooling(CEquipment* pSrcEq, CEquipment* pTarEq)
	{
		std::vector<int> slots = {1, 3};

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

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


		return pTask;
	}

	CRobotTask* CMaster::createTransferTask_bake_to_cooling(CEquipment* pSrcEq)
	{
		std::vector<int> slotsTar = { 2, 4 };
		std::vector<int> slotsSrc = { 1, 3 };

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

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


		return pTask;
	}

	CRobotTask* CMaster::createTransferTask_bakecooling_to_measurement(CEquipment* pSrcEq, CEquipment* pTarEq)
	{
		std::vector<int> slots = { 2, 4 };

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

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


		return pTask;
	}

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


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


		return pTask;
	}

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

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

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

		// µ±Ç°ÈÎÎñÊÖ¶¯ÖÐÖ¹ºó£¬Í£Ö¹µ÷¶È£¬ÐèÒª²Ù×÷Ô±ÔÚ½â¾öÎÊÌâºó£¬ÖØÐÂÆô¶¯
		stop();

		return 0;
	}

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


		return 0;
	}

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

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

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

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

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