#include "StdAfx.h"
#include "Control_Interface.h"
#include "SharedMemoryDefine.h"

CControl_Interface::CControl_Interface(void)
	:m_ReadEvent(FALSE,FALSE,_T("PLCConnector_Event_1"))
{		
	m_pI2M = NULL;
	m_bRecvedPLCIO1 = FALSE;
	m_nRecvedPLCIO1 = 0;

	m_hMap = NULL;
	m_pSharedMemory = NULL;	

	m_nSignal = m_nLongSignal = 0;
	m_bConnect = FALSE;

	m_dTickPrevTime = GetTickCount();

	for(int i=0; i<PLC_MAX_SIGNAL_BIT; i++)
	{
		m_nSignalOnTime[i] = 3000;
		m_nSignalOnDelayTime[i] = 1000;
	}

	LoadSignalOnTime();

	m_pThreadControlIF = new CThread_ControlIF();
	if(m_pThreadControlIF != NULL)
	{
		m_pThreadControlIF->CreateThread();			
		m_pThreadControlIF->SetControl2Main(static_cast<IControlInterface2Parent*>(this));
	}
}

CControl_Interface::~CControl_Interface(void)
{
	if(m_pThreadControlIF != NULL)
		delete m_pThreadControlIF;
	m_pThreadControlIF = NULL;

	DisconnectToPLC();
}

BOOL CControl_Interface::DisconnectToPLC()
{
	if (m_pSharedMemory!=NULL)
	{
		::UnmapViewOfFile(m_pSharedMemory);
		m_pSharedMemory = NULL;
	}
	if (m_hMap != NULL)
	{
		::CloseHandle(m_hMap);
		m_hMap = NULL;
	}

	return TRUE;
}

BOOL CControl_Interface::ConnectToControl()
{
	m_bConnect = ConnectPLCConnector();

	return m_bConnect;
}

BOOL CControl_Interface::ConnectPLCConnector()
{
	m_bConnect = FALSE;

	//4k Å©±âÀÇ °øÀ¯ ¸Þ¸ð¸® ÆÄÀÏ »ý¼º
	m_hMap = ::CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE
		, 0, SHARED_MEMORY_SIZE, _T("MX_COMPONENT_SHARED_MEMORY"));

	//¸¸ÀÏ ÀÌ¹Ì »ý¼ºµÈ °´Ã¼°¡ ÀÖ´Ù¸é ÀÌ¹Ì Connector°¡ ÀÛµ¿ Áß..
	if (::GetLastError() == ERROR_ALREADY_EXISTS)
	{
		//ÀÌ¹Ì »ý¼ºµÈ °´Ã¼°¡ ÀÖ´Ù¸é »ý¼ºÀÌ ¾Æ´Ï¶ó ¿ÀÇÂÀ¸·Î ½ÇÇà
		m_hMap = ::OpenFileMapping(FILE_MAP_ALL_ACCESS,FALSE,_T("MX_COMPONENT_SHARED_MEMORY"));
	}
	else//¸¸ÀÏ »ý¼ºµÈ °´Ã¼°¡ ¾ø´Ù¸é Á¤»ó µ¿ÀÛÇÏÁö ¾Ê´Â´Ù.
		g_pLog->DisplayMessage(_T("Error : No defect PLCConnector program."));

	if (m_hMap == NULL)
	{
		g_pLog->DisplayMessage(_T("ERROR: Failed to create(open) file mapping object!"));			
		return FALSE;
	}

	//°øÀ¯¸Þ¸ð¸® ¸ÊÇÎ
	m_pSharedMemory = (char*)::MapViewOfFile(m_hMap, FILE_MAP_ALL_ACCESS, 0, 0, SHARED_MEMORY_SIZE);

	if (m_pSharedMemory == NULL)
	{
		g_pLog->DisplayMessage(_T("ERROR: Failed to get shared memory!"));			
		return FALSE;
	}

	//0À¸·Î ÃʱâÈ­
	ZeroMemory(m_pSharedMemory,SHARED_MEMORY_SIZE);	

	m_bConnect = TRUE;

	return TRUE;
}

BOOL CControl_Interface::ControlProcess()
{
	if(IsConnect() == FALSE)
	{
		Sleep(10);
		return FALSE;
	}

	if(ReadPLCIOBit() == FALSE)
	{
		g_pLog->DisplayMessage(_T("Error PLC Read PLC 01"));
		return FALSE;
	}

	CheckSignal_01();

	Sleep(10);

	SendPLCIO_01();

	return TRUE;
}

