ca2ipro.cpp

民航二所单片机驱动开发

// CA2IPro.cpp : implementation file
//

#include "stdafx.h"
#include "CivilAviaton2Institute.h"
#include "CA2IPro.h"

#include "math.h"

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

#ifndef OUT_DEBUG_MESSAGE
#define OUT_DEBUG_MESSAGE
#endif

void ShowMessage(const char* msg);
#define  WM_MESSAGE_OUTPUT  WM_USER+50
/////////////////////////////////////////////////////////////////////////////
// CCA2IPro

IMPLEMENT_DYNCREATE(CCA2IPro, CCmdTarget)

CCA2IPro::CCA2IPro()
{
	EnableAutomation();
	
	// To keep the application running as long as an OLE automation 
	//	object is active, the constructor calls AfxOleLockApp.
	m_nLastErrorCode = -1;
	m_nTimeOut = 3000;
	m_nLastLoopNum = -1;
	m_nLastRegType = -1;
	m_nLastDataLen = -1;
	m_hComm = INVALID_HANDLE_VALUE;
    m_bOn = FALSE;
    memset(LoopNum, 0, sizeof(LoopNum));
	memset(DKSFlag, 0, sizeof(DKSFlag));
	memset(DKGFlag, 0, sizeof(DKGFlag));
	memset(m_nData, 0, sizeof(m_nData));
	memset(m_nSelectLoopNo, 0, sizeof(m_nSelectLoopNo));
	memset(m_nHaveSensor, 0, sizeof(m_nHaveSensor));
	memset(m_nSleepTime, 0, sizeof(m_nSleepTime));
	memset(m_nMaxNo, 0, sizeof(m_nMaxNo));
	AfxOleLockApp();
}

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


void CCA2IPro::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(CCA2IPro, CCmdTarget)
	//{{AFX_MSG_MAP(CCA2IPro)
		// NOTE - the ClassWizard will add and remove mapping macros here.
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

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

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

// {DDE96CAE-FFA3-4134-A67B-444F76EE7D85}
static const IID IID_ICA2IPro =
{ 0xdde96cae, 0xffa3, 0x4134, {0xa6, 0x7b, 0x44, 0x4f, 0x76, 0xee, 0x7d, 0x85 } };

BEGIN_INTERFACE_MAP(CCA2IPro, CCmdTarget)
	INTERFACE_PART(CCA2IPro,  IID_ICA2IPro, Dispatch)
	INTERFACE_PART(CCA2IPro,  IID_ProtocolImp,  ProtocolImp)
	INTERFACE_PART(CCA2IPro,  IID_ProtocolImp2, ProtocolImp2)
END_INTERFACE_MAP()

// {9E7A4A45-EED5-4178-BBB9-4682BC89B55F}
IMPLEMENT_OLECREATE(CCA2IPro, "CivilAviaton2Institute.CA2IPro", 0x9e7a4a45, 0xeed5, 0x4178, 0xbb, 0xb9, 0x46, 0x82, 0xbc, 0x89, 0xb5, 0x5f)

/////////////////////////////////////////////////////////////////////////////
// CCA2IPro message handlers
STDMETHODIMP_(ULONG) CCA2IPro::XProtocolImp::AddRef(void)
{
	METHOD_PROLOGUE(CCA2IPro, ProtocolImp);
	return pThis->ExternalAddRef();
}
//ULONG FAR EXPORT CEditPrintObj::XEditObj::Release()
STDMETHODIMP_(ULONG) CCA2IPro::XProtocolImp::Release(void)
{
	METHOD_PROLOGUE(CCA2IPro, ProtocolImp);
	return pThis->ExternalRelease();
}

//HRESULT FAR EXPORT CEditPrintObj::XEditObj::QueryInterface(
//    REFIID iid, void FAR* FAR* ppvObj)
STDMETHODIMP_(HRESULT) CCA2IPro::XProtocolImp::QueryInterface(
	REFIID iid, void * * ppvObj)
{
	METHOD_PROLOGUE(CCA2IPro, ProtocolImp);
	return pThis->ExternalQueryInterface(&iid, ppvObj);
}

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

	return TRUE;
}

