// PLCConnectorView.cpp : CPLCConnectorView Ŭ·¡½ºÀÇ ±¸Çö
//

#include "stdafx.h"
#include "PLCConnector.h"

#include "PLCConnectorDoc.h"
#include "PLCConnectorView.h"

#include "SetOptionDlg.h"


#ifdef _DEBUG
#define new DEBUG_NEW
#endif


#define		ID_TIMER_PLCCONNECTOR		1010
#define		COPYDATA_PLCCONNECTOR		2421

// CPLCConnectorView

IMPLEMENT_DYNCREATE(CPLCConnectorView, CFormView)

BEGIN_MESSAGE_MAP(CPLCConnectorView, CFormView)
	ON_WM_DESTROY()
	ON_COMMAND(ID_SET_OPTION, &CPLCConnectorView::OnSetOption)
	ON_MESSAGE(UM_EXITPROGRAM,&CPLCConnectorView::OnExitProgram)
	ON_MESSAGE(UM_PRINTPLCDATA,&CPLCConnectorView::OnPrintListPLCData)
	ON_BN_CLICKED(IDC_CHECK_Scroll, &CPLCConnectorView::OnBnClickedCheckScroll)
	ON_WM_TIMER()
END_MESSAGE_MAP()

// CPLCConnectorView »ý¼º/¼Ò¸ê
bool CPLCConnectorView::m_bThreadEnd = false;

CPLCConnectorView::CPLCConnectorView()
: CFormView(CPLCConnectorView::IDD)
, m_bExit(false)
,m_ReadEvent_1(FALSE,FALSE,_T("PLCConnector_Event_1"))
,m_ReadEvent_2(FALSE,FALSE,_T("PLCConnector_Event_2"))
,m_ReadEvent_3(FALSE,FALSE,_T("PLCConnector_Event_3"))
, m_bAutoScroll(TRUE)
{
	//¹°·ù µ¥ÀÌÅ͸¦ ´ã°í ÀÖ´Â PLC ÁÖ¼Ò °ª
	memset(m_AddressToReadLongData,0x00,7*sizeof(TCHAR));
	m_ReadCount = 0;
	m_pSharedMemory = NULL;
}

CPLCConnectorView::~CPLCConnectorView()
{
	
}

void CPLCConnectorView::DoDataExchange(CDataExchange* pDX)
{
	CFormView::DoDataExchange(pDX);
	//DDX_Control(pDX, IDC_ACTEASYIF1, m_MXComponent);
	DDX_Control(pDX, IDC_ACTUTLTYPE1, m_MXComponent);
	DDX_Control(pDX, IDC_ConnetorSatate, m_ConnectorState);
	DDX_Check(pDX, IDC_CHECK_Scroll, m_bAutoScroll);
}

BOOL CPLCConnectorView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: CREATESTRUCT cs¸¦ ¼öÁ¤ÇÏ¿© ¿©±â¿¡¼­
	//  Window Ŭ·¡½º ¶Ç´Â ½ºÅ¸ÀÏÀ» ¼öÁ¤ÇÕ´Ï´Ù.

	return CFormView::PreCreateWindow(cs);
}

void CPLCConnectorView::OnInitialUpdate()
{
	CFormView::OnInitialUpdate();
	GetParentFrame()->RecalcLayout();
	ResizeParentToFit();

	//°¢ ¸â¹öº¯¼ö¸¦ ÃʱâÈ­
	InitValue();

	//ÇÁ·Î±×·¥ ¼³Á¤À» Àоî¿Â´Ù.
	LoadINIFile();

	OpenPLCConnection();

	//¼­¹ö¿Í Åë½ÅÀ» À§ÇÑ °øÀ¯ ¸Þ¸ð¸® ¸Ê »ý¼º
	if (!InitSharedMemory()) 
	{
		//½ÇÆнà ÇÁ·Î±×·¥ Á¾·á
		PostMessage(UM_EXITPROGRAM);
		return;
	}

	//Read ½º·¹µå »ý¼º
	AfxBeginThread(CPLCConnectorView::ReadPLCWorkerThread,(LPVOID)(this));

	//Write ½º·¹µå »ý¼º
	AfxBeginThread(CPLCConnectorView::WritePLCWorkerThread,(LPVOID)(this));	

	SetTimer(ID_TIMER_PLCCONNECTOR,1000,NULL);	
}

void CPLCConnectorView::InitValue(void)
{
	//PLC SignalÀ» ÀоîµéÀÏ ÁÖ¼Ò°¡ ¼³Á¤µÊ
	::ZeroMemory( m_AddressToReadSignal0, sizeof(TCHAR)*7);
	::ZeroMemory( m_AddressToReadSignal1, sizeof(TCHAR)*7);
	::ZeroMemory( m_AddressToReadSignal2, sizeof(TCHAR)*7);
	::ZeroMemory( m_AddressToReadSignal3, sizeof(TCHAR)*7);
	::ZeroMemory( m_AddressToReadSignal4, sizeof(TCHAR)*7);

	int i = 0;
	//PLC Read SignalÀ» »ç¿ëÇÒ Áö ¿©ºÎ°¡ ¼³Á¤µÈ Ç÷¡±×
	for(i = 0; i < MAX_READSIGNAL; i++)
		m_bUseReadSignal[i] = 0;

	//PLC Connector »ç¿ë ¸ðµå : 0 MC Protocol, 1: MX Componnet
	m_nPLCConnectMode = MC_Protocol;
}


void CPLCConnectorView::OnRButtonUp(UINT nFlags, CPoint point)
{
	ClientToScreen(&point);
	OnContextMenu(this, point);
}

void CPLCConnectorView::OnContextMenu(CWnd* pWnd, CPoint point)
{
	theApp.GetContextMenuManager()->ShowPopupMenu(IDR_POPUP_EDIT, point.x, point.y, this, TRUE);
}


// CPLCConnectorView Áø´Ü

#ifdef _DEBUG
void CPLCConnectorView::AssertValid() const
{
	CFormView::AssertValid();
}

void CPLCConnectorView::Dump(CDumpContext& dc) const
{
	CFormView::Dump(dc);
}

CPLCConnectorDoc* CPLCConnectorView::GetDocument() const // µð¹ö±×µÇÁö ¾ÊÀº ¹öÀüÀº ÀζóÀÎÀ¸·Î ÁöÁ¤µË´Ï´Ù.
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CPLCConnectorDoc)));
	return (CPLCConnectorDoc*)m_pDocument;
}
#endif //_DEBUG


// CPLCConnectorView ¸Þ½ÃÁö 󸮱â

