#include "stdafx.h"
#include "CHSignalControls/SignalControl.h"

CSignalControl::CSignalControl(int nIndex, DWORD dwPeriod) : m_nIndex(nIndex), m_dwPeriod(dwPeriod), CTimerThreadPools(dwPeriod)
{
	m_ControlInfo.Reset();

	m_pSC2P				= NULL;
	m_bConnected		= FALSE;

	m_nUserSignalMode	= RecvSig_ManualMode;
	m_nUserSignalData	= -1;

	m_nReceiveSignalCount		= 0;
	m_pReceiveSignalValueAddr	= NULL;
	m_pReceiveSignalValue		= NULL;
	m_pReceiveSignalValuePrev	= NULL;
	m_nSendSignalCount			= 0;
	m_pSendSignalValueAddr		= NULL;
	m_pSendSignalValue			= NULL;
	m_pSendSignalValuePrev		= NULL;


	m_pSignalThread		= NULL;

	m_pSignalThread = new CSignalThread(1);
	if (m_pSignalThread)
	{
		m_pSignalThread->SetST2P(static_cast<ISignalThread2Parent*>(this));
	}
	m_bAlive = FALSE;
}

CSignalControl::~CSignalControl(void)
{
	//AfxMessageBox(_T("CSignalControl"));

	m_ControlInfo.Reset();

	if (m_pReceiveSignalValueAddr)
	{
		delete [] m_pReceiveSignalValueAddr;
		m_pReceiveSignalValueAddr = NULL;
	}

	if (m_pReceiveSignalValue)
	{
		delete [] m_pReceiveSignalValue;
		m_pReceiveSignalValue = NULL;
	}

	if (m_pReceiveSignalValuePrev)
	{
		delete [] m_pReceiveSignalValuePrev;
		m_pReceiveSignalValuePrev = NULL;
	}

	if (m_pSendSignalValueAddr)
	{
		delete [] m_pSendSignalValueAddr;
		m_pSendSignalValueAddr = NULL;
	}

	if (m_pSendSignalValue)
	{
		delete [] m_pSendSignalValue;
		m_pSendSignalValue = NULL;
	}

	if (m_pSendSignalValuePrev)
	{
		delete [] m_pSendSignalValuePrev;
		m_pSendSignalValuePrev = NULL;
	}

	if (m_pSignalThread)
	{
		delete m_pSignalThread;
		m_pSignalThread = NULL;
	}
}

void CSignalControl::TimerThreadProcess(PVOID pParameter)
{
	if (m_pSC2P==NULL) return;

	// read transfer data
	DWORD dwBitValue = 1;
	BOOL bCurValue = FALSE;
	BOOL bPrevValue = FALSE;

	const int nBitCount = sizeof(WORD) * 8;

	// read receive signal
	for (int nIdx=0; nIdx<m_nReceiveSignalCount; nIdx++)
	{
		Read_ReceiveSignal(nIdx, m_pReceiveSignalValue[nIdx]);
	}
	// read send signal
	for (int nIdx=0; nIdx<m_nSendSignalCount; nIdx++)
	{
		Read_SendSignal(nIdx, m_pSendSignalValue[nIdx]);
	}

	// process receive signal
	bool bReceiveChanged = false;
	for (int nIdx=0; nIdx<m_nReceiveSignalCount; nIdx++)
	{
		dwBitValue = 1;

		if (m_pReceiveSignalValuePrev[nIdx] == m_pReceiveSignalValue[nIdx] ) 
			continue;

		for (int nSignalIdx=0; nSignalIdx<nBitCount; nSignalIdx++)
		{
			// compare current and prev
			bCurValue = BOOL(dwBitValue & m_pReceiveSignalValue[nIdx]);
			bPrevValue = BOOL(dwBitValue & m_pReceiveSignalValuePrev[nIdx]);

			// change check
			if (bCurValue!=bPrevValue)
			{
				m_pSC2P->ISC2P_ReceiveSignal(m_nIndex, nIdx, nSignalIdx, bCurValue);
			}			

			dwBitValue = dwBitValue << 1;
		}

		m_pReceiveSignalValuePrev[nIdx] = m_pReceiveSignalValue[nIdx];
		bReceiveChanged = true;

	}

	// process send signal
	bool bSendChanged = false;
	for (int nIdx=0; nIdx<m_nSendSignalCount; nIdx++)
	{
		if (m_pSendSignalValuePrev[nIdx] == m_pSendSignalValue[nIdx]) continue;

		m_pSendSignalValuePrev[nIdx] = m_pSendSignalValue[nIdx];
		bSendChanged = true;
	}

	if (bSendChanged || bReceiveChanged)
	{
		m_pSC2P->ISC2P_SetSignalStatus(m_pReceiveSignalValue[0], m_pSendSignalValue[0], m_bAlive);
	}

}

BOOL CSignalControl::ReadData(const CString strAddr, int BitPosition, int nSize, int& nData)
{
	return TRUE;
}

void CSignalControl::IST2P_RunThreadProcess(const CSignalData& signalData)
{
	switch(signalData.nSignalType)
	{
	case 0:

		break;

	default:
		break;
	}
}

void CSignalControl::SetUserSignalMode(int nMode)
{
	m_nUserSignalMode = nMode;
	m_nUserSignalData = -1;

	if (m_nUserSignalMode == RecvSig_AutoMode)
	{
		CSignalData data;
		m_pSignalThread->AddThreadData(data);
	}
}