STDMETHODIMP_(BOOL) CCA2IPro::XProtocolImp::OpenComDevice
(int nDevType, LPVOID lpInitData)
{
	METHOD_PROLOGUE(CCA2IPro, ProtocolImp);
   
	return pThis->InitialComm(lpInitData);
}

STDMETHODIMP_(BOOL) CCA2IPro::XProtocolImp::InitialDevice(
	char *DevName,int nUnitAddr,LPVOID pDevAddr)
{
	METHOD_PROLOGUE(CCA2IPro, ProtocolImp);

 	return TRUE;
}

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

STDMETHODIMP_(BOOL) CCA2IPro::XProtocolImp::TryConnect
  (char *devName, int nAddr, LPVOID lpDevAddr)
{
	return TRUE;
	METHOD_PROLOGUE(CCA2IPro, ProtocolImp);
    BOOL bRetval = TRUE;
	BYTE nCRCData = 0;
	int  nLen=0, nReceLen=0;
	BYTE Readbuffer[1024];
	memset(Readbuffer, 0, sizeof(Readbuffer));
	Readbuffer[0] = 0x55;
	Readbuffer[1] = 7;               
	Readbuffer[2] = 1;
	Readbuffer[3] = 0xff;               
	Readbuffer[4] = 0xff;
    Readbuffer[5] = pThis->CRC_ADD(Readbuffer, 5);
	Readbuffer[6] = 0x68;
	nLen = 7;      
	bRetval = pThis->Transmission(Readbuffer, nLen, nReceLen,NULL);
	BYTE CheckBuf[1024];  int nClen = 0;
	memset(CheckBuf, 0, sizeof(CheckBuf));
	if (Readbuffer[0] == 0xc3 && Readbuffer[6] == 0x68)
	{
		bRetval = TRUE;
		CheckBuf[0] = 0xdd;  CheckBuf[1] = 0xdd;  CheckBuf[2] = 0xdd; 
	}
	else
	{
		ShowMessage("接收数据错");
		CheckBuf[0] = 0xd0;  CheckBuf[1] = 0xd0;  CheckBuf[2] = 0xd0;
		bRetval = FALSE;
	}
	nClen = 3;
	pThis->Transmission(CheckBuf, nClen, nClen,NULL);
	if (CheckBuf[0] == 0xd0 || !bRetval)
	{
		ShowMessage("验证通讯错");
		bRetval = FALSE;
	}

	return bRetval;
}

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

	return TRUE;
}

STDMETHODIMP_(INT) CCA2IPro::XProtocolImp::GetRegisters
(char *name,  LPVOID *ppRegs, int *pRegNum)
{
	METHOD_PROLOGUE(CCA2IPro, ProtocolImp);

	*ppRegs = (LPVOID)&gsRegInfos;
	*pRegNum = REG_TYPE_NUM;

	return TRUE;
}

STDMETHODIMP_(WORD) CCA2IPro::XProtocolImp::
ConvertUserConfigToVar(LPVOID lpDbItem, LPVOID lpVar)
{
	METHOD_PROLOGUE(CCA2IPro, ProtocolImp);
	MINIDBITEM * pDbItem = (MINIDBITEM *)lpDbItem;
	PPLCVAR  pPlcVar = (PPLCVAR)lpVar;
	BOOL  bRet = FAIL;
   
	bRet = pThis->MyConvert(lpDbItem, lpVar, gsRegInfos, REG_TYPE_NUM);

	return bRet;
}