void CPLCConnectorView::LoadINIFile(void)
{
	CString Path;
	GetModulePath(Path);

	CString INIFilePath;
	INIFilePath.Format(_T("%sPLCConnector.ini"),Path);

	CFileFind finder;

	if(TRUE == finder.FindFile(INIFilePath))
	{
		::GetPrivateProfileString(_T("SAVE_OPTION"),_T("ADDRESS_TOREAD_SIGNAL0"),_T("D0"), m_AddressToReadSignal0,6,INIFilePath);
		m_bUseReadSignal[0] = ::GetPrivateProfileInt(_T("SAVE_OPTION"),_T("USEREADSIGNAL0"),0,INIFilePath);
		::GetPrivateProfileString(_T("SAVE_OPTION"),_T("ADDRESS_TOREAD_SIGNAL1"),_T("D1"), m_AddressToReadSignal1,6,INIFilePath);
		m_bUseReadSignal[1] = ::GetPrivateProfileInt(_T("SAVE_OPTION"),_T("USEREADSIGNAL1"),0,INIFilePath);
		::GetPrivateProfileString(_T("SAVE_OPTION"),_T("ADDRESS_TOREAD_SIGNAL2"),_T("D2"), m_AddressToReadSignal2,6,INIFilePath);
		m_bUseReadSignal[2] = ::GetPrivateProfileInt(_T("SAVE_OPTION"),_T("USEREADSIGNAL2"),0,INIFilePath);
		::GetPrivateProfileString(_T("SAVE_OPTION"),_T("ADDRESS_TOREAD_SIGNAL3"),_T("D3"), m_AddressToReadSignal3,6,INIFilePath);
		m_bUseReadSignal[3] = ::GetPrivateProfileInt(_T("SAVE_OPTION"),_T("USEREADSIGNAL3"),0,INIFilePath);
		::GetPrivateProfileString(_T("SAVE_OPTION"),_T("ADDRESS_TOREAD_SIGNAL4"),_T("D4"), m_AddressToReadSignal4,6,INIFilePath);
		m_bUseReadSignal[4] = ::GetPrivateProfileInt(_T("SAVE_OPTION"),_T("USEREADSIGNAL4"),0,INIFilePath);

		m_nPLCConnectMode = ::GetPrivateProfileInt(_T("SAVE_OPTION"),_T("PROTOCOL"),0,INIFilePath);
		m_dwAddress = ::GetPrivateProfileInt(_T("SAVE_OPTION"),_T("IP_ADDRESS"),htonl(inet_addr("126.100.100.50")),INIFilePath);
		m_nPort = ::GetPrivateProfileInt(_T("SAVE_OPTION"),_T("PORT_NO"),4096,INIFilePath);
		m_StationNumber = ::GetPrivateProfileInt(_T("SAVE_OPTION"),_T("STATION_NO"),11,INIFilePath);

		m_bUseAOISignal = ::GetPrivateProfileInt(_T("SAVE_OPTION"),_T("USE_AOISIGNAL"),0,INIFilePath);
		::GetPrivateProfileString(_T("SAVE_OPTION"),_T("AOISERVER_CAPTION"),_T("! Inspection ! D.I.T"), m_strAOICaption,100,INIFilePath);
	}
	else
	{
		CString			str;

		str.Format(_T("D2300"));
		CopyMemory(m_AddressToReadSignal0,str.GetBuffer(0),sizeof(TCHAR)*str.GetLength());		 
		CopyMemory(m_AddressToReadSignal1,str.GetBuffer(0),sizeof(TCHAR)*str.GetLength());
		CopyMemory(m_AddressToReadSignal2,str.GetBuffer(0),sizeof(TCHAR)*str.GetLength());
		CopyMemory(m_AddressToReadSignal3,str.GetBuffer(0),sizeof(TCHAR)*str.GetLength());
		CopyMemory(m_AddressToReadSignal4,str.GetBuffer(0),sizeof(TCHAR)*str.GetLength());
		m_bUseReadSignal[0] = FALSE;
		m_bUseReadSignal[1] = FALSE;
		m_bUseReadSignal[2] = FALSE;
		m_bUseReadSignal[3] = FALSE;
		m_bUseReadSignal[4] = FALSE;
		m_StationNumber = 11;

		m_bUseAOISignal = FALSE;		
		SaveINIFile();
	}	
}


void CPLCConnectorView::SaveINIFile(void)
{
	CString Path;
	GetModulePath(Path);

	CString INIFilePath;
	INIFilePath.Format(_T("%sPLCConnector.ini"),Path);

	//Signal0
	WritePrivateProfileString(_T("SAVE_OPTION"),_T("ADDRESS_TOREAD_SIGNAL0"),m_AddressToReadSignal0,INIFilePath);
	CString ValueOfSetting;
	ValueOfSetting = _T("");
	ValueOfSetting.Format(_T("%d"),m_bUseReadSignal[0]);
	WritePrivateProfileString(_T("SAVE_OPTION"),_T("USEREADSIGNAL0"),ValueOfSetting,INIFilePath);

	//Signal1
	WritePrivateProfileString(_T("SAVE_OPTION"),_T("ADDRESS_TOREAD_SIGNAL1"),m_AddressToReadSignal1,INIFilePath);
	ValueOfSetting = _T("");
	ValueOfSetting.Format(_T("%d"),m_bUseReadSignal[1]);
	WritePrivateProfileString(_T("SAVE_OPTION"),_T("USEREADSIGNAL1"),ValueOfSetting,INIFilePath);

	//Signal2
	WritePrivateProfileString(_T("SAVE_OPTION"),_T("ADDRESS_TOREAD_SIGNAL2"),m_AddressToReadSignal2,INIFilePath);
	ValueOfSetting = _T("");
	ValueOfSetting.Format(_T("%d"),m_bUseReadSignal[2]);
	WritePrivateProfileString(_T("SAVE_OPTION"),_T("USEREADSIGNAL2"),ValueOfSetting,INIFilePath);

	//Signal3
	WritePrivateProfileString(_T("SAVE_OPTION"),_T("ADDRESS_TOREAD_SIGNAL3"),m_AddressToReadSignal3,INIFilePath);
	ValueOfSetting = _T("");
	ValueOfSetting.Format(_T("%d"),m_bUseReadSignal[3]);
	WritePrivateProfileString(_T("SAVE_OPTION"),_T("USEREADSIGNAL3"),ValueOfSetting,INIFilePath);

	//Signal4
	WritePrivateProfileString(_T("SAVE_OPTION"),_T("ADDRESS_TOREAD_SIGNAL4"),m_AddressToReadSignal4,INIFilePath);
	ValueOfSetting = _T("");
	ValueOfSetting.Format(_T("%d"),m_bUseReadSignal[4]);
	WritePrivateProfileString(_T("SAVE_OPTION"),_T("USEREADSIGNAL4"),ValueOfSetting,INIFilePath);

	ValueOfSetting.Format(_T("%d"),m_bUseAOISignal);
	WritePrivateProfileString(_T("SAVE_OPTION"),_T("USE_AOISIGNAL"),ValueOfSetting,INIFilePath);

	WritePrivateProfileString(_T("SAVE_OPTION"),_T("AOISERVER_CAPTION"),m_strAOICaption,INIFilePath);	
}


bool CPLCConnectorView::GetModulePath(CString& strPath)
{
	TCHAR szBuffer[MAX_PATH]= {0};

	::GetModuleFileName(NULL,szBuffer,MAX_PATH);

	for(int i = lstrlen(szBuffer) -1; i>=0; --i)
	{
		if(szBuffer[i] == '\\')
		{
			int j = lstrlen(szBuffer)-1;
			for(;j>=i;--j)
			{
				szBuffer[j] = NULL;
			}

			if(szBuffer[j] == ';') szBuffer[j+1] = '\\';

			szBuffer[j+1] = '\\';

			strPath = szBuffer;
			return true;
		}
	}
	return false;
}


void CPLCConnectorView::OnDestroy()
{
	ExitPLCProgram();

	CFormView::OnDestroy();
}

void CPLCConnectorView::OnSetOption()
{
	// TODO: ¿©±â¿¡ ¸í·É 󸮱â Äڵ带 Ãß°¡ÇÕ´Ï´Ù.
	CSetOptionDlg OptionDlg;
	OptionDlg.DoModal();
}

LRESULT CPLCConnectorView::OnExitProgram(WPARAM wParam, LPARAM lParam)
{
	CFrameWnd *pMainFrame = GetParentFrame();
	if (pMainFrame != NULL)
	{	
		if (!m_bExit)
		{
			WriteLocalLog(FALSE, _T("OnExitProgram"));
			ExitPLCProgram(false);
			m_bExit = true;
			pMainFrame->PostMessage(WM_COMMAND,ID_APP_EXIT);
		}
	}

	return 0;
}

