// MYDLLPro.cpp : implementation file
//

#include "stdafx.h"
#include "Mydll.h"
#include "MYDLLPro.h"
#include "reg.h"
#include "math.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#ifndef  TEST_ShowMessage 
#define    ShowMessage  TRACE
#endif

#ifdef   TEST_ShowMessage 
void ShowMessage( const char* msg);
void ConVertBufToShowMessage(char * BufBeforeConVert, char * BufAfterConVert, int ConVertlong);
#define WM_MESSAGE_OUTPUT WM_USER+50
#endif
/////////////////////////////////////////////////////////////////////////////
// MYDLLPro

IMPLEMENT_DYNCREATE(MYDLLPro, CCmdTarget)

MYDLLPro::MYDLLPro()
{
	EnableAutomation();
	
	// To keep the application running as long as an OLE automation 
	//	object is active, the constructor calls AfxOleLockApp.

	m_nTimeOut =5000;
	m_nLastErrorCode = -1;
	m_hComm = INVALID_HANDLE_VALUE; 	
	
	AfxOleLockApp();
}

MYDLLPro::~MYDLLPro()
{
	// To terminate the application when all objects created with
	// 	with OLE automation, the destructor calls AfxOleUnlockApp.

	if(m_hComm != INVALID_HANDLE_VALUE)
	{
		CloseHandle(m_hComm);
		m_hComm = INVALID_HANDLE_VALUE;
	}		
	
	AfxOleUnlockApp();
}


void MYDLLPro::OnFinalRelease()
{
	// When the last reference for an automation object is released
	// OnFinalRelease is called.  The base class will automatically
	// deletes the object.  Add additional cleanup required for your
	// object before calling the base class.

	CCmdTarget::OnFinalRelease();
}


BEGIN_MESSAGE_MAP(MYDLLPro, CCmdTarget)
	//{{AFX_MSG_MAP(MYDLLPro)
		// NOTE - the ClassWizard will add and remove mapping macros here.
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

BEGIN_DISPATCH_MAP(MYDLLPro, CCmdTarget)
	//{{AFX_DISPATCH_MAP(MYDLLPro)
		// NOTE - the ClassWizard will add and remove mapping macros here.
	//}}AFX_DISPATCH_MAP
END_DISPATCH_MAP()

// Note: we add support for IID_IMYDLLPro to support typesafe binding
//  from VBA.  This IID must match the GUID that is attached to the 
//  dispinterface in the .ODL file.

// {185EE497-6AE3-4530-BC1A-8EAAADEC1F33}
static const IID IID_IMYDLLPro =
{ 0x185ee497, 0x6ae3, 0x4530, { 0xbc, 0x1a, 0x8e, 0xaa, 0xad, 0xec, 0x1f, 0x33 } };

BEGIN_INTERFACE_MAP(MYDLLPro, CCmdTarget)
	INTERFACE_PART(MYDLLPro, IID_IMYDLLPro, Dispatch)
	INTERFACE_PART(MYDLLPro, IID_ProtocolImp, ProtocolImp)
END_INTERFACE_MAP()

// {40F58121-E7AA-47CD-8F86-97D4554A769C}
IMPLEMENT_OLECREATE(MYDLLPro, "Mydll.MYDLLPro", 0x40f58121, 0xe7aa, 0x47cd, 0x8f, 0x86, 0x97, 0xd4, 0x55, 0x4a, 0x76, 0x9c)

/////////////////////////////////////////////////////////////////////////////
// MYDLLPro message handlers

STDMETHODIMP_(ULONG) MYDLLPro::XProtocolImp::AddRef(void)
{
    METHOD_PROLOGUE(MYDLLPro, ProtocolImp);
    return pThis->ExternalAddRef();
}

STDMETHODIMP_(ULONG) MYDLLPro::XProtocolImp::Release(void)
{
    METHOD_PROLOGUE(MYDLLPro, ProtocolImp);
    return pThis->ExternalRelease();
}

STDMETHODIMP MYDLLPro::XProtocolImp::QueryInterface(REFIID iid, void FAR* FAR* ppvObj)
{
    METHOD_PROLOGUE(MYDLLPro, ProtocolImp);
    return pThis->ExternalQueryInterface(&iid, ppvObj);
}

