#include "StdAfx.h"
#include "Control_Interface_New.h"
#include "Config.h"
#include "SharedMemoryDefine.h"

CControl_Interface_New::CControl_Interface_New(void)
	:m_ReadEvent(FALSE,FALSE,_T("PLCConnector_Event_1"))
{		
	m_pInterface = NULL;

	m_hMap = NULL;
	m_pSharedMemory = NULL;	

	m_bConnect = FALSE;

	m_dSendAlive_TickTime = GetTickCount();

	m_bRcvSignal = FALSE;
	m_nRcvSignal = 0;

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

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

	DisconnectToPLC();
}

BOOL CControl_Interface_New::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_New::ConnectToControl()
{
	m_bConnect = ConnectPLCConnector();

	return m_bConnect;
}

BOOL CControl_Interface_New::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_New::ControlProcess()
{
	if(IsConnect() == FALSE)
	{
		Sleep(10);
		return FALSE;
	}

	ReadSignalBit();

	ReadControl_CheckSignal();

	Sleep(10);

	SendSignalBit();

	return TRUE;
}

BOOL CControl_Interface_New::SendControlBit(emInterface_Send_Control emSendBit, int nValue)
{
	if(emSendBit >= enInterface_None)
		return FALSE;

	CSingleLock localLock(&m_csSendBit);
	localLock.Lock();

	// emSnd_Vision_Alive=0, emSnd_Loading_Ack, emSnd_Short_ScanStart_Ack,emSnd_Short_ScanEnd_Ack, emSnd_Long_ScanStart_Ack,emSnd_Short_ScanEnd_Ack

	switch(emSendBit)
	{
	case emSnd_Loading_Ack:			m_Send_Bit.bGlassLoadingAck	= (BOOL) nValue; break;
	case emSnd_Short_ScanStart_Ack: m_Send_Bit.bShortScanStartAck = (BOOL) nValue; break;
	case emSnd_Short_ScanEnd_Ack:	m_Send_Bit.bShortScanEndAck	= (BOOL) nValue; break;
	case emSnd_Long_ScanStart_Ack:	m_Send_Bit.bLongScanStartAck	= (BOOL) nValue; break;
	case emSnd_Long_ScanEnd_Ack:	m_Send_Bit.bLongScanEndAck	= (BOOL) nValue; break;
	default:
		localLock.Unlock();
		return FALSE;
	}

	localLock.Unlock();

	return TRUE;
}

BOOL CControl_Interface_New::SendControlData(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 = WritePLC_Data(1, tAddr, (short*)pBuf, nCnt);

	return bRet;
}

void CControl_Interface_New::SendSignalBit()
{
	int		nSendData = 0;

	CSingleLock localLock(&m_csSendBit);
	localLock.Lock();

	CheckAliveTime();

	m_Send_Bit.MakeSend(nSendData);

	localLock.Unlock();

	TCHAR			*tAddr;
	CString			strAddr;

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

	WritePLC_Data(0,tAddr,(short*)&nSendData,1);
}

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

	int iSignal = (nSharedMemIdx < 0) ? 0 : (PLC_WRITEWORD_LONGDATA_COUNT < nSharedMemIdx) ? PLC_WRITEWORD_LONGDATA_COUNT - 1 : nSharedMemIdx;

	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_New::ReadControl_CheckSignal()
{
	if(m_bRcvSignal == FALSE)
		return TRUE;

	if(m_pInterface == NULL)
		return TRUE;

	// emRcv_PLC_Alive=0, emRcv_Loading, emRcv_Short_Start, emRcv_Short_End, emRcv_Long_Start, emRcv_Long_End, emInterface_Rcv_None

	ST_PLC_RECIVE_BIT newSignalData(m_nRcvSignal);

	// Glass Loading 
	if (m_Rcv_Bit.bGlassLoading != newSignalData.bGlassLoading)
	{			
		m_pInterface->IControl2P_ReceiveSignalValue(emRcv_Loading, (int) newSignalData.bGlassLoading);		
	}	
	// Short Scan Start
	if (m_Rcv_Bit.bShortScanStart != newSignalData.bShortScanStart)	
	{
		m_pInterface->IControl2P_ReceiveSignalValue(emRcv_Short_Start, (int) newSignalData.bShortScanStart);		
	}
	// Short Scan End
	if (m_Rcv_Bit.bShortScanEnd != newSignalData.bShortScanEnd)	
	{
		m_pInterface->IControl2P_ReceiveSignalValue(emRcv_Short_End, (int) newSignalData.bShortScanEnd);		
	}
	// Long Scan Start
	if (m_Rcv_Bit.bLongScanStart != newSignalData.bLongScanStart)	
	{
		m_pInterface->IControl2P_ReceiveSignalValue(emRcv_Long_Start, (int) newSignalData.bLongScanStart);		
	}
	// Long Scan End
	if (m_Rcv_Bit.bLongScanEnd != newSignalData.bLongScanEnd)	
	{
		m_pInterface->IControl2P_ReceiveSignalValue(emRcv_Long_End, (int) newSignalData.bLongScanEnd);		
	}
	// EMO Grab Stop
	if (m_Rcv_Bit.bEMOGrabStop != newSignalData.bEMOGrabStop)	
	{
		m_pInterface->IControl2P_ReceiveSignalValue(emRcv_Grab_Stop_EMO, (int) newSignalData.bEMOGrabStop);		
	}

	CSingleLock localLock(&m_csRcvBit);
	localLock.Lock();

	m_Rcv_Bit = newSignalData;

	localLock.Unlock();

	return TRUE;
}

