sepam1000mas.cpp

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

#include "msystem.h"
#include "sepam1000mas.h"

void* Sepam1000Mas(void *pVoid)//Period and Cycle for PRM=1; Wait IND for PRM=0
{
	CSepam1000Mas *pAS = (CSepam1000Mas *)pVoid;
	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
	sleep(2);
	while (1) {
		pAS->Query();
//		usleep(50000);
//		pAS->YK(54,1,false);
//		sleep(5);
//		pAS->YK(55,5,true);
//		sleep(5);
	}
}

CSepam1000Mas::~CSepam1000Mas()
{
	if (m_hThread > 0)
	{
		cout << "CSepam1000Mas" << m_hThread << endl;
		pthread_cancel(m_hThread);
	}
}

bool CSepam1000Mas::Init()
{
	bool bRet = false;
	pthread_attr_t attr;
	pthread_attr_init(&attr);
	pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
	if (pthread_create(&m_hThread,&attr,Sepam1000Mas,(void *)this) == 0)
		bRet = true;
	pthread_attr_destroy(&attr);
	return bRet;
}

void CSepam1000Mas::Query()
{
	while (!m_subdevmgr.HasOn()) sleep(1);
//	while (m_subdevmgr.GetNum() != 11) sleep(1);
	CTimeVal tmCurrent;
	CTimeValSpan tvs = tmCurrent - m_tmRectify;
	if (m_bFirst || (tvs.GetMinute() >= 1))
	{
		m_bFirst = false;
		SyncClock();
		m_tmRectify = tmCurrent;
	}
	else
	{
		if((m_bySendOrder++>=2) || (m_bySendNo == 0xff))
		{
			m_bySendOrder = 0;
			m_bySendNo = m_subdevmgr.GetNextNo(m_bySendNo);
		}
		BYTE byAddr = m_subdevmgr.GetAddrFrmNo(m_bySendNo);
		if (byAddr == 0xff) return;
		BYTE byType	= m_subdevmgr.GetTypeFrmAddr(byAddr);
		WORD wDevNo = m_subdevmgr.GetDevNoFrmAddr(byAddr);
		bool bConnect = false;
		switch(m_bySendOrder)
		{
		case 0:
			bConnect = GetYC(byAddr,byType);
			break;
		case 1:
			bConnect = GetYX(byAddr,byType);
			break;
		case 2:
			bConnect = GetEvent(byAddr,byType);
			break;
		default: 
//			GetYC(byAddr);
//			break;
			break;
		}
		if (bConnect)
		{
			if (m_wBreakCount[byAddr] >0)
			{
				YXData d;
				d.m_wDevNo = wDevNo;
				d.m_wDevPtNo = 199;
				d.m_bValue = 0xff;
				m_pAllMgr->YX(&d, 1);
			}
			m_wBreakCount[byAddr] = 0;
		}
		else
		{
			if (m_wBreakCount[byAddr] >= 5)
			{
				YXData d;
				d.m_wDevNo = wDevNo;
				d.m_wDevPtNo = 199;
				d.m_bValue = 0xff00;
				m_pAllMgr->YX(&d, 1);
				m_wBreakCount[byAddr] = 0;
			}
			else m_wBreakCount[byAddr]++;
		}
	}
	usleep(m_dwIntervalMS * 1000);
}

void CSepam1000Mas::SyncClock()
{
	pthread_mutex_lock(&m_mutex);
	CFrameNode FNSend,FNRecv;
	FNSend.m_byCID = 0x10;
	FNSend.m_byDesAddr = 0; //广播地址
	FNSend.SetSize(13);

	WORD *pwTemp = (WORD *)FNSend.m_pbyData;
	*pwTemp++ = CW(0x2);
	*pwTemp++ = CW(0x4);
	BYTE *pbyTemp = (BYTE *)pwTemp;
	*pbyTemp = 8;
	pwTemp = (WORD *)++pbyTemp;
	CTimeVal ctv;
	struct tm st;
	ctv.GetTime(&st);
	*pwTemp++ = CW(st.tm_year - 100);
	*pwTemp++ = CW(((st.tm_mon+1) << 8) + st.tm_mday);
	*pwTemp++ = CW((st.tm_hour << 8) + st.tm_min);
	*pwTemp = CW(ctv.GetMilliSecs()+st.tm_sec *1000);
	m_DLService.REQ(0,&FNSend,FNRecv,0,false);//Send - No Respond
	usleep(100000);
// 	cout <<"SyncClock"	<< st.tm_year<<endl;
	pthread_mutex_unlock(&m_mutex);
}

