allmgr.cpp

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

#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <linux/if.h>

#include "allmgr.h"

////////////////////////////////////////////////////////////////
void CAnalogs::Load()
{
	xbXBase	x;
	CYCSet	setYC(&x);
	if (setYC.Open())
	{
		if (setYC.GetFirst())
		{
			do {
				CAnalog a(setYC.m_wDevNo,setYC.m_wLocalNo,setYC.m_fCoef);
				m_vAnalog.push_back(a);
//				cout << "YCNo: " << a.GetYCNo() << endl;
			} while (setYC.GetNext());
		}
		setYC.Close();
	}
	sort(m_vAnalog.begin(),m_vAnalog.end());
//	cout << "YCNum: " << m_vAnalog.size() << endl;
}

void CDigitals::Load()
{
	xbXBase	x;
	CYXSet	setYX(&x);
	if (setYX.Open())
	{
		if (setYX.GetFirst())
		{
			do {
				CDigital d(setYX.m_wDevNo,setYX.m_wLocalNo,setYX.m_bNOT);
				m_vDigital.push_back(d);
//				cout << "YXNo: " << d.GetYXNo() << endl;
			} while (setYX.GetNext());
		}
		setYX.Close();
	}
	sort(m_vDigital.begin(),m_vDigital.end());
//	cout << "YXNum: " << m_vDigital.size() << endl;
}

void* Monitor(void *pVoid)
{
	CAllMgr *pAllMgr = (CAllMgr *)pVoid;
	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
	
	bool bDog = false;
	CTimeVal tmInit;

	while (true)
	{
		pAllMgr->Run();

		CTimeVal tv;
		CTimeValSpan tvs = tv - tmInit;
		
		if (bDog)
		{
			if (pAllMgr->AllThreadOK())
				pAllMgr->m_wdog.Flush();
		}
		else
		{
			if (tvs.GetASecs() > 120)
			{
//				pAllMgr->m_wdog.Open();
				bDog = true;
			}
		}
		
#ifdef _BACK
		if ((pAllMgr->m_pMonitorSvr == NULL) && (tvs.GetASecs() > 10))
		{		
			pAllMgr->m_pMonitorSvr = new CModbusTCPSlave(pAllMgr);
			pAllMgr->m_pMonitorSvr->Init();
		}
#endif
	}
}

bool CAllMgr::AllThreadOK()
{
	bool bRet = true;
/*	if (m_pMonitorSvr && m_pMonitorSvr->IsRun())
	{
		vector<CMAppService* >::iterator it1 = m_listMaster.begin();
		while (it1 != m_listMaster.end())
		{
			if (!(*it1)->IsRun())
			{
				bRet = false;
				break;
			}
			it1++;
		}
	}
	else bRet = false;*/
	return bRet;
}

bool CAllMgr::Init()
{
	bool bRet = false;
//	m_bLicenseIsOk = LicenseIsOk();
	m_bLicenseIsOk = true;
	
#ifdef _BACK
	m_pMonitor = new CMonitorTCPSlave(this);
	m_pMonitor->Init();
#endif

	pthread_attr_t attr;
	pthread_attr_init(&attr);
	pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
	if (pthread_create(&m_hThread,&attr,Monitor,(void *)this) == 0)
	{
		bRet = true;
	}
	else	m_hThread = 0;
	pthread_attr_destroy(&attr);
	return bRet;
}	