bool CPLCConnectorView::InitSharedMemory(void)
{
	m_hMap = ::CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE
								, 0, SHARED_MEMORY_SIZE, _T("MX_COMPONENT_SHARED_MEMORY"));
	if (::GetLastError() == ERROR_ALREADY_EXISTS)
	{
		m_hMap = ::OpenFileMapping(FILE_MAP_ALL_ACCESS,FALSE,_T("MX_COMPONENT_SHARED_MEMORY"));
	}

	if (m_hMap == NULL)
	{
		WriteLocalLog(FALSE, _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)
	{
		WriteLocalLog(FALSE, _T("ERROR: Failed to get shared memory!"));		
		return false;
	}


	ZeroMemory(m_pSharedMemory,SHARED_MEMORY_SIZE);
	return true;
}

void CPLCConnectorView::ExitPLCProgram(bool close)
{
	m_bThreadEnd = true;
	WriteLocalLog(FALSE, _T("ExitPLCProgram"));
	Sleep(500);
	if (m_pSharedMemory!=NULL)
	{
		::UnmapViewOfFile(m_pSharedMemory);
		m_pSharedMemory = NULL;
	}

	if (m_hMap != NULL )	
	{
		::CloseHandle(m_hMap);
		m_hMap = NULL;
	}

	for (m_itorList = m_ListWriteData.begin();m_itorList != m_ListWriteData.end(); m_itorList++)
	{
		if ((*m_itorList))
		{
			delete (*m_itorList);
			(*m_itorList) = NULL;
		}
	}
	m_ListWriteData.clear();


	if (close)
	{
		ClosePLCConnection();
	}
	
	Sleep(100);
}

UINT CPLCConnectorView::WritePLCWorkerThread(LPVOID pParam)
{
	CPLCConnectorView* pView = (CPLCConnectorView*)pParam;
	while (true)
	{
		Sleep(20);
		if (m_bThreadEnd) break;

		//PLC ¾²±â ½ÅÈ£°¡ ÀÖÀ¸¸é °ªÀ» Àû´Â´Ù.
		pView->WritePLCDataTimer();

		//PLC ¾²±â ½ÅÈ£°¡ ÀÖÀ¸¸é °ªÀ» Àû´Â´Ù.
		pView->WritePLCData();

		//PLC Timer¿¡ ¼³Á¤µÈ ½Ã°£ÀÌ Áö³ª¸é ¸®¼Â °ªÀ» Àû´Â´Ù.
		pView->ResetPLCData();
	}
	return 0;
}

bool CPLCConnectorView::CheckRequestToWritePLC(int iAddr)
{
	//PLC ¾²±â ½ÅÈ£°¡ ¿Ô´ÂÁö üũÇÑ´Ù. 
	if (m_pSharedMemory != NULL && m_pSharedMemory[iAddr])
	{
		m_pSharedMemory[iAddr] = 0;
		return true;
	}
	else return false;
}

void CPLCConnectorView::WritePLCDataTimer(void)
{
	int			iSignal,iAddr;

	TCHAR NULLCHECK[PLC_READ_ADDRESS_LENGTH];

	//½Ã±×³Î ¾²±â 10°³ È®Àå
	for(iSignal=0;iSignal<PLC_WRITEWORD_TIMER_COUNT;iSignal++)
	{
		iAddr = PLC_WRITEWORD_SIGNAL+iSignal*PLC_WRITEWORD_TIMER_SIZE;
		if (CheckRequestToWritePLC(iAddr))
		{
			//OutputDebugString(_T("WritePLCData1!\n"));
			PLCWRITE_DATA* pWriteData1 = new PLCWRITE_DATA;
			
			iAddr+=1;
			memset(pWriteData1->WriteAddress,0x00,PLC_READ_ADDRESS_LENGTH*sizeof(TCHAR));
			memcpy(pWriteData1->WriteAddress, m_pSharedMemory+iAddr, (PLC_READ_ADDRESS_LENGTH-1)*sizeof(TCHAR));
			iAddr+=14;
			memcpy(&(pWriteData1->WriteValue), m_pSharedMemory+iAddr, sizeof(WORD));
			iAddr+=2;
			memcpy(&(pWriteData1->EndTickCount), m_pSharedMemory+iAddr, sizeof(DWORD));			

			if(pWriteData1->EndTickCount < 0 || pWriteData1->EndTickCount >= 10000)
				pWriteData1->EndTickCount = 1000;

			if( pWriteData1->EndTickCount != 0)
				pWriteData1->EndTickCount += GetTickCount();			

//			WriteLocalLog(_T("Write Timer Signal[%d],Addr[%s],Val[%d],Time[%d]"),iSignal,pWriteData1->WriteAddress,pWriteData1->WriteValue,pWriteData1->EndTickCount);

			WORD ReadData = 0;
			
			ZeroMemory(NULLCHECK,sizeof(TCHAR)*7);
			memcpy(NULLCHECK,pWriteData1->WriteAddress,PLC_READ_ADDRESS_LENGTH*sizeof(TCHAR));
			if( (NULLCHECK[0]|NULLCHECK[1]|NULLCHECK[2]|NULLCHECK[3]|NULLCHECK[4]|NULLCHECK[5]|NULLCHECK[6])==0) 
			{
				WriteLocalLog(FALSE, _T("Write Timer Signal[%d],Addr[%s],Val[%d],Time[%d] : Check Addr Err"),iSignal,pWriteData1->WriteAddress,pWriteData1->WriteValue,pWriteData1->EndTickCount);
				if (pWriteData1)
				{
					delete pWriteData1;
					pWriteData1 = NULL;
				}
				return;
			}

			//µ¿±âÈ­ÇÏÁö ¾ÊÀ¸¸é ÇÁ·Î±×·¥ ¿À·ù ¹ß»ý
			m_PLCSection.Lock();
			//°°Àº ÁÖ¼ÒÀÇ µ¥ÀÌÅ͸¦ Àоî¿Â´Ù.
			long lRet =	m_MXComponent.ReadDeviceBlock2(pWriteData1->WriteAddress, 1,
											(short*)&(ReadData));

			//ÀÐÀº µ¥ÀÌÅÍ¿Í ¾µ µ¥ÀÌÅÍ °£ or ¿¬»ê
			ReadData |= pWriteData1->WriteValue;
			//1 WORD¸¦ ¾´´Ù.
			//MX Component ÇÔ¼ö »ç¿ë
			lRet =	m_MXComponent.WriteDeviceBlock2(pWriteData1->WriteAddress, 1,
											(short*)&(ReadData));
			m_PLCSection.Unlock();

			if (lRet == 0x00)	//success
			{
				//OutputDebugString(_T("successWritePLCData1!\n"));
				if( pWriteData1->EndTickCount != 0)
					m_ListWriteData.push_back(pWriteData1);
				else
				{
					if (pWriteData1)
					{
						delete pWriteData1;
						pWriteData1 = NULL;
					}
				}

		//		WriteLocalLog(_T("Write Timer Signal[%d],Addr[%s],Val[%d],Time[%d] : Write Success"),iSignal,pWriteData1->WriteAddress,pWriteData1->WriteValue,pWriteData1->EndTickCount);
			}
			else	//¿¬°áÀÌ ²÷¾îÁ³À»¶§ º¸¾ÈÄÚµå ÇÊ¿ä
			{
				//OutputDebugString(_T("FailWritePLCData1!\n"));
				WriteLocalLog(FALSE, _T("Write Timer Signal[%d],Addr[%s],Val[%d],Time[%d] : Write Fail"),iSignal,pWriteData1->WriteAddress,pWriteData1->WriteValue,pWriteData1->EndTickCount);
				if (pWriteData1)
				{
					delete pWriteData1;
					pWriteData1 = NULL;
				}
				//ReConnectionPLC();
			}
		}
	}
}