STDMETHODIMP_(BOOL) MYDLLPro::XProtocolImp::TryConnect( char * pDeviceName, int nUnitAddr, LPVOID lpDevAddr )
{
    METHOD_PROLOGUE(MYDLLPro, ProtocolImp);

	PPACKET   pPac = new PACKET;
	IdNo     *pTempIdNo = new IdNo;
	pPac->nPacketType = PT_READ;
	pPac->nRegType = 0;
	pPac->nUnitNo = nUnitAddr;
	pPac->nStartNo = 0;
	pPac->nEndNo = 0;

	pTempIdNo->wNo = pPac->nStartNo;
	pTempIdNo->wDataType = FLOAT_DATATYPE;

	pPac->varList.AddTail(pTempIdNo);
	if(ProcessPacket( pPac ))
	{
		delete   pPac;
		delete   pTempIdNo;
		return   TRUE;
	}
	else
	{
		delete   pPac;
		delete   pTempIdNo;
		return   FALSE;
	}		
}

STDMETHODIMP_(BOOL) MYDLLPro::XProtocolImp::StrToDevAddr( const  char * str,LPVOID lpDevAddr)
{
    METHOD_PROLOGUE(MYDLLPro, ProtocolImp); 
	DEVADDR * pDevAddr =(DEVADDR *) lpDevAddr;

	int len=strlen(str);	
	WORD addr=0;

//	_strupr(str);

	for(int i=0;i<len;i++) 
	{
		if( !isdigit(str[i]) )
		{
			pThis->m_nLastErrorCode = USER_ADDR_SCOPE_ERROR;
			return FALSE;
		}
	}
	addr=(WORD)atoi(str);
	if(addr<128 || addr>255)
	{
		pThis->m_nLastErrorCode = USER_ADDR_SCOPE_ERROR;
		return FALSE;
	}
	
	pDevAddr->nDevAddr = addr;

	return  TRUE;
}

STDMETHODIMP_(char *) MYDLLPro::XProtocolImp::GetLastError()
{
    METHOD_PROLOGUE(MYDLLPro, ProtocolImp);
	
	if(pThis->m_nLastErrorCode != -1)
		return Error_Message_Table[pThis->m_nLastErrorCode];
	else
		return NULL;
}

STDMETHODIMP_(BOOL) MYDLLPro::XProtocolImp::OpenComDevice( int nDeviceType, LPVOID lpInitData)
{
    METHOD_PROLOGUE(MYDLLPro, ProtocolImp); 
	
	ASSERT( nDeviceType == SERIAL_DEV_TYPE );
	
	return pThis->InitialComm( lpInitData );

/*	char szPort[8]; 
	int Flag = 1;
	ComDevice *pcc = (ComDevice *)lpInitData;   
    if(pcc->isRs232 != RS232)
	{
		pcc->isRs232 = RS485;
	    pThis->m_nCommType=RS485;/*XCL  添加*/
//	}
/*	if((pcc->baudRate<9600)||(pcc->baudRate)>57600)
	{ 	
		TRACE( "Error Config for Commounication .\n" );
		pThis->m_nLastErrorCode = COMMUNICATION_CONFIG_ERROR;
		return FALSE;
	}  
	pThis->m_nTimeOut = pcc->timeOut;
	strcpy(szPort, pcc->deviceName);
    HANDLE hComm;
	hComm = CreateFile( szPort, GENERIC_READ | GENERIC_WRITE, 0, 
		NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL , NULL );
	if ( INVALID_HANDLE_VALUE==hComm )
	{
		TRACE( "Error in open COM port.\n" );
		pThis->m_nLastErrorCode = FAILED_OPEN_COM; 
		return FALSE; 
	}
//	SetupComm( hComm, RX_QUEU, TX_QUEU );
	SetupComm( hComm, 512, 512 );
	
	DCB dcb;
	GetCommState( hComm, &dcb );
	dcb.BaudRate = (WORD)pcc->baudRate;
	dcb.ByteSize =  (BYTE)pcc->dataBits;      
	dcb.StopBits =  ONESTOPBIT;      
	dcb.Parity   =  (BYTE)pcc->parity;
	if ( !SetCommState( hComm, &dcb ) )
	{
		CloseHandle( hComm );
		TRACE( "Error in SetCommDcb.\n" );
//        pThis->m_nLastErrorCode = FAILED_INITIALIZED_COM;
		return FALSE;
	}	
    PurgeComm( hComm, PURGE_TXABORT | PURGE_RXABORT |
		PURGE_TXCLEAR | PURGE_RXCLEAR ) ;
	
	COMMTIMEOUTS CommTimeOuts;
    CommTimeOuts.ReadIntervalTimeout = 0xFFFFFFFF ;
    CommTimeOuts.ReadTotalTimeoutMultiplier = 0 ;
    CommTimeOuts.ReadTotalTimeoutConstant = 0 ;
    CommTimeOuts.WriteTotalTimeoutMultiplier = 5;
    CommTimeOuts.WriteTotalTimeoutConstant = 0 ;
    SetCommTimeouts( hComm, &CommTimeOuts ) ;
	
	pThis->m_hComm = hComm;
	return  TRUE;*/
}

