#include "stdafx.h"
#include "Common.h"
#include "CMaster.h"


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

namespace SERVO {
	CMaster* g_pMaster = NULL;

	unsigned __stdcall 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 = {nullptr, nullptr, nullptr, nullptr};
		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;
	}

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

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

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

	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״̬ʧ°Ü.");
			}
		}


		// ³õʼ»¯Ìí¼Ó¸÷×ÓÉ豸
		addLoadPort(0);
		addLoadPort(1);
		addLoadPort(2);
		addLoadPort(3);
		addFliper();
		addVacuumBake();
		addAligner();
		addEFEM();
		addBonder(0);
		addBonder(1);
		addBakeCooling();
		connectEquipments();

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


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


		m_hReadBitsThreadHandle = (HANDLE)_beginthreadex(NULL, 0, SERVO::ReadBitsThreadFunction, this,
			0, &m_nReadBitsThreadAddr);


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

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

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



		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) {
				if (item->getID() == EQ_ID_Bonder1 ||
					item->getID() == EQ_ID_Bonder2) {
					const StationIdentifier& station = item->getStation();
					MemoryBlock& block = item->getReadBitBlock();

					int nRet = m_cclink.ReadData2(station, (DeviceType)block.type,
						block.start, block.size, block.buffer);
					if (0 == nRet) {
						item->onReceiveLBData(block.buffer, block.size);
					}
				}
			}
		}

		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.onDataChanged = [&](void* pEquipment, int code) -> void {
			m_bDataModify = TRUE;
		};

		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
	 */
	int CMaster::addLoadPort(int index)
	{
		ASSERT(index == 0 || index == 1 || index == 2 || index == 3);
		static char* pszCassetteCtrlCmd[] = { 
			STEP_EQ_P1_CASSETTE_CTRL_CMD,
			STEP_EQ_P2_CASSETTE_CTRL_CMD,
			STEP_EQ_P3_CASSETTE_CTRL_CMD,
			STEP_EQ_P4_CASSETTE_CTRL_CMD
		};
		int nWriteSignalDev[] = {0x120, 0x121, 0x122, 0x123};
		int nCtrlCmdDev[] = {0x45, 0x1a5, 0x305, 0x465};
		int nStepDev[] = { 0x480, 0x481, 0x482, 0x483 };


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


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


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


		return 0;
	}

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


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

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


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

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


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

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


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

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

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

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

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


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

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

	/* Ìí¼Óbonder1 »ò bonder2 
	 * index -- 0, bonder1
	 * index -- 1, bonder2
	 */
	int 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);
		addToEquipmentList(pEquipment);


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


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


		return 0;
	}

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


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

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


		// °´Ò»¶¨ÆµÂÊɨÃèLBÊý¾Ý
		static int i = 0;
		i++;
		/*
		if (i % (4 * 1) == 0) {

			for (auto item : m_listEquipment) {
				if (item->getID() == EQ_ID_Bonder1) {
					const StationIdentifier& station = item->getStation();
					MemoryBlock& block = item->getReadBitBlock();

					int nRet = m_cclink.ReadData2(station, (DeviceType)block.type,
						block.start, block.size, block.buffer);
					if (0 == nRet) {
						item->onReceiveLBData(block.buffer, block.size);
					}
				}
			}
		}
		*/


		// ×Ô¶¯±£´æ»º´æ
		if (i % (4 * 2) == 0) {
			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);

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

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

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

		nRet = pVacuumBake->getPin("Out")->connectPin(pAligner->getPin("In2"));
		if (nRet < 0) {
			LOGE("Á¬½ÓVacuumBake-Alignerʧ°Ü");
		}

		nRet = pAligner->getPin("Out1")->connectPin(pBonder1->getPin("In"));
		if (nRet < 0) {
			LOGE("Á¬½ÓAligner-Bondere1ʧ°Ü");
		}

		nRet = pAligner->getPin("Out2")->connectPin(pBonder2->getPin("In"));
		if (nRet < 0) {
			LOGE("Á¬½ÓAligner-Bondere2ʧ°Ü");
		}

		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("Out1")->connectPin(pLoadPort3->getPin("In"));
		if (nRet < 0) {
			LOGE("Á¬½ÓBakeCooling-LoadPort3ʧ°Ü");
		}

		nRet = pBakeCooling->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()
	{
		CFile file;
		if (!file.Open(m_strFilepath.c_str(), CFile::modeRead)) {
			return -1;
		}

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

		return 0;
	}

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