BOOL CControl_Interface::ReadPLCIOBit()
{
	if(IsConnect() == FALSE)
		return FALSE;

	WORD	RetVal0=0;
	CString	str1;

	memcpy(&RetVal0,m_pSharedMemory+PLC_READ_SIGNAL0,2);

	str1.Format(_T("%x"),RetVal0);		
	str1.MakeUpper();			

	CTransDataManager		TransClass;

	int nRcvData1 = TransClass.Hex2Dec(str1);
	if (m_nRecvedPLCIO1 != nRcvData1)
	{
		m_nRecvedPLCIO1 = nRcvData1;
		m_bRecvedPLCIO1 = TRUE;
	}

	return TRUE;
}

BOOL CControl_Interface::CheckSignal_01()
{
	if(m_bRecvedPLCIO1 == FALSE)
		return TRUE;
	if(m_pI2M == NULL)
		return TRUE;

	ST_PLC_RECIVE_01			pPLCData(m_nRecvedPLCIO1);

	// Glass Loading 
	if (!m_Rcv01.bGlassLoading && pPLCData.bGlassLoading)
	{			
		m_pI2M->IMI2P_PLC_ReceiveSignalValue(C2I_Loading, 1);		
	}	
	// Short Scan Start
	if (!m_Rcv01.bShortScanStart && pPLCData.bShortScanStart)	
	{
		m_pI2M->IMI2P_PLC_ReceiveSignalValue(C2I_ShortScanStart, 1);		
	}
	// Short Scan End
	if (!m_Rcv01.bShortScanEnd && pPLCData.bShortScanEnd)	
	{
		m_pI2M->IMI2P_PLC_ReceiveSignalValue(C2I_ShortScanEnd, 1);		
	}
	// Long Scan Start
	if (!m_Rcv01.bLongScanStart && pPLCData.bLongScanStart)	
	{
		m_pI2M->IMI2P_PLC_ReceiveSignalValue(C2I_LongScanStart, 1);		
	}
	// Long Scan End
	if (!m_Rcv01.bLongScanEnd && pPLCData.bLongScanEnd)	
	{
		m_pI2M->IMI2P_PLC_ReceiveSignalValue(C2I_LongScanEnd, 1);		
	}
	// EMO Grab Stop
	if (!m_Rcv01.bEMOGrabStop && pPLCData.bEMOGrabStop)	
	{
		m_pI2M->IMI2P_PLC_ReceiveSignalValue(C2I_EMOGrabStop, 1);		
	}

	m_Rcv01 = pPLCData;		

	return TRUE;
}

BOOL CControl_Interface::SendConstrol(enInterface_Send_Control enAlarm,int nValue)
{
	if(enAlarm >= enInterface_None)
		return FALSE;

	switch(enAlarm)
	{
		//case SERVER_ALIVE: SendPLCIO_Alive(); break;
	case GLASSLOADING_HANDSHAKE: m_Send01.bGlassLoadingAck = nValue; break;
	case SHORT_SCANSTART_HANDSHAKE: m_Send01.bShortScanStartAck = nValue; break;
	case SHORT_SCANEND_HANDSHAKE: m_Send01.bShortScanEndAck = nValue; break;
	case LONG_SCANSTART_HANDSHAKE: m_Send01.bLongScanStartAck = nValue; break;
	case LONG_SCANEND_HANDSHAKE: m_Send01.bLongScanEndAck = nValue; break;
	default:
		return FALSE;
	}

	return TRUE;
}

BOOL CControl_Interface::SendCIMData(short *pBuf,int nAddr,int nCnt)
{
	if(pBuf == NULL || nCnt <= 0)
		return FALSE;

	if (IsConnect() == FALSE)
		return FALSE;	

	BOOL			bRet = FALSE;
	TCHAR			*tAddr;
	CString			strAddr;

	strAddr.Format(_T("D%d"),nAddr);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;

	bRet = WriteLongPLC( tAddr, (short*)pBuf, nCnt);

	return bRet;
}

BOOL CControl_Interface::CheckAliveTime()
{
	double		CurTime = GetTickCount();

	double		PassTime = CurTime - m_dTickPrevTime;

	if(PassTime > 5000)
	{
		m_dTickPrevTime = CurTime;
		m_Send01.bServerAlive = !m_Send01.bServerAlive;
		return TRUE;
	}

	return FALSE;
}

BOOL CControl_Interface::SendPLCIO_01()
{
	int		nSendData = 0;

	CheckAliveTime();

	m_Send01.MakeSend(nSendData);			

	TCHAR			*tAddr;
	CString			strAddr;

	strAddr.Format(_T("D%d"),PLC_ADDR_SENDSIGNAL1);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;

	WriteLongPLC_Signal(0,tAddr,(short*)&nSendData,1);

	return TRUE;
}