bool CAllMgr::LicenseIsOk()
{
	static u_char addr1[6] = {0x0,0xd0,0xc9,0x42,0x89,0x07}; //木讷-南京
//	static u_char addr1[6] = {0x0,0x0b,0xab,0x09,0x8e,0x26}; //派诺-DEMO
	u_char addr[6];
	bool bRet = false;
/* implementation for Linux */
    struct ifreq ifr;
    struct ifreq *IFR;
    struct ifconf ifc;
    char buf[1024];
    int s, i;
    int ok = 0;

    s = socket(AF_INET, SOCK_DGRAM, 0);
    if (s==-1) {
        return bRet;
    }

    ifc.ifc_len = sizeof(buf);
    ifc.ifc_buf = buf;
    ioctl(s, SIOCGIFCONF, &ifc);
 
    IFR = ifc.ifc_req;
    for (i = ifc.ifc_len / sizeof(struct ifreq); --i >= 0; IFR++) 
    {
        strcpy(ifr.ifr_name, IFR->ifr_name);
        if (ioctl(s, SIOCGIFFLAGS, &ifr) == 0) 
        {
            if (! (ifr.ifr_flags & IFF_LOOPBACK)) 
            {
                if (ioctl(s, SIOCGIFHWADDR, &ifr) == 0) 
                {
                    ok = 1;
                    break;
                }
            }
        }
    }

    close(s);
    if (ok) 
    {
        bcopy( ifr.ifr_hwaddr.sa_data, addr, 6);
        if (memcmp(addr,addr1,6) == 0)
        	bRet = true; 
   	}
    return bRet;

/* Not implemented platforms */
        return -1;
}



void CAllMgr::Run()
{
	bool bSleep = false;
#ifdef _DEMO
//	CTimeVal tv;
//	CTimeValSpan tvs = tv - m_tmInit;
//	if (tvs.GetASecs() < 72000)
//		m_bLicenseIsOk = true;
//	else m_bLicenseIsOk = false;
#endif
	if (m_quYXData.size() > 0)
	{
		pthread_mutex_lock(&m_mutexYX);
		YXData YX = m_quYXData.front();
		m_quYXData.pop();
		pthread_mutex_unlock(&m_mutexYX);
//		pthread_mutex_lock(&m_mutexYX1);
		CDigital* pd = GetDigital((DWORD)YX.m_wDevNo*1000+YX.m_wDevPtNo);
		if (pd && m_bLicenseIsOk)
		{
			pd->SetValue((YX.m_bValue==0xff00)?true:false);
//			if ((YX.m_wDevNo != 3) && (YX.m_wDevNo != 4) && (YX.m_wDevNo != 6)
//				&& (YX.m_wDevNo != 11) && (YX.m_wDevNo != 19) && (YX.m_wDevNo != 20) && (YX.m_wDevNo != 24) && (YX.m_wDevNo != 25))
//				printf("{%d}{%d}\n",YX.m_wDevNo,YX.m_wDevPtNo);
//			if (!pd->GetNT())
			{
//				pd->SetNT();
//				YX.m_bValue = pd->GetValue();
				vector<CSAppService* >::iterator pSAppService= m_listSlave.begin();
				while (pSAppService != m_listSlave.end())
				{
					CSAppService* psa = *pSAppService;
					psa->YX(&YX,1);
					pSAppService++;
				}
			}
		}
	}
	else bSleep = true;
	if (m_quYCData.size() > 0)
	{
		pthread_mutex_lock(&m_mutexYC);
		YCData YC = m_quYCData.front();
		m_quYCData.pop();
		pthread_mutex_unlock(&m_mutexYC);
//		pthread_mutex_lock(&m_mutexYC1);
		CAnalog* pa = GetAnalog((DWORD)YC.m_wDevNo*1000+YC.m_wDevPtNo);
		if (pa && m_bLicenseIsOk)
		{
			pa->SetValue(YC.m_fValue);
//			if (!pa->GetNT())
			{
//				pa->SetNT();
//				YC.m_fValue = pa->GetValue();
				vector<CSAppService* >::iterator pSAppService= m_listSlave.begin();
				while (pSAppService != m_listSlave.end())
				{
					CSAppService* psa = *pSAppService;
					psa->YC(&YC,1);
					pSAppService++;
				}
			}
		}
//		pthread_mutex_unlock(&m_mutexYC1);
	}
	else if (bSleep) usleep(10000);
}