bool CSepam1000Mas::YK(WORD wDevNo,BYTE byRoute,bool bIsOn)
{
	bool bRet = false;
	pthread_mutex_lock(&m_mutex);
	
	BYTE byAddr = m_subdevmgr.GetAddrFrmDevNo(wDevNo);
	if (byAddr == 0xff) return false;
	BYTE byRoadNo;
	if (byRoute%10 > 2)
		byRoadNo = byRoute%10 - 1;
	else
		byRoadNo = byRoute%10-(bIsOn?0:1);
		
	BYTE byType	= m_subdevmgr.GetTypeFrmAddr(byAddr);
	WORD wTSAddr = 0x1f00,  wValue = 0xff00;
	if (byType == dt_eSEPAM40)
	{
		wTSAddr = 0x0f00;
		wValue = 0xff00;
	}
	CFrameNode FNSend,FNRecv;
	FNSend.m_byCID = 0x5;
	FNSend.m_byDesAddr = byAddr;
	FNSend.SetSize(4);

	WORD* pData = (WORD *)FNSend.m_pbyData;
	pData[0] = CW(wTSAddr +0x10 + byRoadNo); //select
	pData[1] = CW(wValue);
	m_DLService.SetEchoLen(8);
	if (m_DLService.REQ(1,&FNSend,FNRecv,0,true) == 1)//Send - Respond
	{
		if (FNRecv.m_byCID == 0x5)
		{
			pData[0] = CW(wTSAddr + byRoadNo); //execute
			pData[1] = CW(wValue);
			if (m_DLService.REQ(1,&FNSend,FNRecv,0,true) == 1)//Send - Respond
			{
				if (FNRecv.m_byCID == 0x5)
					bRet = true;
			}
		}
	}
	
	pthread_mutex_unlock(&m_mutex);
	return bRet;
}

bool CSepam1000Mas::GetFV(WORD wDevNo,BYTE*& pbyBuf,WORD& wSize,WORD wFuncCode)
{
	bool bRet = false;
	pthread_mutex_lock(&m_mutex);
	
	BYTE byAddr = m_subdevmgr.GetAddrFrmDevNo(wDevNo);
	
	CFrameNode FNSend,FNRecv;
	FNSend.m_byCID = 0x6;
	FNSend.m_byDesAddr = byAddr;
	FNSend.SetSize(4);

	WORD* pData = (WORD *)FNSend.m_pbyData;
	pData[0] = CW(0x2080);
	pData[1] = CW(wFuncCode);
	m_DLService.SetEchoLen(8);
	if (m_DLService.REQ(1,&FNSend,FNRecv,0,true) == 1)//Send - Respond
	{
		if (FNRecv.m_byCID == 0x6)
		{
			FNSend.m_byCID = 0x3;
			pData[0] = CW(0x2000);
			pData[1] = CW(wSize*2+1);
			m_DLService.SetEchoLen(5+2*(wSize*2+1));
			if (m_DLService.REQ(1,&FNSend,FNRecv,0,true) == 1)//Send - Respond
			{
				if (FNRecv.m_byCID == 0x3)
				{
					BYTE *pbyD = FNRecv.m_pbyData;
					BYTE bySize = pbyD[0];
					WORD *pw = (WORD *)&pbyD[1];
					if (((wSize*2 + 1)*2 == bySize) && (CW(*pw++) == wFuncCode))
					{
						DWORD* pdw = (DWORD *)pw;
						wSize = FNRecv.m_wSize - 3;
						pbyBuf = new BYTE [wSize];
						DWORD* pdwTemp = (DWORD *)pbyBuf;
						for (BYTE b=0; b<wSize/4;b++,pdw++)
						{
							DWORD dw111 = *pdw;
							pdwTemp[b] = CDW(dw111);
						}
						bRet = true;
					}
				}
			}
		}
	}
	
	pthread_mutex_unlock(&m_mutex);
	return bRet;
	
}

