cscmal.cpp

一个通讯管理机的源代码。比较好用。推荐

#include "cscmal.h"
#include "math.h"
//0x1021 算法中的数据只包括定值本身，不包括区号、序号、类型和性质
static WORD cal_crc(BYTE *ptr, BYTE len)
{ 
	WORD crc; 
	BYTE da; 
	static WORD crc_ta[256]={ /* CRC余式表 */ 
		0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 
		0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef, 
		0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, 
		0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de, 
		0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485, 
		0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d, 
		0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4, 
		0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc, 
		0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823, 
		0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b, 
		0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12, 
		0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a, 
		0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41, 
		0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49, 
		0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70, 
		0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78, 
		0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f, 
		0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067, 
		0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e, 
		0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256, 
		0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d, 
		0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 
		0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c, 
		0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634, 
		0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab, 
		0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3, 
		0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a, 
		0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92, 
		0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9, 
		0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1, 
		0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8, 
		0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0 
	}; 

	crc=0; 
	while(len--!=0) { 
		da=(BYTE) (crc/256); /* 以8位二进制数的形式暂存CRC的高8位 */ 
		crc<<=8; /* 左移8位，相当于CRC的低8位乘以 */ 
		crc^=crc_ta[da^*ptr]; /* 高8位和当前字节相加后再查表求CRC ，再加上以前的CRC */ 
		ptr++; 
	} 
	return(crc); 
} 

static float wtf(WORD wValue)
{
 	double fRet = 0;
 	BYTE* pby = (BYTE *) &wValue;
 	fRet = *pby++;
 	char c = *((char *)pby);
 	fRet =  fRet*pow(2,c)/256;
 	fRet += 0.0009;
 	fRet *= 1000;
 	DWORD dw = (DWORD)fRet;
 	fRet = dw;
 	fRet /=1000;
 	return (float)fRet;
}

static WORD ftw(float fValue)
{
 	WORD wRet;
 	BYTE* pby = (BYTE *)&wRet;
 	float fTemp = fValue;
 	char c=0;
 	while (1)
 	{
 		if (fTemp <= 0) break;
 		else if (fTemp*256 >255) {fTemp /= 2; c++;}
 		else if (fTemp*256 < 128) {fTemp *=2;c--;}
 		else break;
 	}	
 	*pby++ = (BYTE)(fTemp*256);
 	*(char *)pby = c;
 	return wRet;	
}

void* CSCMaster(void *pVoid)//Period and Cycle for PRM=1; Wait IND for PRM=0
{
	CCSCMas *pAS = (CCSCMas *)pVoid;
	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
/*	BYTE* pbyTemp = NULL;
	WORD wSize = 0;
	pAS->GetFV(9,pbyTemp,wSize,0);
	pAS->PutFV(9,pbyTemp,wSize,0);*/
	while (!pAS->m_subdevmgr.HasOn()) sleep(1);
	while (pAS->m_subdevmgr.GetNum() != 11) sleep(1);
	while (1) {
		pAS->Query();
		sleep(1);
	}
}

void* CSCRecv(void *pVoid)//Period and Cycle for PRM=1; Wait IND for PRM=0
{
	CCSCMas *pAS = (CCSCMas *)pVoid;
	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
	while (pAS->m_subdevmgr.GetNum() != 11) sleep(1);
	sleep(5);
	while (1) {
		pAS->ReadDL();
		usleep(10000);
	}
}

CCSCMas::~CCSCMas()
{
	if (m_hThread > 0)
	{
		cout << "CCSCMas query" << m_hThread << endl;
		pthread_cancel(m_hThread);
	}
	if (m_hThreadRecv > 0)
	{
		cout << "CCSCMas recv" << m_hThread << endl;
		pthread_cancel(m_hThreadRecv);
	}
}