BOOL CControl_Interface::SendPLCIO_Alive()
{	
	if(CheckAliveTime() == FALSE)
		return FALSE;

	TCHAR			*tAddr;
	CString			strAddr;

	strAddr.Format(_T("D%d"),PLC_ADDR_SENDSIGNAL1);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;

	if(WriteWORDOneBitTimer(tAddr,0,1000) == TRUE)
	{
		m_Send01.ChangeSignal(m_SentBack01);
	}	

	return TRUE;
}

int CControl_Interface::GetSignal()
{
	m_nSignal++;
	if(m_nSignal >= PLC_WRITEWORD_TIMER_COUNT) m_nSignal = 0;
	return m_nSignal;
}

int CControl_Interface::GetLongSignal()
{
	m_nLongSignal++;
	if(m_nLongSignal >= PLC_WRITEWORD_LONGDATA_COUNT) m_nLongSignal = 1;
	if(m_nLongSignal <= 0)
		m_nLongSignal = 1;
	return m_nLongSignal;
}

void CControl_Interface::LoadSignalOnTime()
{
	CString		strTaget = _T("C:\\RCutProject\\Config\\SignalOnTime.cfg");

	CFileFind findFile;
	BOOL bFind = findFile.FindFile(strTaget);
	if(bFind == FALSE)
	{
		SaveSignalOnTime();
		return;
	}

	CConfig Config;

	if (!Config.SetRegiConfig(NULL, NULL, (TCHAR*)(LPCTSTR)strTaget, FileMap_Mode))
		return;

	int nIndex = 0;

	Config.GetItemValue(_T("LOADING_OK_ON_TIME"), m_nSignalOnTime[nIndex++], 4000);
	Config.GetItemValue(_T("LOADING_FAIL_ON_TIME"), m_nSignalOnTime[nIndex++], 4000);
	Config.GetItemValue(_T("SHORT_SCAN_START_OK_ON_TIME"), m_nSignalOnTime[nIndex++], 4000);
	Config.GetItemValue(_T("SHORT_SCAN_START_FAIL_ON_TIME"), m_nSignalOnTime[nIndex++], 4000);
	Config.GetItemValue(_T("SHORT_SCAN_END_OK_ON_TIME"), m_nSignalOnTime[nIndex++], 4000);
	Config.GetItemValue(_T("SHORT_SCAN_END_FAIL_ON_TIME"), m_nSignalOnTime[nIndex++], 4000);
	Config.GetItemValue(_T("LONG_SCAN_START_OK_ON_TIME"), m_nSignalOnTime[nIndex++], 4000);
	Config.GetItemValue(_T("LONG_SCAN_START_FAIL_ON_TIME"), m_nSignalOnTime[nIndex++], 4000);
	Config.GetItemValue(_T("LONG_SCAN_END_OK_ON_TIME"), m_nSignalOnTime[nIndex++], 4000);
	Config.GetItemValue(_T("LONG_SCAN_END_FAIL_ON_TIME"), m_nSignalOnTime[nIndex++], 4000);

	nIndex = 0;
	Config.GetItemValue(_T("LOADING_OK_ON_DELAY_TIME"), m_nSignalOnDelayTime[nIndex++], 0);
	Config.GetItemValue(_T("LOADING_FAIL_ON_DELAY_TIME"), m_nSignalOnDelayTime[nIndex++], 0);
	Config.GetItemValue(_T("SHORT_SCAN_START_OK_ON_DELAY_TIME"), m_nSignalOnDelayTime[nIndex++], 0);
	Config.GetItemValue(_T("SHORT_SCAN_START_FAIL_ON_DELAY_TIME"), m_nSignalOnDelayTime[nIndex++], 0);
	Config.GetItemValue(_T("SHORT_SCAN_END_OK_ON_DELAY_TIME"), m_nSignalOnDelayTime[nIndex++], 0);
	Config.GetItemValue(_T("SHORT_SCAN_END_FAIL_ON_DELAY_TIME"), m_nSignalOnDelayTime[nIndex++], 0);
	Config.GetItemValue(_T("LONG_SCAN_START_OK_ON_DELAY_TIME"), m_nSignalOnDelayTime[nIndex++], 0);
	Config.GetItemValue(_T("LONG_SCAN_START_FAIL_ON_DELAY_TIME"), m_nSignalOnDelayTime[nIndex++], 0);
	Config.GetItemValue(_T("LONG_SCAN_END_OK_ON_DELAY_TIME"), m_nSignalOnDelayTime[nIndex++], 0);
	Config.GetItemValue(_T("LONG_SCAN_END_FAIL_ON_DELAY_TIME"), m_nSignalOnDelayTime[nIndex++], 0);
}