STDMETHODIMP_(BOOL) MYDLLPro::XProtocolImp::CloseComDevice()
{
    METHOD_PROLOGUE(MYDLLPro, ProtocolImp);
	
	if(pThis->m_hComm != INVALID_HANDLE_VALUE)
	{
		CloseHandle( pThis->m_hComm );
		pThis->m_hComm = INVALID_HANDLE_VALUE;
	}
    return TRUE;
}

STDMETHODIMP_(BOOL) MYDLLPro::XProtocolImp::InitialDevice(char *  pDeviceName, int nUnitAddr, LPVOID lpDevAddr)
{
    METHOD_PROLOGUE(MYDLLPro, ProtocolImp);
	return TRUE;
}


BOOL MYDLLPro::PhysicalReceive(char * pReceive, int & nLen)
{
	DWORD  dwError;
	COMSTAT	cs;
	DWORD dwTimeOut=GetTickCount()+m_nTimeOut;
	ULONG   nByteRead = 0;
	int     RecLen = 0;
	char cTemp[1024];
	memset(cTemp,0,sizeof(cTemp));

	while(TRUE)
	{
		if(GetTickCount() > dwTimeOut)
		{
//			m_nLastErrorCode = TIME_OUT_ERROR;
			TRACE("Time Out!\n");
			return FALSE;
		}
		ClearCommError( m_hComm, &dwError, &cs );

//		if(cs.cbInQue > 1024)
//			RecLen = 1024;
//		else 
//			RecLen = cs.cbInQue;

		if ( cs.cbInQue )
		{
			BOOL bReadSuc = ReadFile(m_hComm, cTemp, cs.cbInQue, &nByteRead, NULL);
			if ( bReadSuc  )
			{
				memcpy(pReceive,cTemp,nByteRead);
				nLen = (int) nByteRead;
//				TRACE("receive  %s\n",pReceive);
				
			}
			return  TRUE;
		}			//for(i=0;i<strlen(pReceive)
//		if(pReceive[nLen-1]==0x0A) 
//			return TRUE;
	}
	return FALSE;
}

STDMETHODIMP_(int) MYDLLPro::XProtocolImp::LoadDeviceInfo( const char *sProd, const char *sDevName, int nType )
{
    METHOD_PROLOGUE(MYDLLPro, ProtocolImp);
	
	return  TRUE;
}

STDMETHODIMP_(BOOL) MYDLLPro::XProtocolImp::GetRegisters(char *szDeviceName,LPVOID * ppRegs, int *pRegNum)
{	
    METHOD_PROLOGUE(MYDLLPro, ProtocolImp);
		*ppRegs = (LPVOID)&gsRegInfos;
		*pRegNum = REG_TYPE_NUM;
	
	return TRUE;
}