CAllMgr::CAllMgr()
{
	m_hThread = 0;
	pthread_mutex_init(&m_mutexYX,NULL);// PTHREAD_MUTEX_INITIALIZER)
	pthread_mutex_init(&m_mutexYC,NULL);// PTHREAD_MUTEX_INITIALIZER)
	#ifdef _BACK
	m_pMonitorSvr = NULL;
	m_pMonitor = NULL;
	#endif	
	try {
//		m_pMonitorSvr = new CMySal(this);
//		m_pMonitorSvr->Init();
		m_pChannelMgr = new CChannelMgr(this);
	}
	catch (CException& e){
		cout << e << endl;
	}
}

CAllMgr::~CAllMgr()
{
#ifdef _BACK
	if (m_pMonitorSvr)
		delete m_pMonitorSvr;
	if (m_pMonitor)
		delete m_pMonitor;
#endif
	CMAppService* pMAS;
	vector<CMAppService* >::iterator temp = m_listMaster.begin();
	BYTE bbb;
	for (bbb=0; bbb<m_listMaster.size();bbb++)
	{
		pMAS = *temp++;
		delete pMAS;
	}
	CSAppService* pSAS;
	vector<CSAppService* >::iterator temp1 = m_listSlave.begin();
	for (bbb=0; bbb<m_listSlave.size();bbb++)
	{
		pSAS = *temp1++;
		delete pSAS;
	}
	delete m_pChannelMgr;
	
	if (m_hThread > 0)
	{
		cout << "AllMgr: " << m_hThread << endl;
		pthread_cancel(m_hThread);
	}
	pthread_mutex_destroy(&m_mutexYC);
	pthread_mutex_destroy(&m_mutexYX);
//	pthread_mutex_destroy(&m_mutexYC1);
//	pthread_mutex_destroy(&m_mutexYX1);
}

void CAllMgr::AddMaster(CMAppService* pAS)
{
	m_listMaster.push_back(pAS);
}

void CAllMgr::AddSlave(CSAppService* pAS)
{
	m_listSlave.push_back(pAS);
}

void CAllMgr::YC(YCData* pYCValue,WORD wCount)
{
	for (WORD www=0;www<wCount;www++)
	{
		CAnalog* pa = GetAnalog((DWORD)pYCValue[www].m_wDevNo*1000+pYCValue[www].m_wDevPtNo);
		if (pa)
		{
			pthread_mutex_lock(&m_mutexYC);
			m_quYCData.push(pYCValue[www]);
			pthread_mutex_unlock(&m_mutexYC);
//			if ((( pYCValue[www].m_wDevPtNo == 28) || ( pYCValue[www].m_wDevPtNo == 1)) && (pYCValue[www].m_fValue < 100))
//				printf("\r\n[%0.2f]\r\n", pYCValue[www].m_fValue);
		}
	}	
}

void CAllMgr::YX(YXData* pYXValue,WORD wCount)
{
	for (WORD www=0;www<wCount;www++)
	{
//		if ((pYXValue[www].m_wDevPtNo != 199)&& ((pYXValue[www].m_wDevNo != 3) && (pYXValue[www].m_wDevNo != 4) && (pYXValue[www].m_wDevNo != 6)
//			&& (pYXValue[www].m_wDevNo != 11) && (pYXValue[www].m_wDevNo != 19) && (pYXValue[www].m_wDevNo != 20) && (pYXValue[www].m_wDevNo != 24) && (pYXValue[www].m_wDevNo != 25)))
//			printf("YX{%d}{%d}\n",pYXValue[www].m_wDevNo,pYXValue[www].m_wDevPtNo);
		CDigital* pd = GetDigital((DWORD)pYXValue[www].m_wDevNo*1000+pYXValue[www].m_wDevPtNo);
		if (pd)
		{
			pthread_mutex_lock(&m_mutexYX);
			m_quYXData.push(pYXValue[www]);
			pthread_mutex_unlock(&m_mutexYX);
		}
	}	
}

void CAllMgr::ProtInfo(BYTE* pBuf, WORD wSize)
{
	vector<CSAppService* >::iterator pSAppService= m_listSlave.begin();
	while (pSAppService != m_listSlave.end())
	{
		CSAppService* psa = *pSAppService++;
		psa->ProtInfo(pBuf,wSize);
	}
}

