pa100mas.cpp

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

#include "msystem.h"
#include "PA100Mas.h"
//#pragma pack(pop)

void* CPA100Mas::PA100Master(void *pVoid)//Period and Cycle	for	PRM=1; Wait	IND	for	PRM=0
{
	CPA100Mas *pAS =	(CPA100Mas *)pVoid;
	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
	sleep(2);
	while (1) {
		pAS->Query();
#ifndef _VIRTUAL_COMM
		usleep(50000);
#else
		usleep(10000);
#endif
	}
}

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

bool CPA100Mas::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,PA100Master,(void *)this) ==	0)
		bRet = true;
	pthread_attr_destroy(&attr);
	return bRet;
}

void CPA100Mas::Query()
{
	for (WORD w=0;w<256;w++)
	{
		if (m_wBreakCount[w] < 5)
		{
			m_dwPrev++;
			break;
		}
	}

	if (!m_subdevmgr.HasOn()) 
	{
		m_dwPrev++;
		return;
	}
//	while ((m_subdevmgr.GetNum() != 8)  && (m_subdevmgr.GetNum() != 9)) sleep(1);
	CTimeVal tmCurrent;
	CTimeValSpan tvs;
	if (tmCurrent > m_tmRectify)
		tvs = tmCurrent - m_tmRectify;
	else tvs = m_tmRectify - tmCurrent;

	if (m_bFirst ||	(tvs.GetMinute() >= 1))
	{
		m_bFirst = false;
		SyncClock();
		m_tmRectify	= tmCurrent;
	}	
	else
	{
		if((m_bySendOrder++>=1)	|| (m_bySendNo == 0xff))
		{
			m_bySendOrder =	0;
			m_bySendNo = m_subdevmgr.GetNextNo(m_bySendNo);
		}
		BYTE byAddr	= m_subdevmgr.GetAddrFrmNo(m_bySendNo);
		BYTE byType	= m_subdevmgr.GetTypeFrmAddr(byAddr);
		if (byAddr == 0xff)	return;
		GetData(byAddr,byType);

	}
}

void CPA100Mas::SyncClock(/*BYTE byAddr,BYTE byType*/)
{
	pthread_mutex_lock(&m_mutex);
	CFrameNode FNSend,FNRecv;
	FNSend.m_byCID = 0;
	FNSend.m_byDesAddr =0x7f;//byAddr; //广播地址
	FNSend.SetSize(8);

	BYTE* pbyTemp = FNSend.m_pbyData;
	CTimeVal tv;
	struct tm st;
	tv.GetTime(&st);
	*pbyTemp++ = st.tm_year-90;
	*pbyTemp++ = st.tm_mon+1;
	*pbyTemp++ = st.tm_mday;
	*pbyTemp++ = st.tm_hour;
	*pbyTemp++ = st.tm_min;
	*pbyTemp++ = st.tm_sec;
	*pbyTemp++ = tv.GetMilliSecs()%256;
	*pbyTemp = tv.GetMilliSecs()/256;

	m_DLService.REQ(0,&FNSend,FNRecv,0,false);//Send - No Respond
	
	pthread_mutex_unlock(&m_mutex);
}