void CControl_Interface::SaveSignalOnTime()
{
	CString		strTaget = _T("C:\\RCutProject\\Config\\SignalOnTime.cfg");

	CFileFind findFile;
	BOOL bFind = findFile.FindFile(strTaget);
	if(bFind == FALSE)
		return;

	CConfig Config;

	if (!Config.SetRegiConfig(NULL, NULL, (TCHAR*)(LPCTSTR)strTaget, FileMap_Mode))
		return;

	int nIndex = 0;

	Config.SetItemValue(_T("LOADING_OK_ON_TIME"), m_nSignalOnTime[nIndex++]);
	Config.SetItemValue(_T("LOADING_FAIL_ON_TIME"), m_nSignalOnTime[nIndex++]);
	Config.SetItemValue(_T("SHORT_SCAN_START_OK_ON_TIME"), m_nSignalOnTime[nIndex++]);
	Config.SetItemValue(_T("SHORT_SCAN_START_FAIL_ON_TIME"), m_nSignalOnTime[nIndex++]);
	Config.SetItemValue(_T("SHORT_SCAN_END_OK_ON_TIME"), m_nSignalOnTime[nIndex++]);
	Config.SetItemValue(_T("SHORT_SCAN_END_FAIL_ON_TIME"), m_nSignalOnTime[nIndex++]);
	Config.SetItemValue(_T("LONG_SCAN_START_OK_ON_TIME"), m_nSignalOnTime[nIndex++]);
	Config.SetItemValue(_T("LONG_SCAN_START_FAIL_ON_TIME"), m_nSignalOnTime[nIndex++]);
	Config.SetItemValue(_T("LONG_SCAN_END_OK_ON_TIME"), m_nSignalOnTime[nIndex++]);
	Config.SetItemValue(_T("LONG_SCAN_END_FAIL_ON_TIME"), m_nSignalOnTime[nIndex++]);

	Config.WriteToFile();
}

int CControl_Interface::GetSignalOnTime(int nSignalIndex)
{
	return m_nSignalOnTime[nSignalIndex];
}

int CControl_Interface::GetSignalDelayTime(int nSignalIndex)
{
	return m_nSignalOnDelayTime[nSignalIndex];
}

bool CControl_Interface::WriteCStringPLC(TCHAR* strAddress, CString strData,int nWSize)
{
	if(m_pSharedMemory == NULL )
		return FALSE;

	int iSignal = GetLongSignal();

	int strlength =  lstrlen(strAddress);
	if ( strlength > 6) strlength = 6;
	int				nWORDSize = strData.GetLength()/2+1;

	if(nWSize > 0)
	{
		if(strData.GetLength() < nWSize * 2)
		{
			int nCount = nWSize * 2 - strData.GetLength();
			for(int i = 0; i < nCount;i++)
			{
				strData+=" ";
			}		
		}		
		nWORDSize = nWSize;
	}

	if( nWORDSize > 1000) nWORDSize = 1000;

	int			iAddr,iStartAddr;

	iStartAddr = iAddr = PLC_WRITELONG_SIGNAL+iSignal*PLC_LONGDATA_MAXSIZE;

	iAddr+=1;
	memset(m_pSharedMemory+iAddr, 0x00, 7*sizeof(TCHAR));
	memcpy(m_pSharedMemory+iAddr, strAddress,strlength*sizeof(TCHAR));
	iAddr+=14;
	memcpy(m_pSharedMemory+iAddr, &nWORDSize, sizeof(unsigned int));
	iAddr+=4;
	if(strlength != 0)
		memcpy(m_pSharedMemory+iAddr, strData.GetBuffer(0), nWORDSize*2);
	else
		memset(m_pSharedMemory+iAddr, 0x00, nWORDSize);

	//¸ðµç °ªÀ» ä¿ö ³ÖÀº ÈÄ PLCConnector¿¡°Ô PLC ÁÖ¼Ò¿¡ °ªÀ» Àûµµ·Ï ½ÅÈ£¸¦ º¸³½´Ù.
	m_pSharedMemory[iStartAddr] = 1;

	return true;
}