void CPLCConnectorView::WritePLCData(void)
{
	int			iSignal,iAddr;

	TCHAR NULLCHECK[PLC_READ_ADDRESS_LENGTH];

	for(iSignal=0;iSignal<PLC_WRITEWORD_LONGDATA_COUNT;iSignal++)
	{
		iAddr = PLC_WRITELONG_SIGNAL+iSignal*PLC_LONGDATA_MAXSIZE;
		if (CheckRequestToWritePLC(iAddr))
		{
			memset(m_AddressToWriteLongData,0x00,PLC_READ_ADDRESS_LENGTH*sizeof(TCHAR));
			iAddr+=1;
			memcpy(m_AddressToWriteLongData, m_pSharedMemory+iAddr, (PLC_READ_ADDRESS_LENGTH-1)*sizeof(TCHAR));
			iAddr+=14;
			memcpy(&(m_SizeOfWriteLongData), m_pSharedMemory+iAddr, sizeof(UINT));			

			// WriteLocalLog(FALSE, _T("Write Long Data Signal[%d],Addr[%s],Size[%d]"),iSignal,m_AddressToWriteLongData,m_SizeOfWriteLongData);

			if(m_SizeOfWriteLongData <= 0 || m_SizeOfWriteLongData > PLC_LONGDATA_MAXSIZE)
			{
				WriteLocalLog(FALSE, _T("Write Long Data Signal[%d],Addr[%s],Size[%d] : Check Size Err"),iSignal,m_AddressToWriteLongData,m_SizeOfWriteLongData);
				return;
			}

			ZeroMemory(NULLCHECK,sizeof(TCHAR)*7);
			memcpy(NULLCHECK,m_AddressToWriteLongData,PLC_READ_ADDRESS_LENGTH*sizeof(TCHAR));
			if( (NULLCHECK[0]|NULLCHECK[1]|NULLCHECK[2]|NULLCHECK[3]|NULLCHECK[4]|NULLCHECK[5]|NULLCHECK[6])==0) 
			{
				WriteLocalLog(FALSE, _T("Write Long Data Signal[%d],Addr[%s],Size[%d] : Check Addr Err"),iSignal,m_AddressToWriteLongData,m_SizeOfWriteLongData);
				return;
			}

			//µ¿±âÈ­ÇÏÁö ¾ÊÀ¸¸é ÇÁ·Î±×·¥ ¿À·ù ¹ß»ý
			m_PLCSection.Lock();
			iAddr+=4;
			long lRet =	m_MXComponent.WriteDeviceBlock2(m_AddressToWriteLongData, m_SizeOfWriteLongData,
				(short*)(m_pSharedMemory+iAddr));

			m_PLCSection.Unlock();
			if (lRet == 0x00)	//success
			{
				// WriteLocalLog(FALSE, _T("Write Long Data Signal[%d],Addr[%s],Size[%d] : Write Success"),iSignal,m_AddressToWriteLongData,m_SizeOfWriteLongData);
			}
			else	//¿¬°áÀÌ ²÷¾îÁ³À»¶§ º¸¾ÈÄÚµå ÇÊ¿ä
			{
				WriteLocalLog(FALSE, _T("Write Long Data Signal[%d],Addr[%s],Size[%d] : Write Fail"),iSignal,m_AddressToWriteLongData,m_SizeOfWriteLongData);
				//ReConnectionPLC();
			}
		}
	}
}

void CPLCConnectorView::ResetPLCData(void)
{
	DWORD CurrentTime = GetTickCount();
	WORD  ResetData = 0;
	WORD ReadData = 0;
	WORD WriteData = 0;
	TCHAR NULLCHECK[PLC_READ_ADDRESS_LENGTH] = {0};
	for (m_itorList = m_ListWriteData.begin();m_itorList != m_ListWriteData.end(); m_itorList++)
	{
		//¸®¼Â ½Ã°£ÀÌ Áö³µ´ÂÁö üũ
		if ((*m_itorList)->EndTickCount < CurrentTime)
		{
			//½Ã°£ÀÌ Áö³ª Áö¿ö¾ßÇÒ µ¥ÀÌÅÍ
			ResetData = (*m_itorList)->WriteValue;

			//PLC¿¡ ¾²¿©Á® ÀÖ´Â °ªÀ» Àоî¿Â´Ù.
			ReadData = 0;

			ZeroMemory(NULLCHECK,sizeof(TCHAR)*7);
			memcpy(NULLCHECK,(*m_itorList)->WriteAddress,PLC_READ_ADDRESS_LENGTH*sizeof(TCHAR));
			if( (NULLCHECK[0]|NULLCHECK[1]|NULLCHECK[2]|NULLCHECK[3]|NULLCHECK[4]|NULLCHECK[5]|NULLCHECK[6])==0) return;

			m_PLCSection.Lock();
			long lRet =	m_MXComponent.ReadDeviceBlock2((*m_itorList)->WriteAddress, 1,
										(short*)&(ReadData));

			ResetData = ~ResetData;
			//Àоî¿Â µ¥ÀÌÅÍ¿Í Áö¿ï µ¥ÀÌÅ͸¦ XOR¿¬»êÀ» ÇÑ´Ù.
			ReadData &= ResetData;

			//°°Àº ÁÖ¼Ò°ª¿¡¼­ ¾ÆÁ÷ ³²¾ÆÀÖ¾î¾ß ÇÏ´Â °ªÀ» ±¸ÇÑ´Ù.
			WriteData = GetWriteData((*m_itorList)->WriteAddress);

			//³²¾ÆÀÖ¾î¾ß ÇÒ °ª | (PLC¿¡¼­ Àоî¿Â°ª ^ ¸®¼ÂÇÒ °ª)
			WriteData = WriteData | ReadData;
		
			 lRet =
				m_MXComponent.WriteDeviceBlock2((*m_itorList)->WriteAddress, 1,	(short*)&(WriteData));

			m_PLCSection.Unlock();
			if (lRet == 0x00)	//success
			{
				//OutputDebugString(_T("successResetWritePLCData1!\n"));
				if ((*m_itorList))
				{
					delete (*m_itorList);
					(*m_itorList) = NULL;
				}
				
				m_ListWriteData.erase(m_itorList);
				return;
			}
			else	//¿¬°áÀÌ ²÷¾îÁ³À»¶§ º¸¾ÈÄÚµå ÇÊ¿ä
			{
				//OutputDebugString(_T("FailResetWritePLCData1!\n"));
				WriteLocalLog(FALSE, _T("Write Timer Addr[%s],Val[%d],Time[%d] : Reset Fail"),(*m_itorList)->WriteAddress,(*m_itorList)->WriteValue,(*m_itorList)->EndTickCount);
				ClosePLCConnection();
				OpenPLCConnection();
			}
		}
	}
}

UINT CPLCConnectorView::ReadPLCWorkerThread(LPVOID pParam)
{
	CPLCConnectorView* pView = (CPLCConnectorView*)pParam;
	while (true)
	{
		pView->ReadPLC();

		pView->ReadLongData(0);

		pView->ReadLongData(1);

		pView->ReadLongData(2);

		Sleep(5);
		if (m_bThreadEnd) break;
	}
	return 0;
}