bool CPA100Mas::YK(WORD wDevNo,BYTE byRoute,bool	bIsOn)
{
	bool bRet =	false;
	pthread_mutex_lock(&m_mutex);
	
	BYTE byAddr	= m_subdevmgr.GetAddrFrmDevNo(wDevNo);
	if (byAddr < 0x7f)
	{	
		CFrameNode FNSend,FNRecv;
		FNSend.m_byCID = 0x4;
		FNSend.m_byDesAddr = byAddr;
		FNSend.SetSize(5);

		BYTE* pbyTemp = FNSend.m_pbyData;
		*pbyTemp++ = byRoute;
		if (byRoute == 0)
		{
			*pbyTemp++ = 0;
			*pbyTemp++ = 0;
			*pbyTemp++ = 0;
			*pbyTemp++ = 0;
		
		}
		else if (bIsOn)
		{
			*pbyTemp++ = 0x55;
			*pbyTemp++ = 0x55;
			*pbyTemp++ = 0x55;
			*pbyTemp++ = 0x55;
		}
		else
		{
			*pbyTemp++ = 0x33;
			*pbyTemp++ = 0x33;
			*pbyTemp++ = 0x33;
			*pbyTemp++ = 0x33;
		}

		if (m_DLService.REQ(1,&FNSend,FNRecv,0,true) ==	1)//Send - Respond
		{
			if ((FNRecv.m_byCID == 0x5) && (FNRecv.m_wSize == 6))
			{
				if (FNRecv.m_pbyData[5] == 0xff) //success
				{
					CFrameNode FNSend1,FNRecv1;
					FNSend1.m_byCID = 0x5;
					FNSend1.m_byDesAddr = byAddr;
					FNSend1.SetSize(5);
			
					BYTE* pbyTemp = FNSend1.m_pbyData;
					*pbyTemp++ = byRoute;
					if (byRoute == 0)
					{
						*pbyTemp++ = 0;
						*pbyTemp++ = 0;
						*pbyTemp++ = 0;
						*pbyTemp++ = 0;
					
					}
					else if (bIsOn)
					{
						*pbyTemp++ = 0x55;
						*pbyTemp++ = 0x55;
						*pbyTemp++ = 0x55;
						*pbyTemp++ = 0x55;
					}
					else
					{
						*pbyTemp++ = 0x33;
						*pbyTemp++ = 0x33;
						*pbyTemp++ = 0x33;
						*pbyTemp++ = 0x33;
					}
					if (m_DLService.REQ(1,&FNSend1,FNRecv1,0,true) ==	1)//Send - Respond
					{
						if ((FNRecv1.m_byCID == 0x5) && (FNRecv1.m_wSize == 6))
						{
							if (FNRecv1.m_pbyData[5] == 0xff) //success
								bRet = true;
						}
					}
				}
			}
		}
	}
	pthread_mutex_unlock(&m_mutex);
	return bRet;
}

void CPA100Mas::GetData(BYTE	byAddr,BYTE	byType)
{
	pthread_mutex_lock(&m_mutex);
	CFrameNode FNSend,FNRecv;
	FNSend.m_byCID = 0x2;
	FNSend.m_byDesAddr = byAddr;
	FNSend.SetSize(1);
	WORD wDevNo	= m_subdevmgr.GetDevNoFrmAddr(byAddr);
	BYTE* pbyTemp = FNSend.m_pbyData;
	*pbyTemp = 0xff;
#ifdef _VIRTUAL_COMM
	BYTE abyVD[0x3f];
	for (WORD ww=0;ww<0x3f; ww++)
	{
			abyVD[ww] = ww;
	}
	ExpData(byAddr,abyVD,0x3f);
#else	
	if (m_DLService.REQ(1,&FNSend,FNRecv,0,true) ==	1)//Send - Respond
	{
		if (FNRecv.m_wSize == 0x3f)
			ExpData(FNRecv.m_bySrcAddr,FNRecv.m_pbyData,FNRecv.m_wSize);

		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)
		{
			m_wBreakCount[byAddr]++;
			YXData d;
			d.m_wDevNo = wDevNo;
			d.m_wDevPtNo = 199;
			d.m_bValue = 0xff00;
			m_pAllMgr->YX(&d, 1);
		}
		else if (m_wBreakCount[byAddr] < 5)
			m_wBreakCount[byAddr]++;
	}
#endif			
	pthread_mutex_unlock(&m_mutex);
}

void CPA100Mas::ExpData(BYTE byAddr,BYTE*	pbyData,WORD wSize)
{
	WORD wDevNo	= m_subdevmgr.GetDevNoFrmAddr(byAddr);
	YCData*	pData =	new	YCData [22];
	YXData*	pYXData	= new YXData [56];//8*7
	WORD w1	=0;
	BYTE* pbyTemp =	pbyData;
	
	for	(WORD w	=0;	w< 20; w++)
	{
		pData[w1].m_wDevNo = wDevNo;
		pData[w1].m_wDevPtNo = w+1;
		pData[w1++].m_fValue = CWFromBuf(pbyTemp);
	}
	
	for	(WORD w=0;	w< 2; w++)
	{
		pData[w1].m_wDevNo = wDevNo;
		pData[w1].m_wDevPtNo = w+20+1;
		pData[w1++].m_fValue = CDWFromBuf(pbyTemp);
	}
	m_pAllMgr->YC(pData,w1);
	delete [] pData;

	for	(WORD w=0; w< 7; w++)
	{
		BYTE byStatus = *pbyTemp++;
		BYTE byA = 1;
		for (BYTE b=0; b<8; b++,byA<<=1)
		{
			pYXData[w*8+b].m_wDevNo = wDevNo;
			pYXData[w*8+b].m_wDevPtNo = w*8 + b + 1;
			pYXData[w*8+b].m_bValue = (byStatus & byA)?0xff00:0xff;
		}
	
	}
	m_pAllMgr->YX(pYXData, 56);
	delete [] pYXData;
}