STDMETHODIMP_(BOOL) CCA2IPro::XProtocolImp::AddVarToPacket
 (LPVOID lpVar, int nVarAccessType, LPVOID lpPacket)
{
	METHOD_PROLOGUE(CCA2IPro, ProtocolImp);
	
	BOOL  bRetVal = FALSE; 
	PPACKET pPack = (PPACKET)lpPacket;
	PPLCVAR pVar  = (PPLCVAR)lpVar;

	if(pPack->nRegType == TOFF_REG || pPack->nRegType == TON_REG)
		return FALSE;

    if (pPack->nDeviceIndex == pVar->nDeviceIndex
       && nVarAccessType == PT_READ 
	   && pPack->nRegType == pVar->nRegType)
	{
		if(pPack->nRegType == MSPDATA_REG || pPack->nRegType == ADAPTER_REG ||
		   pPack->nRegType == SENDATA_REG || pPack->nRegType == DKSDATA_REG ||
		   pPack->nRegType == DKGDATA_REG )
		{
			if(pPack->nSubType != pVar->nSubType)
				return FALSE;
		}
		int  nTotal = 0;
		if (pVar->nNo < pPack->nStartNo)
		{
            nTotal = pPack->nEndNo - pVar->nNo;
			if (nTotal > MAX_PACKET_NUM)
			   bRetVal = FALSE;
			else
			{
			   pPack->nStartNo = pVar->nNo;
			   bRetVal = TRUE;
			}
		}
		else if (pVar->nNo > pPack->nEndNo)
		{
			nTotal = pVar->nNo - pPack->nStartNo;
			if (nTotal > MAX_PACKET_NUM)
			   bRetVal = FALSE;
			else
			{
			   pPack->nEndNo = pVar->nNo;
			   bRetVal = TRUE;
			}
		}
		else
          bRetVal = TRUE;
	}
	else
		bRetVal = FALSE;

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

	//TO DO: Do your own Initialization.

	return  TRUE;
}

STDMETHODIMP_(int) CCA2IPro::XProtocolImp::ProcessPacket( LPVOID lpPacket )
{
 	METHOD_PROLOGUE(CCA2IPro, ProtocolImp);
	
	PPACKET pPac = (PACKET*)lpPacket;
	BOOL	bPacSuc = FALSE;
	
	return bPacSuc;	
}