void CPLCConnectorView::ReadLongData(int nID)
{
	long lRet;
	CString	MsgStr;
	TCHAR NULLCHECK[PLC_READ_ADDRESS_LENGTH] = {0};

	if (CheckRequestToReadLongData(nID))
	{	
		int			nAddrLength,nAddrAddress,nAddrValue;
		switch(nID)
		{
		case 0:
			nAddrLength = PLC_READ_LONGDATA_LENGTH_1;
			nAddrAddress = PLC_READ_LONGDATA_ADDRESS_1;
			nAddrValue = PLC_READ_LONGDATA_VALUE_1;
			break;
		case 1:
			nAddrLength = PLC_READ_LONGDATA_LENGTH_2;
			nAddrAddress = PLC_READ_LONGDATA_ADDRESS_2;
			nAddrValue = PLC_READ_LONGDATA_VALUE_2;
			break;
		case 2:
			nAddrLength = PLC_READ_LONGDATA_LENGTH_3;
			nAddrAddress = PLC_READ_LONGDATA_ADDRESS_3;
			nAddrValue = PLC_READ_LONGDATA_VALUE_3;
			break;
		default:
			return;
		}

		memcpy(&m_SizeOfLongData ,m_pSharedMemory+nAddrLength,2);
		memcpy(m_AddressToReadLongData ,m_pSharedMemory+nAddrAddress,sizeof(TCHAR)*PLC_READ_ADDRESS_LENGTH);

		WriteLocalLog(FALSE, _T("Read Long Data Start : Addr[%s] Size[%d]"),m_AddressToReadLongData,m_SizeOfLongData);

		ZeroMemory(m_pSharedMemory+nAddrValue,sizeof(BYTE)*PLC_LONGDATA_MAXSIZE);

		//OutputDebugString(_T("StartReadLongData!\n"));
		if (m_AddressToReadLongData == _T("")){
			// Not Enter DeviceName Error

			WriteLocalLog(FALSE, _T("Not Enter DeviceName Error."));			

			PostMessage(UM_EXITPROGRAM);
			return;
		}

		memcpy(NULLCHECK,m_AddressToReadLongData,PLC_READ_ADDRESS_LENGTH*sizeof(TCHAR));
		if( (NULLCHECK[0]|NULLCHECK[1]|NULLCHECK[2]|NULLCHECK[3]|NULLCHECK[4]|NULLCHECK[5]|NULLCHECK[6])==0) return;

		//PLC¿¡¼­ Àоî¿Ã µ¥ÀÌÅÍ´Â 512 word¸¦ ³ÑÀ» ¼ö ¾ø´Ù.
		if(	m_SizeOfLongData > PLC_LONGDATA_MAXSIZE) m_SizeOfLongData = PLC_LONGDATA_MAXSIZE;

		m_PLCSection.Lock();
		lRet = m_MXComponent.ReadDeviceBlock2(m_AddressToReadLongData,m_SizeOfLongData,(short*)(m_pSharedMemory+nAddrValue));
		m_PLCSection.Unlock();

		if (lRet == 0x00)	//success			
		{
			WriteLocalLog(FALSE, _T("Read Long Data Success : Addr[%s] Size[%d]"),m_AddressToReadLongData,m_SizeOfLongData);

			if(nID == 0)
				RestString((char*)(m_pSharedMemory+nAddrValue),m_SizeOfLongData);
			PostMessage(UM_PRINTPLCDATA,0xffff,nID);

			switch(nID)
			{
			case 0:
				m_ReadEvent_1.SetEvent();
				break;
			case 1:
				m_ReadEvent_2.SetEvent();
				break;
			case 2:
				m_ReadEvent_3.SetEvent();
				break;
			default:
				return;
			}			
		}
		else
		{//¿¬°áÀÌ ²÷¾îÁ³À»¶§ º¸¾ÈÄÚµå ÇÊ¿ä
			//OutputDebugString(_T("ReadLongDataSuccess!\n"));
			WriteLocalLog(FALSE, _T("ReadLongDataFail"));
			//ReConnectionPLC();
		}
	}
}

bool CPLCConnectorView::CheckRequestToReadLongData(int nID)
{
	if(m_pSharedMemory != NULL)
	{
		switch(nID)
		{
		case 0:
			if (m_pSharedMemory[PLC_READ_LONGDATA_SIGNAL_1])
			{
				m_pSharedMemory[PLC_READ_LONGDATA_SIGNAL_1] = 0;
				return true;
			}
			break;
		case 1:
			if (m_pSharedMemory[PLC_READ_LONGDATA_SIGNAL_2])
			{
				m_pSharedMemory[PLC_READ_LONGDATA_SIGNAL_2] = 0;
				return true;
			}
			break;
		case 2:
			if (m_pSharedMemory[PLC_READ_LONGDATA_SIGNAL_3])
			{
				m_pSharedMemory[PLC_READ_LONGDATA_SIGNAL_3] = 0;
				return true;
			}
			break;
		}		
	}
	
	return false;
}

void CPLCConnectorView::ReadPLC(void)
{
	m_ReadCount++;
	if(m_bUseReadSignal[0])
		ReadPLCSignal0();
	if(m_bUseReadSignal[1])
		ReadPLCSignal1();
	if(m_bUseReadSignal[2])
		ReadPLCSignal2();
	if(m_bUseReadSignal[3])
		ReadPLCSignal3();
	if(m_bUseReadSignal[4])
		ReadPLCSignal4();
}

void CPLCConnectorView::ReadPLCSignal0(void)
{	
	long lRet;
	CString	MsgStr;

	if (m_AddressToReadSignal0 == _T("")){
		// Not Enter DeviceName Error
		WriteLocalLog(FALSE, _T("Not Enter DeviceName Error."));	

		PostMessage(UM_EXITPROGRAM);
		return;
	}
	TCHAR NULLCHECK[PLC_READ_ADDRESS_LENGTH] = {0};
	memcpy(NULLCHECK,m_AddressToReadSignal0,PLC_READ_ADDRESS_LENGTH*sizeof(TCHAR));
	if( (NULLCHECK[0]|NULLCHECK[1]|NULLCHECK[2]|NULLCHECK[3]|NULLCHECK[4]|NULLCHECK[5]|NULLCHECK[6])==0) return;

	//DWORD dwTick = GetTickCount();
	//ÀÐ°í ¾²±â µ¿±âÈ­ ÇÊ¿ä
	m_PLCSection.Lock();
	//DWORD »çÀÌÁî ¸¸Å­ Àоî¿Â´Ù.
	lRet = m_MXComponent.ReadDeviceBlock2(m_AddressToReadSignal0,1,(short*)&m_lReadPLCWORD0);
	m_PLCSection.Unlock();
	//if(m_ReadCount%Print_Delay == 0)
	//	WriteLocalLog(TRUE, "ReadPLCSignal0 Time [%d]", GetTickCount()-dwTick);
	
	if (lRet == 0x00)	//success
	{
		memcpy(m_pSharedMemory+PLC_READ_SIGNAL0, &m_lReadPLCWORD0, 2);

		if(m_ReadCount%Print_Delay == 0)
			PostMessage(UM_PRINTPLCDATA,m_lReadPLCWORD0,0);
	}
	else	//¿¬°áÀÌ ²÷¾îÁ³À»¶§ º¸¾ÈÄÚµå ÇÊ¿ä
	{
		WriteLocalLog(FALSE, _T("Readsignal0 ½ÇÆÐ"));
	//	ReConnectionPLC();
	}
}


void CPLCConnectorView::ReConnectionPLC(void)
{
	m_PLCSection.Lock();
	Sleep(1000);
		ClosePLCConnection();
		Sleep(1000);
		OpenPLCConnection();
	m_PLCSection.Unlock();
}