bool CControl_Interface::WriteLongPLC_Signal(int iLongSigIdx,TCHAR* strAddress, short* WriteData, unsigned int nWORDSize)
{
	if(m_pSharedMemory == NULL )
		return FALSE;

	//int iSignal = GetLongSignal();

	int iSignal = iLongSigIdx;

	int strlength =  lstrlen(strAddress);
	if ( strlength > 6) strlength = 6;

	if( nWORDSize > 1000) nWORDSize = 1000;
	int			iAddr,iStartAddr;

	iStartAddr = iAddr = PLC_WRITELONG_SIGNAL+iSignal*PLC_LONGDATA_MAXSIZE;

	iAddr+=1;
	memset(m_pSharedMemory+iAddr, 0x00, 7*sizeof(TCHAR));
	memcpy(m_pSharedMemory+iAddr, strAddress,strlength*sizeof(TCHAR));
	iAddr+=14;
	memcpy(m_pSharedMemory+iAddr, &nWORDSize, sizeof(unsigned int));
	iAddr+=4;
	memcpy(m_pSharedMemory+iAddr, WriteData, nWORDSize*2);

	m_pSharedMemory[iStartAddr] = 1;
	return true;
}

bool CControl_Interface::WriteLongPLC(TCHAR* strAddress, short* WriteData, unsigned int nWORDSize)
{
	if(m_pSharedMemory == NULL )
		return FALSE;

	int iSignal = GetLongSignal();

	int strlength =  lstrlen(strAddress);
	if ( strlength > 6) strlength = 6;

	if( nWORDSize > 1000) nWORDSize = 1000;
	int			iAddr,iStartAddr;

	iStartAddr = iAddr = PLC_WRITELONG_SIGNAL+iSignal*PLC_LONGDATA_MAXSIZE;

	iAddr+=1;
	memset(m_pSharedMemory+iAddr, 0x00, 7*sizeof(TCHAR));
	memcpy(m_pSharedMemory+iAddr, strAddress,strlength*sizeof(TCHAR));
	iAddr+=14;
	memcpy(m_pSharedMemory+iAddr, &nWORDSize, sizeof(unsigned int));
	iAddr+=4;
	memcpy(m_pSharedMemory+iAddr, WriteData, nWORDSize*2);

	//¸ðµç °ªÀ» ä¿ö ³ÖÀº ÈÄ PLCConnector¿¡°Ô PLC ÁÖ¼Ò¿¡ °ªÀ» Àûµµ·Ï ½ÅÈ£¸¦ º¸³½´Ù.
	m_pSharedMemory[iStartAddr] = 1;
	return true;
}

bool CControl_Interface::WriteWordArrayPLC(TCHAR* strAddress, WORD* WriteData, unsigned int nArraySize)
{
	return WriteLongPLC(strAddress, (short*) WriteData, nArraySize);
}

bool CControl_Interface::WriteIntArrayPLC(TCHAR* strAddress, int* WriteData, unsigned int nArraySize)
{
	return WriteLongPLC( strAddress, (short*) WriteData, 2*nArraySize);
}

bool CControl_Interface::WriteWORDPLCTimer(TCHAR* strAddress, short WriteData, DWORD msecTimer)
{
	if(m_pSharedMemory == NULL )
		return FALSE;

	int strlength =  lstrlen(strAddress);
	if ( strlength > 6) strlength = 6;

	int			iAddr,iStartAddr;

	int iSignal = GetSignal();
	iStartAddr = iAddr = PLC_WRITEWORD_SIGNAL+iSignal*PLC_WRITEWORD_TIMER_SIZE;

	iAddr+=1;
	memset(m_pSharedMemory+iAddr, 0x00, 7*sizeof(TCHAR));
	memcpy(m_pSharedMemory+iAddr, strAddress,strlength*sizeof(TCHAR));
	iAddr+=14;
	memcpy(m_pSharedMemory+iAddr, &WriteData, 2);
	iAddr+=2;
	memcpy(m_pSharedMemory+iAddr, &msecTimer, 4);

	//¸ðµç °ªÀ» ä¿ö ³ÖÀº ÈÄ PLCConnector¿¡°Ô PLC ÁÖ¼Ò¿¡ °ªÀ» Àûµµ·Ï ½ÅÈ£¸¦ º¸³½´Ù.
	m_pSharedMemory[iStartAddr] = 1;
	return true;
}