bool CCSCMas::Init()
{
	bool bRet = false;
	if (m_dlsvr.Init())
	{
		pthread_attr_t attr;
		pthread_attr_init(&attr);
		pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
		if (pthread_create(&m_hThread,&attr,CSCMaster,(void *)this) == 0)
		{
			pthread_attr_t attr1;
			pthread_attr_init(&attr1);
			pthread_attr_setdetachstate(&attr1,PTHREAD_CREATE_DETACHED);
			if (pthread_create(&m_hThreadRecv,&attr1,CSCRecv,(void *)this) == 0)
				bRet = true;
		}
		pthread_attr_destroy(&attr);
	}
	return bRet;
}

void CCSCMas::ReadDL()
{
	CFrameNode fnR;
	if (m_dlsvr.IND(fnR) == 1)
	{
		if (fnR.m_wDAddr<255)
			m_wBreakCount[fnR.m_wSAddr]++;
		if (fnR.m_wDAddr == 0xf)
		{
			Explain(&fnR);
		}
		else if (fnR.m_wDAddr == 0x5) //local addr
		{
			CFrameNode* pfn = new CFrameNode;
			*pfn = fnR;
			m_queResp.Add(pfn);// append tsdu to queIND
		}
	}
}

void CCSCMas::Query()
{
	CTimeVal tmCurrent;
	CTimeValSpan tvs;
	if (tmCurrent > m_tmRectify)
	 	tvs = tmCurrent - m_tmRectify;
	 else tvs = m_tmRectify - tmCurrent;
	if (m_bFirst || (tvs.GetMinute() >= 1))
	{
		if (!m_bFirst)
		{
			BYTE byDevNum = m_subdevmgr.GetNum();
			YXData* pYXData = new YXData [byDevNum];
			for (BYTE byNo=0;byNo< byDevNum; byNo++)
			{
				CSubdev* pDev = m_subdevmgr.GetDevFrmNo(byNo);
				pYXData[byNo].m_wDevNo = pDev->m_wDevNo;
				pYXData[byNo].m_wDevPtNo =199;
				if (pDev)
				{
					if (m_wBreakCount[pDev->m_byAddr]>0)
					{
						m_wBreakCount[pDev->m_byAddr] = 0;
						pYXData[byNo].m_bValue = 0xff;
					}
					else 	
						pYXData[byNo].m_bValue = 0xff00;
				}
			}
			m_pAllMgr->YX(pYXData, byDevNum);
			delete [] pYXData;
		}
		m_bFirst = false;
		SyncClock();
		m_tmRectify = tmCurrent;
	}
/*				static WORD wValue = 1;
				BYTE byNum = 16 ;
				WORD byA = 1;
				YXData* pYXData = new YXData [byNum];
				for (BYTE by=4; by<4+byNum/8; by++)
				{
		printf("%02X ",wValue);
					for (BYTE b=0; b<8; b++,byA<<=1)
					{
						pYXData[b+8*(by-4)].m_wDevNo = 3;
						pYXData[b+8*(by-4)].m_wDevPtNo =b+8*by + 1 ;
						pYXData[b+8*(by-4)].m_bValue = (wValue & byA)?0xff00:0xff;
					}
				}
				wValue<<=1;
				if (wValue == 0) wValue = 1;
				m_pAllMgr->YX(pYXData, byNum);
				delete [] pYXData;
				cout <<endl;*/
}

bool CCSCMas::Reset(WORD wAddr)
{
	bool bRet = false;
	CFrameNode FNSend;
	FNSend.m_byCID = 0x3f;
	FNSend.m_wDAddr = wAddr;
	FNSend.SetSize(0);
	if (m_dlsvr.REQ(0,&FNSend,0,false) == 1)
	{
		CFrameNode* pfn=NULL;
		if (m_queResp.Get(pfn,200))
		{
			if (pfn->m_byCID == 0x26) //success
				bRet = true;
			delete pfn;
		}
	}
	return bRet;
}