void CPLCConnectorView::ReadPLCSignal1(void)
{
	long lRet;
	CString	MsgStr;

	if (m_AddressToReadSignal1 == _T("")){
		// Not Enter DeviceName Error
		WriteLocalLog(FALSE, _T("Not Enter DeviceName Error."));	

		PostMessage(UM_EXITPROGRAM);
		return;
	}
	TCHAR NULLCHECK[PLC_READ_ADDRESS_LENGTH] = {0};
	memcpy(NULLCHECK,m_AddressToReadSignal1,PLC_READ_ADDRESS_LENGTH*sizeof(TCHAR));
	if( (NULLCHECK[0]|NULLCHECK[1]|NULLCHECK[2]|NULLCHECK[3]|NULLCHECK[4]|NULLCHECK[5]|NULLCHECK[6])==0) return;

	//DWORD dwTick = GetTickCount();
	//ÀÐ°í ¾²±â µ¿±âÈ­ ÇÊ¿ä
	m_PLCSection.Lock();
	//DWORD »çÀÌÁî ¸¸Å­ Àоî¿Â´Ù.
	lRet = m_MXComponent.ReadDeviceBlock2(m_AddressToReadSignal1,1,(short*)&m_lReadPLCWORD1);
	m_PLCSection.Unlock();
	//if(m_ReadCount%Print_Delay == (Print_Delay/5))
	//	WriteLocalLog(TRUE, "ReadPLCSignal1 Time [%d]", GetTickCount()-dwTick);		
	
	BOOL bLotStart, bLotEnd;	//¶ù¿£µå¶û ¶ù½ºÅ¸Æ® ±î¸Ô³ª ¾È±î¸Ô³ª È®ÀÎ
	if (lRet == 0x00)	//success
	{
		(m_lReadPLCWORD1 & 0x01)?bLotStart=TRUE:bLotStart=FALSE;
		(m_lReadPLCWORD1 & 0x02)?bLotEnd=TRUE:bLotEnd=FALSE;

		if(bLotStart)
			WriteLocalLog(FALSE, _T("Receive Lot Start!"));
		if(bLotEnd)
			WriteLocalLog(FALSE, _T("Receive Lot End!"));

		memcpy(m_pSharedMemory+PLC_READ_SIGNAL1, &m_lReadPLCWORD1, 2);

		if(m_ReadCount%Print_Delay == (Print_Delay/5))
			PostMessage(UM_PRINTPLCDATA,m_lReadPLCWORD1,1);
	}
	else	//¿¬°áÀÌ ²÷¾îÁ³À»¶§ º¸¾ÈÄÚµå ÇÊ¿ä
	{
		WriteLocalLog(FALSE, _T("Readsignal1 ½ÇÆÐ"));
		//ReConnectionPLC();
	}
}

void CPLCConnectorView::ReadPLCSignal2(void)
{
	long lRet;
	CString	MsgStr;

	if (m_AddressToReadSignal2 == _T("")){
		// Not Enter DeviceName Error
		WriteLocalLog(FALSE, _T("Not Enter DeviceName Error."));	

		PostMessage(UM_EXITPROGRAM);
		return;
	}

	TCHAR NULLCHECK[PLC_READ_ADDRESS_LENGTH] = {0};
	memcpy(NULLCHECK,m_AddressToReadSignal2,PLC_READ_ADDRESS_LENGTH*sizeof(TCHAR));
	if( (NULLCHECK[0]|NULLCHECK[1]|NULLCHECK[2]|NULLCHECK[3]|NULLCHECK[4]|NULLCHECK[5]|NULLCHECK[6])==0) return;

	//DWORD dwTick = GetTickCount();
	//ÀÐ°í ¾²±â µ¿±âÈ­ ÇÊ¿ä
	m_PLCSection.Lock();
	//DWORD »çÀÌÁî ¸¸Å­ Àоî¿Â´Ù.
	lRet = m_MXComponent.ReadDeviceBlock2(m_AddressToReadSignal2,1,(short*)&m_lReadPLCWORD2);
	m_PLCSection.Unlock();
	//if(m_ReadCount%Print_Delay == (Print_Delay/5)*2)
	//	WriteLocalLog(TRUE, "ReadPLCSignal2 Time [%d]", GetTickCount()-dwTick);
	
	if (lRet == 0x00)	//success
	{
		memcpy(m_pSharedMemory+PLC_READ_SIGNAL2, &m_lReadPLCWORD2, 2);

		if(m_ReadCount%Print_Delay == (Print_Delay/5)*2)
			PostMessage(UM_PRINTPLCDATA,m_lReadPLCWORD2,2);
	}
	else	//¿¬°áÀÌ ²÷¾îÁ³À»¶§ º¸¾ÈÄÚµå ÇÊ¿ä
	{
		WriteLocalLog(FALSE, _T("Readsignal2 ½ÇÆÐ"));
		//ReConnectionPLC();
	}
}

void CPLCConnectorView::ReadPLCSignal3(void)
{
	long lRet;
	CString	MsgStr;

	if (m_AddressToReadSignal3 == _T("")){
		// Not Enter DeviceName Error
		WriteLocalLog(FALSE, _T("Not Enter DeviceName Error."));	

		PostMessage(UM_EXITPROGRAM);
		return;
	}
	TCHAR NULLCHECK[PLC_READ_ADDRESS_LENGTH] = {0};
	memcpy(NULLCHECK,m_AddressToReadSignal3,PLC_READ_ADDRESS_LENGTH*sizeof(TCHAR));
	if( (NULLCHECK[0]|NULLCHECK[1]|NULLCHECK[2]|NULLCHECK[3]|NULLCHECK[4]|NULLCHECK[5]|NULLCHECK[6])==0) return;
	
	//DWORD dwTick = GetTickCount();
	//ÀÐ°í ¾²±â µ¿±âÈ­ ÇÊ¿ä
	m_PLCSection.Lock();
	//DWORD »çÀÌÁî ¸¸Å­ Àоî¿Â´Ù.
	lRet = m_MXComponent.ReadDeviceBlock2(m_AddressToReadSignal3,1,(short*)&m_lReadPLCWORD3);
	m_PLCSection.Unlock();
	//if(m_ReadCount%Print_Delay == (Print_Delay/5)*3)
	//	WriteLocalLog(TRUE, "ReadPLCSignal3 Time [%d]", GetTickCount()-dwTick);
	
	if (lRet == 0x00)	//success
	{
		memcpy(m_pSharedMemory+PLC_READ_SIGNAL3, &m_lReadPLCWORD3, 2);

		if(m_ReadCount%Print_Delay == (Print_Delay/5)*3)
			PostMessage(UM_PRINTPLCDATA,m_lReadPLCWORD3,3);
	}
	else	//¿¬°áÀÌ ²÷¾îÁ³À»¶§ º¸¾ÈÄÚµå ÇÊ¿ä
	{
		WriteLocalLog(FALSE, _T("Readsignal3 ½ÇÆÐ"));
		//ReConnectionPLC();
	}
}

void CPLCConnectorView::ReadPLCSignal4(void)
{
	long lRet;
	CString	MsgStr;

	if (m_AddressToReadSignal4 == _T("")){
		// Not Enter DeviceName Error
		WriteLocalLog(FALSE, _T("Not Enter DeviceName Error."));	

		PostMessage(UM_EXITPROGRAM);
		return;
	}
	TCHAR NULLCHECK[PLC_READ_ADDRESS_LENGTH] = {0};
	memcpy(NULLCHECK,m_AddressToReadSignal4,PLC_READ_ADDRESS_LENGTH*sizeof(TCHAR));
	if( (NULLCHECK[0]|NULLCHECK[1]|NULLCHECK[2]|NULLCHECK[3]|NULLCHECK[4]|NULLCHECK[5]|NULLCHECK[6])==0) return;
	
	//DWORD dwTick = GetTickCount();
	//ÀÐ°í ¾²±â µ¿±âÈ­ ÇÊ¿ä
	m_PLCSection.Lock();
	//DWORD »çÀÌÁî ¸¸Å­ Àоî¿Â´Ù.
	lRet = m_MXComponent.ReadDeviceBlock2(m_AddressToReadSignal4,1,(short*)&m_lReadPLCWORD4);
	m_PLCSection.Unlock();
	//if(m_ReadCount%Print_Delay == (Print_Delay/5)*4)
	//	WriteLocalLog(TRUE, "ReadPLCSignal4 Time [%d]", GetTickCount()-dwTick);
	
	if (lRet == 0x00)	//success
	{
		memcpy(m_pSharedMemory+PLC_READ_SIGNAL4, &m_lReadPLCWORD4, 2);

		if(m_ReadCount%Print_Delay == (Print_Delay/5)*4)
			PostMessage(UM_PRINTPLCDATA,m_lReadPLCWORD4,4);
	}
	else	//¿¬°áÀÌ ²÷¾îÁ³À»¶§ º¸¾ÈÄÚµå ÇÊ¿ä
	{
		WriteLocalLog(FALSE, _T("Readsignal4 ½ÇÆÐ"));
		//ReConnectionPLC();
	}
}

