OTS/OTSCPP/OTSControl/COTSHardwareMgr.cpp

#include "stdafx.h"
#include "COTSHardwareMgr.h" 
#include "Bruker\OTSSEMBruker.h"
#include "Simulate\OTSSemSim.h"
#include "Simulate\OTSEDSSim.h"
#include "Simulate\OTSScanSim.h"
#include "Bruker\OTSEDSBrucker.h"
#include "Bruker\OTSScanBrucker.h"
#include "Oxford\OTSEDSOxford.h"
#include "Oxford\OTSScanOxford.h"
#include "Oxford\OTSSEMOxford.h"

namespace OTSController {

	//using namespace COTSXmlFileDll;
	//Registry Path And KeyName
	const CString cssSubKeyRegeditPath = "SOFTWARE\\OTSDevName";
	const CString csKey_DevName = "SEMName";
	const CString csKey_EDSName = "EDSName";
	//
	char* lpSemName[] = { "OffLine","Bruker","ESEM","ZEISS" ,"Oxford"};
	char* lpEdsName[] = { "OffLine","Bruker" ,"Oxford"};
	

	//XMLÎļþÃû
	const CString szXMLFileName = "./Config/ProData/HardwareConfig.xml";
	CString szSemName=_T(""), szEdsName= _T("");

 typedef enum class SemDevID
	{		
		Invalid = -1,
		OFFLINE = 0,
		BRUKER = 1,
		ESEM = 2,
		ZEISS = 3,	
		OXFORD = 4,
	}SEM_DEV_ID;


 typedef enum class EDSDevID
 {
	 Invalid = -1,
	 OFFLINE = 0,
	 BRUKER = 1,
	 OXFORD = 2,
 }EDS_DEV_ID;


	COTSHardwareMgr::COTSHardwareMgr()
	{
		m_SemBasePtr = nullptr;
		m_EDSPtr = nullptr;
		m_SCanPtr = nullptr;
	}


	COTSHardwareMgr::~COTSHardwareMgr()
	{

	}

	CSemBasePtr COTSHardwareMgr::GetSemControllerMgrPtr()
	{	
		if (nullptr == m_SemBasePtr)
		{
			int iDevID = -1;
			if (szSemName == _T(""))
			{
				if (!this->GetXMLVal(szXMLFileName, szSemName, szEdsName))
				{
					return nullptr;
				}
			}

			LogTrace(__FILE__, __LINE__, "(COTSHardwareMgr::GetSemControllerMgrPtr) szSemName = %s,  szEdsName = %s", szSemName, szEdsName);

			iDevID = this->GetSemControllerID(szSemName);
			switch (iDevID)
			{
				case (int)SEM_DEV_ID::BRUKER:
				{

						m_SemBasePtr = CSemBasePtr(new COTSSEMBruker());
						LogInfoTrace(__FILE__, __LINE__, "(COTSHardwareMgr::GetSemControllerMgrPtr) new COTSSEMBruker() ");
						break;
				}
				case (int)SEM_DEV_ID::OFFLINE:
				{
						m_SemBasePtr = CSemBasePtr(new COTSSemSim());
						LogInfoTrace(__FILE__, __LINE__, "(COTSHardwareMgr::GetSemControllerMgrPtr) new COTSSemSim() ");
         				break;
				}
				case (int)SEM_DEV_ID::OXFORD:
				{
	
						m_SemBasePtr = CSemBasePtr(new COTSSEMOxford());
						LogInfoTrace(__FILE__, __LINE__, "(COTSHardwareMgr::GetSemControllerMgrPtr) new COTSSemSim() ");
				
					break;
				}
				default:

					break;
			}
			//connect the hardware when the singleton instanced ,make it an enforcement.
			m_SemBasePtr->Connect();
		}
		
		return m_SemBasePtr;
	}

	COTSEDSBasePtr COTSHardwareMgr::GetEDSControllerPtr()
	{	
		
		if (nullptr == m_EDSPtr)
		{
			int iDevID = -1;
			if (szEdsName == _T(""))
			{
				if (!this->GetXMLVal(szXMLFileName, szSemName, szEdsName))
				{
					return nullptr;
				}
			}
			LogInfoTrace(__FILE__, __LINE__, "(COTSHardwareMgr::GetEDSControllerPtr) szSemName = %s,  szEdsName = %s", szSemName, szEdsName);

			iDevID = this->GetEDSControllerID(szEdsName);
			switch (iDevID)
			{
				case (int)EDS_DEV_ID::BRUKER:
				{
			
						m_EDSPtr = COTSEDSBasePtr(new COTSEDSBrucker());
						LogInfoTrace(__FILE__, __LINE__, "(COTSHardwareMgr::GetEDSControllerPtr) new COTSEDSBrucker() ");
				
					break;
				}
				case (int)EDS_DEV_ID::OFFLINE:
				{
				
						m_EDSPtr = COTSEDSBasePtr(new COTSEDSSim());
						LogInfoTrace(__FILE__, __LINE__, "(COTSHardwareMgr::GetEDSControllerPtr) new COTSEDSSim() ");
				

					break;
				}
				case (int)EDS_DEV_ID::OXFORD:
				{
				
						m_EDSPtr = COTSEDSBasePtr(new COTSEDSOxford());
						LogInfoTrace(__FILE__, __LINE__, "(COTSHardwareMgr::GetEDSControllerPtr) new COTSEDSSim() ");
				

					break;
				}
				default:

					break;
			}
			m_EDSPtr->Init();
			
		}
		
	
		return m_EDSPtr;

	}