void CAllMgr::SOE(SOEData* pSOEValue,WORD wCount)
{
	vector<CSAppService* >::iterator pSAppService= m_listSlave.begin(); 
	while (pSAppService != m_listSlave.end())
	{
		CSAppService* psa = *pSAppService++;
		psa->SOE(pSOEValue,wCount);
	}
#ifdef _BACK
//	m_pMonitorSvr->AddSOE(pSOEValue,wCount);
#endif	
}

void CAllMgr::Event(WORD wDevNo,char* pszEvent)
{
#ifdef _BACK
//	m_pMonitorSvr->AddEvent(wDevNo,pszEvent);
#endif
}

void CAllMgr::DD(DDData* pDDValue,WORD wCount)
{
	vector<CSAppService* >::iterator pSAppService= m_listSlave.begin();
	while (pSAppService != m_listSlave.end())
	{
		CSAppService* psa = *pSAppService++;
		psa->DD( pDDValue,wCount);
	}
}

bool CAllMgr::YK(WORD wDevNo,WORD wAddr,bool bOn)
{
	bool bRet = false;
	CMAppService * pMAS = GetMAppService(wDevNo);
	if (pMAS)
		bRet = pMAS->YK(wDevNo,wAddr,bOn);
	return bRet;
}

bool CAllMgr::GetFV(WORD wDevNo,BYTE*& pbyData,WORD& wLength,WORD wFuncCode)
{
	bool bRet = false;
	CMAppService * pMAS = GetMAppService(wDevNo);
	if (pMAS)
		bRet = pMAS->GetFV(wDevNo,pbyData,wLength,wFuncCode);
	return bRet;
}

bool CAllMgr::PutFV(WORD wDevNo,BYTE* pbyData,WORD wLength,WORD wFuncCode)
{
	bool bRet = false;
	CMAppService * pMAS = GetMAppService(wDevNo);
	if (pMAS)
		bRet = pMAS->PutFV(wDevNo,pbyData,wLength,wFuncCode);
	return bRet;
}

void CAllMgr::RectifyTime(CTimeVal* ptv)
{
	ptv->SetTime();
}

void CMAppService::SendYCData(WORD wDevNo,double* pData,WORD wCount)
{
	YCData* pYCData = new YCData [wCount];
	for (WORD w=0; w<wCount; w++)
	{
		pYCData[w].m_wDevNo = wDevNo;
		pYCData[w].m_wDevPtNo = w + 1;
		pYCData[w].m_fValue = *pData++;
	}
	m_pAllMgr->YC(pYCData, wCount);
	delete [] pYCData;
}

void CMAppService::SendYXData(WORD wDevNo,BYTE* pData,BYTE byDSize)
{
	YXData* pYXData = new YXData [byDSize*8];
	BYTE* pbyTemp = pData;
	for (BYTE by=0; by<byDSize; 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_wDevPtNo = b+8*by + 1;
			pYXData[b+8*by].m_bValue = (byValue & byA)?0xff00:0xff;
		}
	}
	m_pAllMgr->YX(pYXData, byDSize*8);
	delete [] pYXData;
}

void CMAppService::SendDDData(WORD wDevNo,DWORD* pData,WORD wCount)
{
	DDData* pDDData = new DDData [wCount];
	for (WORD w=0; w<wCount; w++)
	{
		pDDData[w].m_wDevNo = wDevNo;
		pDDData[w].m_wDevPtNo = w + 1;
		pDDData[w].m_dwValue = *pData++;
	}
	m_pAllMgr->DD(pDDData, wCount);
	delete pDDData;
}

void CMAppService::SendSOEData(SOEData* pData,WORD wCount)
{
	m_pAllMgr->SOE(pData, wCount);
}

void CMAppService::SendFVData(WORD wDevNo,FVData* pData,WORD wCount)
{
//	m_pAllMgr->FV(wDevNo,pData, wCount);
}