#define MAX_STRING_SIZE 256
void CPLCConnectorView::WriteLocalLog(TCHAR* str,...)
{
	//»ç¿ë ¾îÇø®ÄÉÀ̼ǿ¡¼­ ·ÎÄ÷Π¹Ù·Î ·Î±× ÆÄÀÏÀ» ÀÛ¼ºÇÕ´Ï´Ù.
	va_list list;
	TCHAR szText[MAX_STRING_SIZE] = {0, };

	va_start(list, str);
	_vstprintf_s(szText, str, list);
	va_end(list);

	CString strPath;
	GetModulePath(strPath);

	// ÆÄÀÏ¿¡ ¾²±â
	SYSTEMTIME st;
	GetLocalTime(&st);

	static TCHAR strMessage[MAX_STRING_SIZE];
	memset(strMessage, 0x00, MAX_STRING_SIZE*sizeof(TCHAR));
	_stprintf_s(strMessage, _T("[%02d:%02d:%02d] %s\r\n"), st.wHour, st.wMinute, st.wSecond, szText);

	//·Î±× ÆÄÀϸí°ú À§Ä¡ »ý¼º
	static TCHAR strFileName[MAX_PATH];
	memset(strFileName, 0x00, MAX_PATH*sizeof(TCHAR));
	_stprintf_s(strFileName, _T("%s%d%02d%02d.log"), strPath, st.wYear, st.wMonth, st.wDay);

	DWORD dwWritten;
	HANDLE hFile;

	//°æÀï»óÅ ¹æÁö¸¦ À§ÇÑ Å©¸®Æ¼Äà °´Ã¼ »ç¿ë
	m_LogSection.Lock();
	hFile = CreateFile(strFileName, GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
	int nFilePointer = SetFilePointer(hFile, 0, NULL, FILE_END);

#ifdef UNICODE
	if(!nFilePointer)
	{
		// À¯´ÏÄÚµå ÆÄÀÏÀÇ ½ÃÀÛÀº BOM(0xFEFF) À̾î¾ß ÇÑ´Ù.
		TCHAR strCommand = 0xFEFF;
		WriteFile(hFile, &strCommand, sizeof(TCHAR), &dwWritten, NULL);
	}
#endif

	//·ÎÄà ·Î±×ÆÄÀÏ ÀÛ¼º
	WriteFile(hFile, strMessage, _tcslen(strMessage)*sizeof(TCHAR), &dwWritten, NULL);
	CloseHandle(hFile);
	m_LogSection.Unlock();

	CString		strLog;
	strLog.Format(_T("%s"),strMessage);
	AddLogList(strLog);	
}

void CPLCConnectorView::WriteLocalLog(BOOL bFile, TCHAR* str,...)
{
	//»ç¿ë ¾îÇø®ÄÉÀ̼ǿ¡¼­ ·ÎÄ÷Π¹Ù·Î ·Î±× ÆÄÀÏÀ» ÀÛ¼ºÇÕ´Ï´Ù.
	va_list list;
	TCHAR szText[MAX_STRING_SIZE] = {0, };

	va_start(list, str);
	_vstprintf_s(szText, str, list);
	va_end(list);

	CString strPath;
	GetModulePath(strPath);

	// ÆÄÀÏ¿¡ ¾²±â
	SYSTEMTIME st;
	GetLocalTime(&st);

	static TCHAR strMessage[MAX_STRING_SIZE];
	memset(strMessage, 0x00, MAX_STRING_SIZE*sizeof(TCHAR));
	_stprintf_s(strMessage, _T("[%02d:%02d:%02d] %s\r\n"), st.wHour, st.wMinute, st.wSecond, szText);

	//·Î±× ÆÄÀϸí°ú À§Ä¡ »ý¼º
	static TCHAR strFileName[MAX_PATH];
	memset(strFileName, 0x00, MAX_PATH*sizeof(TCHAR));
	_stprintf_s(strFileName, _T("%s%d%02d%02d.log"), strPath, st.wYear, st.wMonth, st.wDay);

	DWORD dwWritten;
	HANDLE hFile;

	//°æÀï»óÅ ¹æÁö¸¦ À§ÇÑ Å©¸®Æ¼Äà °´Ã¼ »ç¿ë
	if(bFile)
	{
		m_LogSection.Lock();
		hFile = CreateFile(strFileName, GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
		int nFilePointer = SetFilePointer(hFile, 0, NULL, FILE_END);

#ifdef UNICODE
		if(!nFilePointer)
		{
			// À¯´ÏÄÚµå ÆÄÀÏÀÇ ½ÃÀÛÀº BOM(0xFEFF) À̾î¾ß ÇÑ´Ù.
			TCHAR strCommand = 0xFEFF;
			WriteFile(hFile, &strCommand, sizeof(TCHAR), &dwWritten, NULL);
		}
#endif

		//·ÎÄà ·Î±×ÆÄÀÏ ÀÛ¼º
		WriteFile(hFile, strMessage, _tcslen(strMessage)*sizeof(TCHAR), &dwWritten, NULL);
		CloseHandle(hFile);
		m_LogSection.Unlock();		
	}	

	CString		strLog;
	strLog.Format(_T("%s"),strMessage);
	AddLogList(strLog);	
}

bool CPLCConnectorView::OpenPLCConnection(void)
{
	long lRet = INT_MAX;
	CString	MsgStr;
	// Clear ReturnValue Display
	m_RetVal= _T("");
	m_RetVal2 = _T("");
	m_RetVal3 = _T("");

	try{
		// ActEasyIF Control
		// If you don't use default values, please set their properties before OPEN method call.
		// ---> Example: Change the Logical station number to "1" from default value.
		m_PLCSection.Lock();
		//MX Component OpenÀ» À§Çؼ­´Â Logical Station °ªÀ» ÀÔ·ÂÇØ¾ß ÇÑ´Ù.
		//MX Component ¼³Ä¡½Ã ¼ÂÆÃÇÏ´Â °ªÀ¸·Î °Ë»ç±â ¼­¹ö´Â 11ÀÌ ÀûÇÕÇÔ
		m_MXComponent.put_ActLogicalStationNumber(m_StationNumber);	// Exec set-property method 

		//Logical Station °ª ¼³Á¤ÈÄ PLC¿Í Åë½Å ¿¬°á Open
		
		lRet = m_MXComponent.Open();	// Open method exec

		m_PLCSection.Unlock();
		// Renew ReturnValue 
		m_RetVal.Format(_T("0x%08x"),lRet);

		if (lRet != 0x00)
		{
			//¿¡·¯ ¹ß»ý
			MsgStr.Format(_T("¿¬°á½ÇÆÐ!\n Station No üũ :%d"), m_StationNumber);
			WriteLocalLog(FALSE, (TCHAR*)(LPCTSTR)MsgStr);			
			//ÇÁ·Î±×·¥ Á¾·á ¸Þ½ÃÁö Àü´Þ
			PostMessage(UM_EXITPROGRAM);
			return false;
		}
	}
	catch(COleDispatchException *Exception){
		// OLE IDispatch Interface Error
		MsgStr.LoadString(IDS_STRING103);
	//	AfxMessageBox(MsgStr, MB_ICONINFORMATION);
		//MX Component¿À·ù ÄÚµå ·Î±× ÀÛ¼º ÈÄ ÇÁ·Î±×·¥ Á¾·á
		WriteLocalLog(FALSE, (TCHAR*)(LPCTSTR)MsgStr);
		Exception->Delete();
		//ÇÁ·Î±×·¥ Á¾·á ¸Þ½ÃÁö Àü´Þ
		PostMessage(UM_EXITPROGRAM);

		return false;
	}	
	return true;
}

void CPLCConnectorView::ClosePLCConnection(void)
{
	long lRet;
	CString	MsgStr;

	// Clear ReturnValue Display
	m_RetVal= "";
	m_RetVal2 = "";
	m_RetVal3 = "";

	try{
		// ActEasyIF Control
		m_PLCSection.Lock();
		
		lRet = m_MXComponent.Close();	// Exec Close Method
		m_PLCSection.Unlock();
		// Renew ReturnValue 
		m_RetVal.Format(_T("0x%08x"),lRet);
	}
	catch(COleDispatchException *Exception){
		// OLE IDispatch Interface Error
		MsgStr.LoadString(IDS_STRING104);
		//AfxMessageBox(MsgStr, MB_ICONINFORMATION);
		WriteLocalLog(FALSE, (TCHAR*)(LPCTSTR)MsgStr);
		Exception->Delete();
	}
}

//Á¤»ó OpenÈÄ PLC CPU TypeÀ» ¾Ë¾Æ¿À´Â Å×½ºÆ® ÄÚµå
void CPLCConnectorView::GetPLCCPUType(void)
{
	long	lRet;
	long	lCpuCode	= 0;
	BSTR	szCpuName	= NULL;
	CString	MsgStr;

	// Clear ReturnValue Display
	CString m_RetVal= _T("");
	CString m_RetVal2 = _T("");
	CString m_RetVal3 = _T("");

	try{
		// ActEasyIF Control
		m_PLCSection.Lock();
		lRet = m_MXComponent.GetCpuType(&szCpuName,&lCpuCode);// Exec GetCpuType Method
		m_PLCSection.Unlock();

		if(lRet == 0x00){	// Success 
			m_RetVal2.Format(_T("0x%x(%d)"),lCpuCode,lCpuCode);	// Cpu Code
			m_RetVal3 = szCpuName;							// Cpu Name
		}
		// Renew ReturnValue 
		m_RetVal.Format(_T("0x%08x"),lRet);

	}
	catch(COleDispatchException *Exception){
		// OLE IDispatch Interface Error
		MsgStr.LoadString(IDS_STRING105);
		WriteLocalLog(FALSE, (TCHAR*)(LPCTSTR)MsgStr);		
		Exception->Delete();

		PostMessage(UM_EXITPROGRAM);
	}

	MsgStr.Format(_T("%s ¿¬°á ¼º°ø"),m_RetVal3);
	m_ConnectorState.AddString(MsgStr);
	WriteLocalLog(FALSE, (TCHAR*)(LPCTSTR)MsgStr);
	//AfxMessageBox(MsgStr);
	// If the Method has Output value of BSTR type, you have to free the allocated BSTR area.
	::SysFreeString(szCpuName);
}

LRESULT CPLCConnectorView::OnPrintListPLCData(WPARAM wParam, LPARAM lParam)
{
	//Á¤»ó µ¿ÀÛÇÏ´ÂÁö ·Î±×·Î Âï¾îº»´Ù.
	static unsigned int index = 0;
	index ++;
	if (index%MaxPrintCount == 0)
	{
		m_ConnectorState.ResetContent();
	}
	long ResultToRead = (long)wParam;
	long Signal = (long)lParam;
	CString Result;

	if (ResultToRead == 0xffff)
	{
		int		nAddrVal=0;
		switch(Signal)
		{
		case 0: nAddrVal = PLC_READ_LONGDATA_VALUE_1; break;
		case 1: nAddrVal = PLC_READ_LONGDATA_VALUE_2; break;
		}
		short* pData = (short*)(m_pSharedMemory+nAddrVal);
		Result.Format(_T("%x%x%x%x%x%x%x%x%x%x%x%x%x"),pData[0],pData[1],pData[2],pData[3],pData[4],pData[5],pData[6],
			pData[7],pData[8],pData[9],pData[10],pData[11],pData[12]);
	}
	else
	{
		switch(Signal)
		{
		case 0:
			Result.Format(_T("Sigal0 %s : %x"),m_AddressToReadSignal0,ResultToRead);
			break;
		case 1:
			Result.Format(_T("Sigal1 %s : %x"),m_AddressToReadSignal1,ResultToRead);
			break;
		case 2:
			Result.Format(_T("Sigal2 %s : %x"),m_AddressToReadSignal2,ResultToRead);
			break;
		case 3:
			Result.Format(_T("Sigal3 %s : %x"),m_AddressToReadSignal3,ResultToRead);
			break;
		case 4:
			Result.Format(_T("Sigal4 %s : %x"),m_AddressToReadSignal4,ResultToRead);
			break;
		}
		
	}
	m_ConnectorState.AddString(Result);

	if(m_bAutoScroll)
		m_ConnectorState.SetCurSel(m_ConnectorState.GetCount()-1);  


	return 0;
}

void CPLCConnectorView::AddLogList(CString strMsg)
{
	if(m_ConnectorState.GetCount() >= 2000)
		m_ConnectorState.ResetContent();

	m_ConnectorState.AddString(strMsg);

	if(m_bAutoScroll)
		m_ConnectorState.SetCurSel(m_ConnectorState.GetCount()-1);  
}

WORD CPLCConnectorView::GetWriteData(TCHAR* AddressToGetData)
{
	WORD RetData = 0;

	std::vector<PPLCWRITE_DATA>::iterator itorList;
	for (itorList = m_ListWriteData.begin();itorList != m_ListWriteData.end(); itorList++)
	{
		if( itorList == m_itorList ) continue;
		//¸®¼Â ½Ã°£ÀÌ Áö³µ´ÂÁö üũ
		if(0== _tcscmp((*itorList)->WriteAddress,AddressToGetData))
		{
			//OutputDebugString(_T("ResetWritePLCData1!\n"));
			RetData = RetData | (*itorList)->WriteValue;
		}
	}
	return RetData;
}



void CPLCConnectorView::OnBnClickedCheckScroll()
{
	// TODO: ¿©±â¿¡ ÄÁÆ®·Ñ ¾Ë¸² 󸮱â Äڵ带 Ãß°¡ÇÕ´Ï´Ù.
	UpdateData();
}



void CPLCConnectorView::OnTimer(UINT_PTR nIDEvent)
{
	if(m_bUseAOISignal == TRUE && nIDEvent == ID_TIMER_PLCCONNECTOR)
	{
		CString			strCaption;
		HWND hWnd = NULL;
		COPYDATASTRUCT cds;

		cds.dwData = COPYDATA_PLCCONNECTOR;
		cds.cbData = 0;
		cds.lpData = 0;

		strCaption.Format(_T("%s"),m_strAOICaption);
		hWnd = ::FindWindow(strCaption, NULL);
	//	hWnd = ::FindWindow(NULL, strCaption);

		if (hWnd) 
		{
			PDWORD_PTR nReturn = NULL;
			LRESULT Res = ::SendMessageTimeout(hWnd, WM_COPYDATA, COPYDATA_PLCCONNECTOR, (LPARAM)(LPVOID)&cds, 
				SMTO_NORMAL, 1000, nReturn);
		}
	}
	
	CFormView::OnTimer(nIDEvent);
}

void CPLCConnectorView::RestString(char* RestPoint, int DataLength)
{
	char sData = 0;
	for(int i =0; i < DataLength; i++)
	{
		sData = RestPoint[i];
		if(sData == 0x00) //Àоî¿Â ¹°·ù µ¥ÀÌÅÍ°¡ NULLÀÌ¸é °ø¹éÀ¸·Î ´ëü
			RestPoint[i] = 0x00;
			//RestPoint[i] = 0x20;
	}
}