BOOL CControl_Interface_New::ReadControlBit(emInterface_Rcv_Control emRcvBit,int& nValue)
{
	if(emRcvBit >= emInterface_Rcv_None)
		return FALSE;

	CSingleLock localLock(&m_csRcvBit);
	localLock.Lock();

	// emRcv_PLC_Alive=0, emRcv_Loading, emRcv_Short_Start, emRcv_Short_End, emRcv_Long_Start, emRcv_Long_End, emInterface_Rcv_None

	switch(emRcvBit)
	{
	case emRcv_PLC_Alive:	nValue = (int) m_Rcv_Bit.bPLCHeatbit;
	case emRcv_Loading:		nValue = (int) m_Rcv_Bit.bGlassLoading;
	case emRcv_Short_Start: nValue = (int) m_Rcv_Bit.bShortScanStart;
	case emRcv_Short_End:	nValue = (int) m_Rcv_Bit.bShortScanEnd;
	case emRcv_Long_Start:	nValue = (int) m_Rcv_Bit.bLongScanStart;
	case emRcv_Long_End:	nValue = (int) m_Rcv_Bit.bEMOGrabStop;
	default:
		localLock.Unlock();
		return FALSE;
	}

	localLock.Unlock();

	return TRUE;
}

BOOL CControl_Interface_New::ReadControlData(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};

	ReadPLC_Data(1, 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_New::ReadPLC_Data(int nSharedMemIdx, 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;

	int nSignal = PLC_READ_LONGDATA_SIGNAL_1;
	int nAddress = PLC_READ_LONGDATA_ADDRESS_1;
	int nLength = PLC_READ_LONGDATA_LENGTH_1;
	int nValue = PLC_READ_LONGDATA_VALUE_1;

	switch(nSharedMemIdx)
	{
	case 1:
		nSignal = PLC_READ_LONGDATA_SIGNAL_2;
		nAddress = PLC_READ_LONGDATA_ADDRESS_2;
		nLength = PLC_READ_LONGDATA_LENGTH_2;
		nValue = PLC_READ_LONGDATA_VALUE_2;
		break;
	case 2:
		nSignal = PLC_READ_LONGDATA_SIGNAL_3;
		nAddress = PLC_READ_LONGDATA_ADDRESS_3;
		nLength = PLC_READ_LONGDATA_LENGTH_3;
		nValue = PLC_READ_LONGDATA_VALUE_3;
		break;
	}
	
	//傍蜡 皋葛府俊 拱幅单捞磐甫 佬档废 脚龋甫 焊辰促.
	ZeroMemory(m_pSharedMemory+nAddress,(nLength)-(nAddress));
	memcpy(m_pSharedMemory+nAddress, strAddress,strlength*sizeof(TCHAR));
	memcpy(m_pSharedMemory+nLength, &nWORDSize,2);
	memset(m_pSharedMemory+nSignal, 0x01, 1);

	//单捞磐甫 促 佬绊 傍蜡皋葛府 利阑 锭鳖瘤 扁促赴促.
	::WaitForSingleObject(m_ReadEvent,2000);

	//肯丰啊 登搁 秦寸 蔼阑 促矫 佬绢柯促.
	//pData = m_pSharedMemory+PLC_READ_LONGDATA_VALUE;

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

	return true;
}

BOOL CControl_Interface_New::ReadSignalBit()
{
	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 nRcvSignal = TransClass.Hex2Dec(str1);
	if (m_nRcvSignal != nRcvSignal)
	{
		m_nRcvSignal = nRcvSignal;
		m_bRcvSignal = TRUE;
	}

	return TRUE;
}

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

	double		PassTime = CurTime - m_dSendAlive_TickTime;

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

	return FALSE;
}

// 胶飘傅 -> 16柳荐
BOOL CControl_Interface_New::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_New::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;		

	ReadPLC_Data(1,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);
}