void CCSCMas::SyncClock()
{
	pthread_mutex_lock(&m_mutex);
	CFrameNode FNSend,FNSend1;
	FNSend.m_byCID = 0x3d;
	FNSend.m_wDAddr = 0xff; //广播地址
	
	FNSend.SetSize(6);

	BYTE *pbyTemp = FNSend.m_pbyData;
	CTimeVal ctv;
	struct tm st;
	ctv.GetTime(&st);

	*pbyTemp++ = st.tm_sec;
	*pbyTemp++ = st.tm_min;
	*pbyTemp++ = st.tm_hour;
	*pbyTemp++ = st.tm_mday;
	*pbyTemp++ = st.tm_mon+1;
	*pbyTemp = st.tm_year-100;

	m_dlsvr.REQ(1,&FNSend,0,false);//Send - No Respond
	usleep(100000);//100ms
	FNSend1.m_byCID = 0x3e;
	FNSend1.m_wDAddr = 0xff; //广播地址
	FNSend1.m_wSize = 0;
	m_dlsvr.REQ(1,&FNSend1,0,false);//Send - No Respond
// 	cout <<"SyncClock"	<< st.tm_year<<endl;
	pthread_mutex_unlock(&m_mutex);
}

bool CCSCMas::YK(WORD wDevNo,BYTE byRoute,bool bIsOn)
{
	bool bRet = false;
	pthread_mutex_lock(&m_mutex);
	
	BYTE byAddr = m_subdevmgr.GetAddrFrmDevNo(wDevNo);
	if (byAddr == 0xff)
	{
		pthread_mutex_unlock(&m_mutex);
		return bRet;	
	}
	if (byRoute == 99)
	{
		bRet = Reset(byAddr);	
		pthread_mutex_unlock(&m_mutex);
		return  bRet;
	}
	CFrameNode FNSend,FNRecv;
	FNSend.m_byCID = 0x1e; //select
	FNSend.m_wDAddr = byAddr;//GGG
	FNSend.SetSize(2);
	BYTE* pData = FNSend.m_pbyData;

	pData[0] = ~((byRoute==1)?1:(byRoute-1));
	pData[1] = ~((byRoute==1)?(bIsOn?0xd2:0xd1):(bIsOn?0xb4:0xbc));

	if (m_dlsvr.REQ(0,&FNSend,0,true) == 1)//Send - Respond
	{
		CFrameNode* pfn=NULL;
		if (m_queResp.Get(pfn,200))
		{
			if (pfn->m_byCID == 0x3c) //success
			{
				FNSend.m_byCID = 0x1a; ////execute
				pData[0] = (byRoute==1)?1:(byRoute-1);
				pData[1] = (byRoute==1)?(bIsOn?0xd2:0xd1):(bIsOn?0xb4:0xbc);
				if (m_dlsvr.REQ(0,&FNSend,0,true) == 1)//Send - Respond
				{
					CFrameNode* pfn1=NULL;
					if (m_queResp.Get(pfn1,200))
					{
						if (pfn1->m_byCID == 0x26)
							bRet = true;
						delete pfn1;
					}
				}
			}
			delete pfn;
		}
	}
	
	pthread_mutex_unlock(&m_mutex);
	return bRet;
}

