taas.cpp

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

#include "msystem.h"
#include "taas.h"
//#include "math.h"
#include "allmgr.h"

void* TAMaster(void *pVoid)//Period and Cycle for PRM=1; Wait IND for PRM=0
{
	CTAAS *pAS = (CTAAS *)pVoid;
	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
	while (1) {
		pAS->Run();
//		usleep(10000);
	}
}

////////////////////////////////////////////////////////////////////
CTAAS::CTAAS(CAllMgr* pAllMgr,bool bBalance,BYTE byMaxReportTimes,CSerialPortDef* pChannel)
	: CMAppService(pAllMgr,bBalance,pChannel->m_wChannelNo)
	, m_DLService(pChannel)
{
	m_bySendOrder = 0;
	m_tmRectify.GetCurrentTime();
	m_tmRectify += CTimeValSpan(0,0,-2,0);
//	for (BYTE b=0; b<18; b++) m_BreakNo[b]=0;
	m_bySendNo = 0;
	m_hThread = 0;
}

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

bool CTAAS::YK(WORD wDevNo,BYTE byRoute,bool bIsOn)
{
	bool bRet = false;
	CFrameNode FNSend;
	CFrameNode FNRecv;
	pthread_mutex_lock(&m_mutex);
	if (Select(wDevNo,byRoute,bIsOn,FNSend) > 0)
	{
		if (m_DLService.REQ(1,&FNSend,FNRecv,0,true) == 1)
		{//Send - Respond
			if ((FNRecv.m_byCID == 0x6) && (FNRecv.m_wSize == 0))
			{
				CFrameNode FNSend1;
				CFrameNode FNRecv1;
				if (Operate(wDevNo,byRoute,bIsOn,FNSend1) > 0)
				{
					if (m_DLService.REQ(1,&FNSend1,FNRecv1,0,true) == 1)
					{
						if ((FNRecv1.m_byCID == 0x6) && (FNRecv1.m_wSize == 0))
							bRet = true;
					}
				}
			}
		}
	}
	pthread_mutex_unlock(&m_mutex);
	return bRet;
}

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

void CTAAS::Run()
{
	while (m_DLService.Status() != 0)
		sleep(1);
	CFrameNode FNSend;
	CFrameNode FNRecv;
	int nEcho = GetPeriod(FNSend);
	pthread_mutex_lock(&m_mutex);
	//nEcho=0:Send no reply;=1:Send - Respond;=-1:No send;
	if ((nEcho!=-1) && (m_DLService.REQ((BYTE) nEcho,&FNSend,FNRecv,(BYTE) 0,true) == 1))
	{
		ExplainRESP(&FNRecv);
	}
	pthread_mutex_unlock(&m_mutex);
}

/////////////////////TA////////////////////////////////////////////
int CTAAS::GetPeriod(CFrameNode& fn) //-1:failure;0:no echo; 1:have echo
{
	while (!m_subdevmgr.HasOn()) sleep(1);
	int nRet = -1;
	CTimeVal tmCurrent;
	CTimeValSpan tvs = tmCurrent - m_tmRectify;
	if (tvs.GetMinute() >= 1)
	{
		m_tmRectify = tmCurrent;
		RectifyTime(fn);
		nRet = 0;
	}
	else
	{
		if((m_bySendOrder > 1) || (m_bySendNo == 0xff))
		{
			m_bySendOrder = 0;
			m_bySendNo = m_subdevmgr.GetNextNo(m_bySendNo);
		}
		m_byAddr = m_subdevmgr.GetAddrFrmNo(m_bySendNo);
		if (m_byAddr == 0xff) return 0;
		switch(m_bySendOrder++%2)
		{
		case 0:
			nRet = 1;
			GetYC(m_byAddr,fn);
			break;
		case 1:
			nRet = 1;
			GetYXSOE(m_byAddr,fn);
			break;
		default:
			break;
		}
	}
	return nRet;
}