bool  CControl_Interface::WriteWORDOneBitTimer(TCHAR* strAddress, short BITOrder, DWORD msecTimer)
{
	if(m_pSharedMemory == NULL)
		return FALSE;

	int strlength =  lstrlen(strAddress);
	if ( strlength > 6) strlength = 6;

	short WriteData = (1 << BITOrder);

	int			iAddr,iStartAddr;
	int iSignal = GetSignal();

	iStartAddr = iAddr = PLC_WRITEWORD_SIGNAL+iSignal*PLC_WRITEWORD_TIMER_SIZE;

	iAddr+=1;
	memset(m_pSharedMemory+iAddr, 0x00, 7*sizeof(TCHAR));
	memcpy(m_pSharedMemory+iAddr, strAddress,strlength*sizeof(TCHAR));
	iAddr+=14;
	memcpy(m_pSharedMemory+iAddr, &WriteData, 2);
	iAddr+=2;
	memcpy(m_pSharedMemory+iAddr, &msecTimer, 4);

	//¸ðµç °ªÀ» ä¿ö ³ÖÀº ÈÄ PLCConnector¿¡°Ô PLC ÁÖ¼Ò¿¡ °ªÀ» Àûµµ·Ï ½ÅÈ£¸¦ º¸³½´Ù.
	m_pSharedMemory[iStartAddr] = 1;
	return true;
}

bool CControl_Interface::WriteWORDManyBitsTimer(TCHAR* strAddress, char* BitFlag, DWORD msecTimer)
{
	short WriteData = 0;

	for( int i = 0; i < 16; i++)
		WriteData |= (BitFlag[i] << i);

	return WriteWORDPLCTimer( strAddress,  WriteData, msecTimer);
}

BOOL CControl_Interface::SendIntPLCData(char cDevice, int nAddr, int nData)
{
	if (IsConnect() == FALSE)
		return FALSE;	

	BOOL			bRet = FALSE;
	TCHAR			*tAddr;
	CString			strAddr;

	strAddr.Format(_T("%c%d"),cDevice,nAddr);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;

	bRet = WriteLongPLC( tAddr, (short*)&nData, 2);

	return bRet;

}

BOOL CControl_Interface::SendWordArrayPLCData(char cDevice, int nAddr, WORD* pData, int nLen)
{
	if (IsConnect() == FALSE)
		return FALSE;	

	BOOL			bRet = FALSE;	
	TCHAR			*tAddr;
	CString			strAddr;

	strAddr.Format(_T("%c%d"),cDevice,nAddr);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;

	bRet = WriteWordArrayPLC(tAddr,pData,nLen);		

	return bRet;
}

BOOL CControl_Interface::SendIntArrayPLCData(char cDevice, int nAddr, int* pData, int nLen)
{
	if (IsConnect() == FALSE)
		return FALSE;	

	BOOL			bRet = FALSE;	
	TCHAR			*tAddr;
	CString			strAddr;

	strAddr.Format(_T("%c%d"),cDevice,nAddr);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;

	bRet = WriteIntArrayPLC(tAddr,pData,nLen);		

	return bRet;
}

BOOL CControl_Interface::RecvPLCData(char cDevice , int nAddr, char* pData, unsigned short nWORDSize)
{
	if (IsConnect() == FALSE)
		return FALSE;

	TCHAR			*tAddr;
	CString			strAddr;

	strAddr.Format(_T("%c%d"),cDevice,nAddr);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;

	BOOL bRet = FALSE;

	bRet = ReadLongData( pData, tAddr, nWORDSize);

	return bRet;
}

BOOL CControl_Interface::ReadPLCDataDec(char cMemory, int nAddr, int &nData, int nByteSize)
{
	TCHAR			*tAddr;
	CString			strAddr;

	strAddr.Format(_T("%c%d"),cMemory,nAddr);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;	

	char RetData[2048] = {0};
	CString			pString;

	ReadLongData(RetData,tAddr,nByteSize/2);			

	CTransDataManager		TransClass;

	char* pstrHex = new char[nByteSize * 2 +1];
	CStringA strRetA = ("");
	memset( pstrHex,0,sizeof(char)*(nByteSize * 2 +1) );

	StrToHex(pstrHex,RetData,nByteSize, TRUE);
	strRetA = pstrHex;
	nData = TransClass.Hex2UnsignedDec( (CString)strRetA );

	delete [] pstrHex;

	return TRUE;
}

// ½ºÆ®¸µ -> 16Áø¼ö
BOOL CControl_Interface::StrToHex(CHAR* pchData, CHAR* pchDataSrc, INT nLength, BOOL bWordReverse)
{
	//static UCHAR saucHex[] = "0123456789ABCDEF";
	for(int i=0; i<nLength/2; i++)
	{
		sprintf(&pchData[i*4], "%02X%02X", pchDataSrc[i*2+1] & 0xFF, pchDataSrc[i*2+0] & 0xFF);

		if(pchData[i*4+0]=='2' && pchData[i*4+1]=='0')
		{
			pchData[i*4+0]=0;
			pchData[i*4+1]=0;
		}
		if(pchData[i*4+2]=='2' && pchData[i*4+3]=='0')
		{
			pchData[i*4+2]=0;
			pchData[i*4+3]=0;
		}
	}

	if( bWordReverse == TRUE && nLength >= 4 && nLength % 4 == 0)
	{
		char szBuffer[4] = {0,};
		for(int i=0; i< nLength*2; i+=8)
		{
			memcpy(szBuffer,&pchData[i],4);
			memcpy(&pchData[i],&pchData[i+4],4);
			memcpy(&pchData[i+4],szBuffer,4);

		}
	}
	return TRUE;
}