/*
{27} {27} \1a \05 \2f \b3 \01 \00 \16 \ff \90 \02 \00 \00 \02 \00 \20 \00 \c8 \07 \00 \00 \00 \00 \c8 \07 \00 \80 \06
{26} {26} \19 \05 \2f \b3 \02 \00 \16 \ff \00 \c8 \07 \00 \80 \06 \00 \8c \07 \00 \a0 \05 \00 \00 \00 \00 \a0 \05
{26} {26} \19 \05 \2f \b3 \03 \00 \16 \ff \00 \80 \06 \00 \a0 \05 \00 \80 \06 \00 \c8 \07 \00 \80 \02 \00 \a0 \05
{26} {26} \19 \05 \2f \b3 \04 \00 \16 \ff \00 \80 \02 \00 \c8 \07 \00 \e5 \fa \00 \a0 \05 \00 \e5 \fa \00 \a3 \fb
{26} {26} \19 \05 \2f \b3 \05 \00 \16 \ff \00 \a0 \04 \00 \f0 \06 \00 \f0 \06 \00 \f0 \05 \00 \a0 \04 \00 \c0 \06
{26} {26} \19 \05 \2f \b3 \06 \00 \16 \ff \00 \80 \01 \00 \8c \07 \00 \a0 \03 \00 \a0 \04 \00 \b4 \07 \00 \80 \01
{19} {19} \12 \05 \2f \b3 \07 \80 \16 \ff \00 \a0 \04 \00 \cc \fe \00 \cc \fd \10 \81
*/
/*
{27} {27} \1a \05 \2f \b3 \01 \00 \16 \ff \90 \02 \00 \00 \02 \00 \20 \00 \c8 \07 \00 \00 \00 \00 \c8 \07 \00 \80 \06
{26} {26} \19 \05 \2f \b3 \02 \00 \16 \ff \00 \c8 \07 \00 \80 \06 \00 \8c \07 \00 \a0 \05 \00 \00 \00 \00 \a0 \05
{26} {26} \19 \05 \2f \b3 \03 \00 \16 \ff \00 \80 \06 \00 \a0 \05 \00 \80 \06 \00 \c8 \07 \00 \80 \02 \00 \a0 \05
{26} {26} \19 \05 \2f \b3 \04 \00 \16 \ff \00 \80 \02 \00 \c8 \07 \00 \e5 \fa \00 \a0 \05 \00 \e5 \fa \00 \a3 \fb
{26} {26} \19 \05 \2f \b3 \05 \00 \16 \ff \00 \a0 \04 \00 \f0 \06 \00 \f0 \06 \00 \f0 \05 \00 \a0 \04 \00 \c0 \06
{26} {26} \19 \05 \2f \b3 \06 \00 \16 \ff \00 \80 \01 \00 \8c \07 \00 \a0 \03 \00 \a0 \04 \00 \b4 \07 \00 \80 \01
{19} {19} \12 \05 \2f \b3 \07 \80 \16 \ff \00 \a0 \04 \00 \cc \fe \00 \cc \fd \10 \81
{6} 05  2f  05  1e  fe  2e
{6} {6} \05 \05 \2f \3c \01 \d1
{6} 05  2f  05  1a  01  d1
 */

bool CCSCMas::GetFV(WORD wDevNo,BYTE*& pbyBuf,WORD& wSize,WORD wFuncCode)
{
	pthread_mutex_lock(&m_mutex);
	bool bRet = false;
	WORD awBuf[39];
	BYTE byPoint = 0;

	BYTE byAddr = m_subdevmgr.GetAddrFrmDevNo(wDevNo);
	if (byAddr == 0xff)
	{
		pthread_mutex_unlock(&m_mutex);
		return bRet;	
	}
	BYTE byType = m_subdevmgr.GetTypeFrmAddr(byAddr);
	
	CFrameNode FNSend;
	FNSend.m_byCID = 0x23;
	FNSend.m_wDAddr = byAddr;
	FNSend.SetSize(2);

	BYTE* pData = FNSend.m_pbyData;
	pData[0] = 0x16; //datetype
	pData[1] = 0x0; //current fixed_value no. 0xff

	if (m_dlsvr.REQ(0,&FNSend,0,true) == 1)//Send - Respond
	{
		CFrameNode* pfn=NULL;
//		BYTE* pTemp = abyBuf;
		while (m_queResp.Get(pfn,2000))
		{
			if ((pfn->m_byCID & 0x7f) == 0x33)
			{
				WORD w = (byPoint == 0)?6:5;
				for (;w<pfn->m_wSize;w+=3)
				{
					WORD* pwTemp = (WORD *)&pfn->m_pbyData[w];
					if (byPoint <2)
						awBuf[byPoint++] = CW(*pwTemp);
					else awBuf[byPoint++] = *pwTemp;
				}
				if (((pfn->m_byCID & 0x80) != 0x80) || ((pfn->m_pbyData[1] & 0x80) != 0))
				{