int CTAAS::ExplainRESP(CFrameNode* pFNRecv)
{
	bool bRet = false;
	BYTE* pbyData = pFNRecv->m_pbyData;
	BYTE bySize = (BYTE) pFNRecv->m_wSize;
	if (pbyData && bySize)
	{
		BYTE byAddr = pFNRecv->m_bySrcAddr;
		switch (pFNRecv->m_byCID)
		{
		case 0x12:
			ExpYXSOE(byAddr,pbyData,bySize);
			break;
		case 0x14:
			ExpTARYC(byAddr,pbyData,bySize);
			break;
		default:
			break;
		}
	}
	return bRet;
}
/*
int CTAAS::Read(WORD wDevNo,CFrameNode& fn)
{
	int nRet = -1;
	return nRet;
}

int CTAAS::Write(WORD wDevNo,FVData* pData,WORD wCount,CFrameNode& fn)
{
	int nRet = -1;
	return nRet;
}
*/
int CTAAS::Select(WORD wDevNo,BYTE byRoute,bool bIsOn,CFrameNode &FNSend)
{
	int nRet = -1;
	CSubdev* pDev = NULL;
	if ((pDev = m_subdevmgr.GetDevFrmDevNo(wDevNo)) != NULL)
	{
		nRet = 1;
		FNSend.m_byDesAddr = pDev->m_byAddr;
		FNSend.SetSize(3);
		FNSend.m_pbyData[0] = 0;
		FNSend.m_pbyData[1] = 1<<((byRoute-1)*2+(bIsOn?1:0));
		FNSend.m_pbyData[2] = FNSend.m_pbyData[1];
		FNSend.m_byCID = 0x19;
	}
	return nRet;
}

int CTAAS::Operate(WORD wDevNo,BYTE byRoute,bool bIsOn,CFrameNode &FNSend)
{
	int nRet = -1;
	CSubdev* pDev = NULL;
	if ((pDev = m_subdevmgr.GetDevFrmDevNo(wDevNo)) != NULL)
	{
		nRet = 1;
		FNSend.m_byDesAddr = pDev->m_byAddr;
		FNSend.SetSize(3);
		FNSend.m_pbyData[0] = 0xff;
		FNSend.m_pbyData[1] = 1<<((byRoute-1)*2+(bIsOn?1:0));
		FNSend.m_pbyData[2] = FNSend.m_pbyData[1];
		FNSend.m_byCID = 0x19;
	}
	return nRet;
}

bool CTAAS::GetYC(BYTE byAddr,CFrameNode& fn)
{
	fn.m_byDesAddr = byAddr;
	fn.m_byCID = 0x14;
	fn.m_wSize = 0;
	return true;
}

bool CTAAS::GetYXSOE(BYTE byAddr,CFrameNode& fn)
{
	fn.m_byDesAddr = byAddr;
	fn.m_byCID = 0x12;
	fn.m_wSize = 0;
	return true;
}

void CTAAS::RectifyTime(CFrameNode& fn)
{
	fn.m_byDesAddr = 0xff;
	fn.m_byCID = 0x5;
	fn.m_wSize = 7;
	CTimeVal ctv;
	struct tm st;
	ctv.GetTime(&st);
	BYTE* pbyTemp = fn.m_pbyData;
	*pbyTemp++ = st.tm_year%100;
	*pbyTemp++ = st.tm_mon +1;
	*pbyTemp++ = st.tm_mday;
	*pbyTemp++ = st.tm_hour;
	*pbyTemp++ = st.tm_min;
	WORD* pw = (WORD *)pbyTemp;
	WORD w = ctv.GetMilliSecs()+st.tm_sec *1000;
	*pw = ((w & 0xff) << 8) | ((w&0xff00) >>8);
}

void CTAAS::ExpYXSOE(BYTE byAddr,BYTE* pbyData,BYTE bySize)
{
	BYTE* pbyTemp = pbyData;
	if (pbyTemp && (bySize >= 2))
	{
		WORD wDevNo = m_subdevmgr.GetDevNoFrmAddr(byAddr);
		SendYXData(wDevNo,pbyTemp,2);
		for (BYTE bbb=0; bbb<(bySize-2)/8; bbb++)
		{
			pbyTemp += bbb*8 + 2;
			WORD wv = *(WORD *)(&pbyTemp[0]);
			WORD wv1 = *(WORD *)(&pbyTemp[2]);
			for (int j=0,k=0x01;j<16;j++,k<<=1)
			{
				if (wv&k) //定位SOE
				{
					struct tm gt;
					WORD wMilliSecs = *(WORD *)(&pbyTemp[4]);
					gt.tm_sec = wMilliSecs / 1000;
					wMilliSecs = wMilliSecs % 1000;
					gt.tm_min = pbyTemp[6] & 0x3F;
					gt.tm_hour = pbyTemp[7] & 0x1F;
					CTimeVal tvCurrent;
					struct tm ct;
					tvCurrent.GetTime(&ct);
					gt.tm_mon = ct.tm_mon;
					gt.tm_mday = ct.tm_mday;
					gt.tm_year = ct.tm_year;
					CTimeVal tvg(&gt,wMilliSecs*1000);
					if (tvg > tvCurrent)
						tvg += CTimeValSpan(-1,0,0,0,0);
					cout <<	gt.tm_year<<"/"<<gt.tm_mon<<"/"<<gt.tm_mday<<"  "<<gt.tm_hour<<":"<<gt.tm_min<<":"<<gt.tm_sec<<"."<<wMilliSecs<<endl;
					SOEData aSOEData;
					aSOEData.m_ctv = tvg;
					aSOEData.m_bValue = (wv1&k)?false:true;
					aSOEData.m_wDevNo = wDevNo;
					aSOEData.m_wDevPtNo = j+1;
					SendSOEData(&aSOEData,1);
				}
			}
		}
	}
}