BOOL CControl_Interface::ReadPLCData(int nAddr, int& nData)
{
	TCHAR			*tAddr;
	CString			strAddr;

	strAddr.Format(_T("D%d"),nAddr);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;	

	char RetData[2048] = {0};
	CString			pString;

	ReadLongData(RetData,tAddr,1);		

	CTransDataManager		TransClass;
	pString.Format(_T("%s"),RetData);

	if (pString.GetLength() <= 0)
		return FALSE;

	nData = TransClass.Hex2Dec(pString);

	return TRUE;
}

BOOL CControl_Interface::ReadPLCData(int nAddr, int &nData, int nLen)
{
	if (IsConnect() == FALSE)
		return FALSE;

	TCHAR			*tAddr;
	CString			strAddr;
	CString			pString;

	strAddr.Format(_T("D%d"),nAddr);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;	

	char RetData[2048] = {0};

	ReadLongData(RetData,tAddr,nLen);	
	pString.Format(_T("%s"),RetData);

	if (pString.GetLength() <= 0)
		return FALSE;

	CString		strRead = pString;
	CString		strConvert;

	if(strRead.GetLength() < 8)
		return FALSE;

	strConvert = strRead.Right(4);
	strConvert += strRead.Left(4);

	CTransDataManager		TransClass;

	nData = TransClass.Hex2Dec(strConvert);

	return TRUE;
}

BOOL CControl_Interface::ReadPLCData(int nAddr, CString& strData, int nLen)
{
	if (IsConnect() == FALSE)
		return FALSE;

	TCHAR			*tAddr;
	CString			strAddr;
	CString			pString;

	strAddr.Format(_T("D%d"),nAddr);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;	

	char RetData[2048] = {0};

	ReadLongData(RetData,tAddr,nLen);	
	pString.Format(_T("%s"),RetData);

	if (pString.GetLength() <= 0)
		return FALSE;

	int nAddress = 0;

	strData = pString;	

	return TRUE;
}

BOOL CControl_Interface::ReadPLCData(char cMemory, int nAddr, CString& strData, int nLen)
{
	if (IsConnect() == FALSE)
		return FALSE;

	TCHAR			*tAddr;
	CString			strAddr;
	CString			pString;

	strAddr.Format(_T("%c%d"),cMemory,nAddr);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;	

	char RetData[2048] = {0};

	ReadLongData(RetData,tAddr,nLen);	
	pString.Format(_T("%s"),RetData);

	if (pString.GetLength() <= 0)
		return FALSE;

	int nAddress = 0;

	strData = pString;

	return TRUE;
}

BOOL CControl_Interface::ReadTIMEData(char cMemory, int nAddr, CString& strData, int nLen, SYSTEMTIME &sTime)
{
	CString strYear, strMonth, strDay, strHour, strMinute, strSecond;

	if (IsConnect() == FALSE)
		return FALSE;

	TCHAR			*tAddr;
	CString			strAddr;
	CString			pString;

	strAddr.Format(_T("%c%d"),cMemory,nAddr);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;	

	char RetData[2048] = {0};

	ReadLongData(RetData,tAddr,nLen);	
	pString.Format(_T("%s"),RetData);

	if (pString.GetLength() <= 0)
		return FALSE;

	int nAddress = 0;

	strData = pString;	

	return TRUE;
}

BOOL CControl_Interface::SendPLCData(int nAddr, int nData)
{
	if (IsConnect() == FALSE)
		return FALSE;

	BOOL			bRet = FALSE;	
	TCHAR			*tAddr;
	CString			strAddr;

	strAddr.Format(_T("D%d"),nAddr);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;		

	bRet = WriteWORDPLCTimer(tAddr,nData,1000);	

	return bRet;
}

BOOL CControl_Interface::SendPLCData_NoTimer(int nAddr, int nData, int nLen)
{
	if (IsConnect() == FALSE)
		return FALSE;

	BOOL bRet = FALSE;
	TCHAR			*tAddr;
	CString			strAddr;

	strAddr.Format(_T("D%d"),nAddr);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;		

	bRet = WriteLongPLC( tAddr, (short*)&nData, nLen);	

	return bRet;
}