bool CSepam1000Mas::PutFV(WORD wDevNo,BYTE* pFixVal,WORD wSize,WORD wFuncCode)
{
	bool bRet = false;
	pthread_mutex_lock(&m_mutex);
	
	BYTE byAddr = m_subdevmgr.GetAddrFrmDevNo(wDevNo);
	
	CFrameNode FNSend,FNRecv;
	FNSend.m_byCID = 0x10;
	FNSend.m_byDesAddr = byAddr;
	FNSend.SetSize(wSize*4+7);

	WORD* pData = (WORD *)FNSend.m_pbyData;
	
	pData[0] = CW(0x2100); //0x2100
	pData[1] = CW(wSize*2+1);
	BYTE *pbyTemp = (BYTE *)&pData[2];
	*pbyTemp++ = (wSize*2+1)*2;
	WORD *pw = (WORD *)pbyTemp;
	*pw++ = CW(wFuncCode);
	DWORD* pdw = (DWORD *)pw;
	DWORD *pdwV = (DWORD *)pFixVal;
	for (WORD w=0; w<wSize; w++)
		*pdw++ = CDW(*pdwV++);

	m_DLService.SetEchoLen(8);
	if (m_DLService.REQ(1,&FNSend,FNRecv,0,true) == 1)//Send - Respond
	{
		if (FNRecv.m_byCID == 0x10)
		{
//			FNSend.m_byCID = 0x3;
//			pData[0] = CW(0xd000);
//			pData[1] = CW(wSize*2+1);
//			m_DLService.SetEchoLen(5+2*(wSize*2+1));
//			if (m_DLService.REQ(1,&FNSend,FNRecv,0,true) == 1)//Send - Respond
//			{
//				if (FNRecv.m_byCID == 0x3)
//				{
					bRet = true;
//				}
//			}
		}
	}
	
	pthread_mutex_unlock(&m_mutex);
	return bRet;
}

bool CSepam1000Mas::GetYX(BYTE byAddr,BYTE byType)
{
	bool bConnect = false;
	pthread_mutex_lock(&m_mutex);
	CFrameNode FNSend,FNRecv;
	FNSend.m_byCID = 0x4;
	FNSend.m_byDesAddr = byAddr;
	FNSend.SetSize(4);

	WORD* pData = (WORD *)FNSend.m_pbyData;
	pData[0] = CW(0x100);
	if (byType == dt_eSEPAM20)
	{
		pData[1] = CW(6);
		m_DLService.SetEchoLen(5+6*2);
	}
	else
	{
		pData[1] = CW(12);
		m_DLService.SetEchoLen(5+12*2);
	}
//	WORD wDevNo = m_subdevmgr.GetDevNoFrmAddr(FNSend.m_byDesAddr );
	if (m_DLService.REQ(1,&FNSend,FNRecv,0,true) == 1)//Send - Respond
	{
		bConnect = true;
		ExpYXData(FNRecv.m_bySrcAddr,FNRecv.m_pbyData,FNRecv.m_wSize,0);
	}
			
	pthread_mutex_unlock(&m_mutex);
       return bConnect;
}

bool CSepam1000Mas::GetYC(BYTE byAddr,BYTE byType)
{
	bool bConnect = false;
	pthread_mutex_lock(&m_mutex);
	CFrameNode FNSend,FNRecv;
	FNSend.m_byCID = 0x4;
	FNSend.m_byDesAddr = byAddr;
	FNSend.SetSize(4);

	WORD* pData = (WORD *)FNSend.m_pbyData;
	
	if (byType == dt_eSEPAM20)
	{
		pData[0] = CW(0x106);
		pData[1] = CW(7);
		m_DLService.SetEchoLen(5+7*2);
	}
	else
	{
		pData[0] = CW(0x113);
		pData[1] = CW(35);
		m_DLService.SetEchoLen(5+35*2);
	}
	
//	WORD wDevNo = m_subdevmgr.GetDevNoFrmAddr(FNSend.m_byDesAddr );
	if (m_DLService.REQ(1,&FNSend,FNRecv,0,true) == 1)//Send - Respond
	{
		bConnect = true;
		ExpYCData(FNRecv.m_bySrcAddr,FNRecv.m_pbyData,FNRecv.m_wSize);
	}
	pthread_mutex_unlock(&m_mutex);
       return bConnect;
}

bool CSepam1000Mas::GetEvent(BYTE byAddr,BYTE byType)
{
	bool bConnect = false;
	pthread_mutex_lock(&m_mutex);
	CFrameNode FNSend,FNRecv;
	FNSend.m_byCID = 0x3;
	FNSend.m_byDesAddr = byAddr;
	FNSend.SetSize(4);

	WORD* pData = (WORD *)FNSend.m_pbyData;
	pData[0] = CW(0x40);
	pData[1] = CW(0x21);

	m_DLService.SetEchoLen(5+0x21*2);

	if (m_DLService.REQ(1,&FNSend,FNRecv,0,true) == 1)//Send - Respond
	{
		bConnect = true;
		ExpEventData(FNRecv.m_bySrcAddr,FNRecv.m_pbyData,FNRecv.m_wSize);
		//确定并清除
		BYTE byExchanged = FNRecv.m_pbyData[1];
		BYTE byCount = FNRecv.m_pbyData[2];
		if (byCount > 0)
		{
			usleep(100000);
			CFrameNode FNSend1,FNRecv1;
			FNSend1.m_byCID = 0x6; //
			FNSend1.m_byDesAddr = byAddr;
			FNSend1.SetSize(4);
			pData = (WORD *)FNSend1.m_pbyData;
			pData[0] = CW(0x40);
			pData[1] = byExchanged;
			m_DLService.SetEchoLen(8);
			if (m_DLService.REQ(1,&FNSend1,FNRecv1,0,true) == 1)//Send - Respond
			{
			}
		}
	}
	pthread_mutex_unlock(&m_mutex);
	return bConnect;
}