STDMETHODIMP_(BOOL) MYDLLPro::XProtocolImp:: AddVarToPacket( LPVOID lpVar, int nVarAccessType,LPVOID lpPacket)
{
	METHOD_PROLOGUE(MYDLLPro, ProtocolImp);
	
    PPACKET pPack = (PACKET *)lpPacket;
    PPLCVAR pVar = (PLCVAR *)lpVar;

	int nTotalNo;

	if((nVarAccessType == pPack->nPacketType)&&(pPack->nUnitNo == pVar->nUnitNo)
        && (pPack->nRegType == pVar->nRegType))
	{
		if ( nVarAccessType == PT_WRITE )
		{
			if ( pVar->nNo == pPack->nStartNo )  
				return TRUE;
			else  
				return FALSE;
		}
	  //Read Operate 
		if ( pVar->nNo<pPack->nStartNo )
		{//Graph:		-----no-------Start================End----------
			nTotalNo = pPack->nEndNo - pVar->nNo + 1;
			if ( nTotalNo <= MAX_PACKET_NUM )
			{
				pPack->nStartNo = pVar->nNo;	
				return TRUE;
			}
		}
		else if ( pVar->nNo > pPack->nEndNo )
		{//Graph:		------------Start================End----no------
			nTotalNo = pVar->nNo - pPack->nStartNo + 1;
			if ( nTotalNo <= MAX_PACKET_NUM )
			{
				pPack->nEndNo = pVar->nNo;
				return TRUE;
			}
		}
		else
		{//Graph:		------------Start====no============End----------
			return TRUE;
		}		
	}
	return FALSE;		
}

STDMETHODIMP_(WORD) MYDLLPro::XProtocolImp:: ConvertUserConfigToVar( LPVOID lpDbItem, LPVOID lpVar )
{
	METHOD_PROLOGUE(MYDLLPro, ProtocolImp);
	
	MiniDbItem * pTheDbItem = (MiniDbItem*)lpDbItem;
	CString strRegName;
	
	CString strDevName(pTheDbItem->szDevName);
	strRegName = pTheDbItem->szRegister;      
	
	if(pThis->MyConvert( lpDbItem, lpVar,
		gsRegInfos, REG_TYPE_NUM))
		return 1;
	return 0;
}

STDMETHODIMP_(int) MYDLLPro::XProtocolImp:: ProcessPacket( LPVOID lpPacket )
{
    METHOD_PROLOGUE(MYDLLPro, ProtocolImp);
	

	PPACKET pPac = (PPACKET) lpPacket;

	POSITION position =  pPac->varList.GetHeadPosition();
	ID_NO* idNo = (ID_NO*)pPac->varList.GetNext(position);
	
	char Readbuffer[1024];	
	char SendBuffer[64];
	char pData[1024];
		
	DWORD    dwTimeOutTick = 0;
	BOOL     bTimeOut = FALSE;

    int  nLen=0;
	int  nReceiveLen = 0;
	int  nByteRead = 0;
	int  ret = 0;
	int  bError  = 0;
	int  bPacSuc = 0;	

	memset(Readbuffer,0,sizeof(Readbuffer));	
	memset(SendBuffer,0,sizeof(SendBuffer));	
	memset(pData,0,sizeof(pData));	
	
	if(PT_WRITE == pPac->nPacketType)//寫數據
	{
		pThis->m_nLastErrorCode = DONOT_WRITE; 
		return  FALSE;
	}	
	
	pThis->GetSendString(pPac,SendBuffer, nLen);
	
	ASSERT(nLen > 0);

	pThis->PhysicalSend(SendBuffer, nLen);
	
	TRACE("Send %s\n",SendBuffer+1);

	Sleep(100);

	dwTimeOutTick = GetTickCount() + pThis->m_nTimeOut;
	
	while ( TRUE )
	{					
		if( pThis->PhysicalReceive( Readbuffer, nByteRead ) )
		{					
			memcpy( pData+nReceiveLen, Readbuffer, nByteRead );
			/*	for (int i=0;i<nByteRead;i++)
			{
			TRACE("%x,",Readbuffer[i]);					
			}
			TRACE("\n");*/
			TRACE("receive %s\n",Readbuffer);
			
			nReceiveLen+= nByteRead;
			pData[nReceiveLen] = 0;
			
			ret = pThis->PreProcessData(pPac, pData, nReceiveLen, nByteRead);
			//#ifdef _DEBUG
			//ret = RECEIVE_RECEIVED;//test
			//#endif
			if(ret == RECEIVE_RECEIVED)
			{
				//					receivetime = GetTickCount() - (dwTimeOutTick - pThis->m_nTimeOut);
				break;
			}