BOOL CControl_Interface::SendPLCBItData(int nAddr, short nBit)
{
	if (IsConnect() == FALSE)
		return FALSE;

	BOOL bRet = FALSE;	
	TCHAR			*tAddr;
	CString			strAddr;

	strAddr.Format(_T("D%d"),nAddr);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;		

	bRet = WriteWORDOneBitTimer(tAddr,nBit,1000);

	return bRet;
}

BOOL CControl_Interface::SendPLCData(char cDevice, int nAddr, CString& strData, int nLen)
{
	if (IsConnect() == FALSE)
		return FALSE;	

	BOOL			bRet = FALSE;	
	TCHAR			*tAddr;
	CString			strAddr;

	strAddr.Format(_T("%c%d"),cDevice,nAddr);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;

	bRet = WriteCStringPLC(tAddr,strData,nLen);			

	return bRet;
}

BOOL CControl_Interface::ReadTransferData(CTransDataManager *TData,char *lpTransBuffer,int Addr)
{
	CString		pString,strAddr;
	short		nDataSize;

	nDataSize = TData->GetDataPackTotalByteSize()/2;
	if(TData->GetDataPackTotalByteSize()%2 > 0)
		nDataSize++;

	TCHAR			*tAddr;

	strAddr.Format(_T("D%d"),Addr);
	tAddr = (TCHAR *)(LPCTSTR)strAddr;		

	ReadLongData(lpTransBuffer,tAddr,nDataSize);			

	CString		strTmp;

	for(int i=0;i<nDataSize;i++)
	{
		strTmp += lpTransBuffer[i];
	}

	//g_pLog->DisplayMessage(_T("Read TransferData : %s"),strTmp);


	return TData->InsertPLCValueToMap(lpTransBuffer,nDataSize*2);
}

bool CControl_Interface::ReadLongData(char* pData, TCHAR* strAddress, unsigned short nWORDSize)
{
	if(m_pSharedMemory == NULL)
		return FALSE;

	int strlength =  lstrlen(strAddress);
	if ( strlength > 6) strlength = 6;	

	if( nWORDSize > 1000) nWORDSize = 1000;
	//°øÀ¯ ¸Þ¸ð¸®¿¡ ¹°·ùµ¥ÀÌÅ͸¦ Àеµ·Ï ½ÅÈ£¸¦ º¸³½´Ù.
	ZeroMemory(m_pSharedMemory+PLC_READ_LONGDATA_ADDRESS_1,(PLC_READ_LONGDATA_LENGTH_1)-(PLC_READ_LONGDATA_ADDRESS_1));
	memcpy(m_pSharedMemory+PLC_READ_LONGDATA_ADDRESS_1, strAddress,strlength*sizeof(TCHAR));
	memcpy(m_pSharedMemory+PLC_READ_LONGDATA_LENGTH_1, &nWORDSize,2);
	memset(m_pSharedMemory+PLC_READ_LONGDATA_SIGNAL_1, 0x01, 1);

	//µ¥ÀÌÅ͸¦ ´Ù ÀÐ°í °øÀ¯¸Þ¸ð¸® ÀûÀ» ¶§±îÁö ±â´Ù¸°´Ù.
	::WaitForSingleObject(m_ReadEvent,2000);

	//¿Ï·á°¡ µÇ¸é ÇØ´ç °ªÀ» ´Ù½Ã Àоî¿Â´Ù.
	//pData = m_pSharedMemory+PLC_READ_LONGDATA_VALUE;

	memcpy(pData, m_pSharedMemory+PLC_READ_LONGDATA_VALUE_1, nWORDSize*2);

	return true;
}

BOOL CControl_Interface::SendJudgement(int nJudge)
{
	g_pLog->DisplayMessage(_T("Send Glass Judgement : %d"),nJudge);			

	return SendPLCData_NoTimer(PLC_ADDR_GLASS_JUDEMENT, nJudge, 1);
}

BOOL CControl_Interface::ReadRcpHandNo(int &nRcpNo,int &nHandNo)
{
	nRcpNo = 0;
	nHandNo = 0;	

	ReadPLCData(520,nRcpNo);

	g_pLog->DisplayMessage(_T("Read Rcp No D520 : %d"),nRcpNo);

	ReadPLCData(521,nHandNo);

	g_pLog->DisplayMessage(_T("Read Hand No D521 : %d"),nHandNo);

	return TRUE;
}