void CTAAS::ExpTARYC(BYTE byAddr, BYTE *pbyData, BYTE bySize)
{
	BYTE byType = m_subdevmgr.GetTypeFrmAddr(byAddr);
	switch (byType)//设备型号
	{
	case dt_eTAR200A:
		ExpTAR200AYC(byAddr, pbyData, bySize);
		break;
	case dt_eTAR200C:
		ExpTAR200CYC(byAddr, pbyData, bySize);
		break;
	case dt_eTAR200DC:
		ExpTAR200DCYC(byAddr, pbyData, bySize);
		break;
	default:
		break;
	}
}

void CTAAS::ExpTAR200CYC(BYTE byAddr, BYTE *pbyData, BYTE bySize)
{
	WORD wDevNo = m_subdevmgr.GetDevNoFrmAddr(byAddr);
	YCData* pData = new YCData [bySize/2];
	short* pshOrigValue = (short *)pbyData;
	for (WORD w=0; w<bySize/2; w++,pshOrigValue++)
	{
		pData[w].m_wDevNo = wDevNo;
		pData[w].m_wDevPtNo = w+1;
		if (w < 2)
			pData[w].m_fValue = (float)(*pshOrigValue)*120/0x7fff;
		else if (w < 8)
			pData[w].m_fValue = (float)(*pshOrigValue)*6/0x7fff;
		else if (w < 14)
			pData[w].m_fValue = (float)(*pshOrigValue)*1440/0x7fff;
		else pData[w].m_fValue = (float)1/(*pshOrigValue)*50*20000;
	}
	m_pAllMgr->YC(pData,(WORD)bySize/2);
	delete pData;
}

void CTAAS::ExpTAR200AYC(BYTE byAddr, BYTE *pbyData, BYTE bySize)
{
	WORD wDevNo = m_subdevmgr.GetDevNoFrmAddr(byAddr);
	YCData* pData = new YCData [bySize/2];
	WORD* pwOrigValue = (WORD *)pbyData;
	for (WORD w=0; w<bySize/2; w++,pwOrigValue++)
	{
		pData[w].m_wDevNo = wDevNo;
		pData[w].m_wDevPtNo = w+1;
		if (w < 4)
			pData[w].m_fValue = ConvertU(*pwOrigValue);
		else if (w < 8)
			pData[w].m_fValue = ConvertI(*pwOrigValue);
		else if (w<10)
			pData[w].m_fValue = ConvertP(*pwOrigValue);
		else pData[w].m_fValue = ConvertF(*pwOrigValue);
	}
	m_pAllMgr->YC(pData,(WORD)bySize/2);
	delete pData;
}

void CTAAS::ExpTAR200DCYC(BYTE byAddr, BYTE *pbyData, BYTE bySize)
{
	WORD wDevNo = m_subdevmgr.GetDevNoFrmAddr(byAddr);
	YCData* pData = new YCData [bySize/2];
	short* pshOrigValue = (short *)pbyData;
	for (WORD w=0; w<bySize/2; w++,pshOrigValue++)
	{
		pData[w].m_wDevNo = wDevNo;
		pData[w].m_wDevPtNo = w+1;
		if (w < 3)
			pData[w].m_fValue = (float)(*pshOrigValue)*300/0x7fff;
		else if (w < 5)
			pData[w].m_fValue = (float)(*pshOrigValue)*150/0x7fff;
		else
			pData[w].m_fValue = (float)(*pshOrigValue)*300/0x7fff;
	}
	m_pAllMgr->YC(pData,(WORD)bySize/2);
	delete pData;
}