void CSepam1000Mas::ExpYCData(BYTE byAddr,BYTE* pbyData,BYTE bySize)
{
	BYTE* pbyTemp = pbyData + 1;
	
	WORD wDevNo = m_subdevmgr.GetDevNoFrmAddr(byAddr);
	YCData* pData = new YCData [bySize/2];
	WORD* pwOrigValue = (WORD *)pbyTemp;
	WORD w1 = 0;
	for (WORD w=0; w<bySize/2; w++)
	{
		pData[w1].m_wDevNo = wDevNo;
		pData[w1].m_wDevPtNo = w1+1;
		float ffValue;
		if  ((w >= 21) && (w <= 26))
		{
			WORD wValue = CW(*pwOrigValue++);
			short* pShort = (short *)&wValue;
			ffValue = *pShort;
		}
		else if (w> 26)
		{
			DWORD* pdwOrigValue = (DWORD *)pwOrigValue++;
			DWORD dwValue = CDW(*pdwOrigValue);
			ffValue = dwValue;
			pwOrigValue++;
			w++;
		}
		else ffValue = CW(*pwOrigValue++);
		pData[w1++].m_fValue = ffValue;
	}
	m_pAllMgr->YC(pData, w1);
	delete pData;
}

void CSepam1000Mas::ExpYXData(BYTE byAddr,BYTE* pbyData,BYTE bySize,BYTE byOrder)
{
	if ((pbyData == NULL) || (bySize < 2)) return;
	BYTE* pbyTemp = pbyData+1;

	WORD* pw = (WORD *)pbyTemp;
	for (BYTE b=0; b<bySize/2;b++)
		*pw++ = CW(*pw);

	YXData* pYXData = new YXData [(bySize-1)*8];
	WORD wDevNo = m_subdevmgr.GetDevNoFrmAddr(byAddr);
	for (BYTE by=0; by<(bySize-1); by++)
	{
		BYTE byA = 1;
		BYTE byValue = *pbyTemp++;
		for (BYTE b=0; b<8; b++,byA<<=1)
		{
			pYXData[b+8*by].m_wDevNo = wDevNo;
			pYXData[b+8*by].m_bValue = bool(byValue & byA)?0xff00:0xff;
		}
	}
	
	m_pAllMgr->YX(pYXData, (bySize-1)*8);
	delete [] pYXData;
}


void CSepam1000Mas::ExpEventData(BYTE byAddr,BYTE* pbyData,BYTE bySize)
{
	BYTE byEventCount;
	m_byExchanged = pbyData[1];
	byEventCount = pbyData[2];

	WORD* pw = (WORD *)&pbyData[3];

	WORD wDevNo = m_subdevmgr.GetDevNoFrmAddr(byAddr);
	for (BYTE b=0; b<byEventCount; b++)
	{
		struct tm gt;
		gt.tm_year = CW(*(pw + 4 + 8*b));
		if (gt.tm_year<50) gt.tm_year += 100;
		gt.tm_mon = ((CW(*(pw + 5 + 8*b)) & 0xff00) >> 8) - 1;
		gt.tm_mday = CW(*(pw + 5 + 8*b)) & 0xff;
		gt.tm_hour = (CW(*(pw + 6 + 8*b)) & 0xff00) >> 8;
		gt.tm_min = CW(*(pw + 6 + 8*b)) & 0xff;
		gt.tm_sec = CW(*(pw + 7 + 8*b)) /1000;
		CTimeVal tvg(&gt,(CW(*(pw + 7 + 8*b)) % 1000)*1000);

		WORD wEventAddr = CW(*(pw + 1 + 8*b));

		wEventAddr = wEventAddr - 0x1000+1;
		SOEData aSOEData;
		aSOEData.m_ctv = tvg;
		aSOEData.m_bValue = (*(pw + 3 + 8*b) == 0) ?0xff:0xff00;
		aSOEData.m_wDevNo = wDevNo;
		aSOEData.m_wDevPtNo = wEventAddr;
		SendSOEData(&aSOEData,1);
	}
}