	COTSScanBasePtr COTSHardwareMgr::GetScanControllerPtr()
	{

		if (nullptr == m_SCanPtr)
		{
			int iDevID = -1;

			if (szEdsName == _T(""))
			{
				if (!this->GetXMLVal(szXMLFileName, szSemName, szEdsName))
				{
					return nullptr;
				}
			}

			LogInfoTrace(__FILE__, __LINE__, "(COTSHardwareMgr::GetScanControllerPtr) szSemName = %s,  szEdsName = %s", szSemName, szEdsName);

			iDevID = this->GetEDSControllerID(szEdsName);

			switch (iDevID)
			{
				case (int)EDS_DEV_ID::BRUKER:
				{

						m_SCanPtr = COTSScanBasePtr(new COTSScanBrucker());
						LogInfoTrace(__FILE__, __LINE__, "(COTSHardwareMgr::GetScanControllerPtr) new COTSScanBrucker() ");
					break;
				}
				case (int)EDS_DEV_ID::OFFLINE:
				{
						m_SCanPtr = COTSScanBasePtr(new COTSScanSim());
						LogInfoTrace(__FILE__, __LINE__, "(COTSHardwareMgr::GetScanControllerPtr) new COTSScanSim() ");
					break;
				}
				case (int)EDS_DEV_ID::OXFORD:
				{
						m_SCanPtr = COTSScanBasePtr(new COTSScanOxford());
						LogInfoTrace(__FILE__, __LINE__, "(COTSHardwareMgr::GetScanControllerPtr) new COTSScanSim() ");
					break;
				}
				default:

					break;
			}
			//connect the hardware when the singleton instanced ,make it an enforcement.
			m_SCanPtr->Init();

		}
		
		return m_SCanPtr;
	}

	BOOL COTSHardwareMgr::GetXMLVal(const CString& szXmlFileName, CString& szSemName, CString& szEdsName)
	{
		
		tinyxml2::XMLDocument doc;
		doc.LoadFile(szXMLFileName);//ÔØÈëxmlÎļþ
		xmls::xString szS;
		xmls::xString szE;

		xmls::Slo subClass;
		xmls::Slo subClass1;
		subClass.Register("drive", &szS);
		 subClass1.Register ("drive",&szE);
		subClass.Register("SemControllerName", &subClass);
		
		subClass.Register("EDSName", &subClass1);


		tinyxml2::XMLElement *rootNode;
		rootNode = doc.FirstChildElement(RootClassName);
		subClass.Serialize(false, &doc, rootNode);
		szSemName = szS.value().c_str();
		szEdsName = szE.value().c_str();
		return true;
	}


	

	//return array Index when ControllerName match for name in array 
	int COTSHardwareMgr::GetSemControllerID(const CString& SemControllerName)
	{
		int iLen = sizeof(lpSemName) /sizeof(*lpSemName);

		int i = 0;
		for (i=0; i<iLen; i++)
		{
			if (0 == strcmp(lpSemName[i], SemControllerName))
			{
				return i;
			}			
		}
		LogErrorTrace(__FILE__, __LINE__, "GetSemControllerID:: SEMControllerName is Valied, ControllerName =%s ", SemControllerName);
		return -1;
		
	}


	//return array Index when ControllerName match for name in array 
	int COTSHardwareMgr::GetEDSControllerID(const CString& EDSControllerName)
	{
		int iLen = sizeof(lpEdsName) / sizeof(*lpEdsName);

		int i = 0;
		for (i = 0; i < iLen; i++)
		{
			if (0 == strcmp(lpEdsName[i], EDSControllerName))
			{
				return i;
			}
		}
		LogErrorTrace(__FILE__, __LINE__, "GetEDSControllerID:: EDSControllerName is Valied, ControllerName =%s ", EDSControllerName);
		return -1;

	}
	

}