WORD  CCA2IPro::MyConvert(LPVOID lpDbItem,  LPVOID lpVar,
						  LPVOID lRegInfos, int reg_type_num)
{
	MINIDBITEM *pDbItem = (MINIDBITEM *)lpDbItem;
	
	PLCVAR *pPlcVar = (PLCVAR *)lpVar;
	REG_INFO *gsRegInfos = (REG_INFO *)lRegInfos;

	char buf[128];
	WORD bResult = SUCCESS;
	memset(buf, 0, sizeof(buf));
	strcpy(buf, pDbItem->szRegister);
	char  *pChar = buf;	
	
	while (*pChar == ' ' && (pChar-buf) < 32) 
		pChar++;
	int nLen = strlen(pChar);
	while (nLen > 0 && pChar[nLen-1] == ' ')
		pChar[--nLen] = 0;
    
	for (int nRegType=0; nRegType<reg_type_num; nRegType++)
	{
		char *pDest = strstr(pChar, gsRegInfos[nRegType].sRegName);
		if (pDest != pChar)
			continue;
		if (gsRegInfos[nRegType].nLowIndex < gsRegInfos[nRegType].nUpperIndex)
		{
			char tv_fmt[128];
			memset(tv_fmt, 0, sizeof(tv_fmt));
			strcpy(tv_fmt, gsRegInfos[nRegType].sRegName);
			int nNo=-1, tv_n=0;
			strcat(tv_fmt, "%u");
			tv_n = sscanf(pChar, tv_fmt, &nNo);
			if (tv_n == EOF || tv_n == 0) 
			{
				m_nLastErrorCode = USER_REG_DECIMAL;
				return FAIL;
			}
			if(nRegType == MSPDATA_REG || nRegType == ADAPTER_REG || 
			   nRegType == SENDATA_REG || nRegType == DKSDATA_REG ||
			   nRegType == DKGDATA_REG )
			{
				pChar += strlen(tv_fmt)-2;
				char *pPoint = NULL;
				pPoint = strstr(pChar,".");
				if(pPoint != NULL)
				{
					int nHL = -1;// nHL.nNo  nHL回路 nNo 数据号或检测器号
					nNo = atoi(pPoint+1);
					if(nRegType == MSPDATA_REG || nRegType == SENDATA_REG || 
					   nRegType == DKSDATA_REG || nRegType == DKGDATA_REG )
					{
						if(nNo<0 || nNo>34)
						{
							m_nLastErrorCode = USER_REG_DECIMAL;
							return FAIL;
						}
					}
					else
					{
						if(nNo<0 || nNo>32)
						{
							m_nLastErrorCode = USER_REG_DECIMAL;
							return FAIL;
						}
					}
					pPoint = 0;
					nHL = atoi(pChar);
					if ((nHL < gsRegInfos[nRegType].nLowIndex) 
					   || (nHL > gsRegInfos[nRegType].nUpperIndex))
					{
						m_nLastErrorCode = USER_REG_DECIMAL;
						return FAIL;
					}
					pPlcVar->nSubType = nHL;
					pPlcVar->nRegType = nRegType;
					pPlcVar->nNo = nNo;	
					pPlcVar->pszRegName = gsRegInfos[ nRegType].sRegName;
					if ((pDbItem->nDataType & gsRegInfos[nRegType].wDataType) != 0)
					{
						pPlcVar->nDataType = pDbItem->nDataType;
						bResult = SUCCESS;
						return bResult;
					}
					else
					{
						m_nLastErrorCode =  USER_NODATA;
						bResult = FAIL;
						return bResult;
					}		
					return SUCCESS;

				}
				else
				{
					m_nLastErrorCode = USER_REG_DECIMAL;
					return FAIL;
				}
			}
			pPlcVar->nNo = 0;
			if ((nNo < gsRegInfos[nRegType].nLowIndex) 
			   || (nNo > gsRegInfos[nRegType].nUpperIndex))
			{
				m_nLastErrorCode = USER_REG_DECIMAL;
				return FAIL;
			}
			pPlcVar->nRegType = nRegType;
			pPlcVar->nSubType = -1;
			pPlcVar->nNo = nNo;	
			pPlcVar->pszRegName = gsRegInfos[ nRegType].sRegName;
			//只有：寄存器名字正确，且数字在范围内，才能执行到此行。
			//判断数据类型
			if ((pDbItem->nDataType & gsRegInfos[nRegType].wDataType) != 0)
			{
				pPlcVar->nDataType = pDbItem->nDataType;
				bResult = SUCCESS;
				return bResult;
			}
			else
			{
				m_nLastErrorCode =  USER_NODATA;
				bResult = FAIL;
				return bResult;
			}		
		}
	else
		{
			if(gsRegInfos[nRegType].nLowIndex == gsRegInfos[nRegType].nUpperIndex)
			{
				if(strcmp(pChar, gsRegInfos[nRegType].sRegName) == 0)
				{
					pPlcVar->nRegType = nRegType;
					pPlcVar->nNo = -1;	
					pPlcVar->pszRegName = gsRegInfos[ nRegType].sRegName;
					pPlcVar->nSubType = -1;	
					if ((pDbItem->nDataType & gsRegInfos[nRegType].wDataType) != 0)
					{
						pPlcVar->nDataType = pDbItem->nDataType;
						bResult = SUCCESS;
						return bResult;
					}
					else
					{
						m_nLastErrorCode =  USER_NODATA;
						bResult = FAIL;
						return bResult;
					}		
				}
			}
			m_nLastErrorCode =  USER_REGNAME_C_ERROR;
			bResult = FAIL;
			return bResult;
		}
        return  bResult;   	
	}
	m_nLastErrorCode =  USER_REGNAME_C_ERROR;         //寄存器名错误

	return FAIL;	//查找完所有寄存器名都不匹配。
}

STDMETHODIMP_(ULONG) CCA2IPro::XProtocolImp2::AddRef(void)
{
    METHOD_PROLOGUE(CCA2IPro, ProtocolImp2);

    return pThis->ExternalAddRef();
}

STDMETHODIMP_(ULONG) CCA2IPro::XProtocolImp2::Release(void)
{
    METHOD_PROLOGUE(CCA2IPro, ProtocolImp2);

    return pThis->ExternalRelease();
}

STDMETHODIMP CCA2IPro::XProtocolImp2::QueryInterface(
    REFIID iid, void FAR* FAR* ppvObj)