103device.cpp

为电力系统开发保护设备装置通讯的源代码 采用串口通讯, ret hat 9下 QT开发

#include "103Device.h"
#include <qdatetime.h>
#include <time.h>
#include <qstringlist.h> 
#include <unistd.h>
#include <sys/types.h>
#include <qcstring.h> 
#include <qdir.h>

extern CPublicClass g_PublicClass;

CCommonMutex C103Device::mutex;
C103Device::C103Device(st_deviceinfo DevInfo)
{
	 memcpy(&m_DevInfo, &DevInfo, sizeof(st_deviceinfo));
	 m_bSendState3 = true;
	 m_bSendState0 = true;
	 m_bHaveL1UserData = false;
	 m_bSwitch = false;
	 
	 m_FrameHead = 0x00;
	 m_FrameLength = 0x00;
	 m_ReceAddress = 0x00;
	 m_FrameCS = 0x00;
	 m_FrameEnd = 0x00;
	 m_iThreadId = 0;
	 
	 m_iHaveWaveFile = 0;
	 memset(&m_CmdInfo, 0x00, sizeof(st_nodeinfo));
	 m_CmdInfo.m_MachineNo = m_DevInfo.m_EquipNo;
	 
	 m_szMCastIP = "";
	 m_iMCastPort = 0;
	 m_iMCastSocket = -1;
	 m_iUDPSocket = -1;
	 m_iUDPPort = 0;
	 m_szUDPIP = "";
	 m_bUDPError =  true;
	 m_bMCastError = true;
	 
	 m_szConFile = g_PublicClass.GetWorkPath()+"/devconfig/"+m_DevInfo.m_MachineType+".xml";
}

C103Device::~C103Device()
{
	 m_ReceData.SetSize(0);
	 m_CommParam.clear();
}

void C103Device::Debug(string msg, int black/* = b_black*/, int front/* = f_green*/)
{
 	if (DEBUG)
 	{
 		mutex.Lock();
 		int b = 0, f = 0;
	 	switch(black)
		{
			case b_black :
				b = 40;
				break;
			default :
				b = 40;
				break;
		}
		switch(front)
		{
			case f_green :
				f = 32;
				break;
			default :
				f = 32;
				break;
		}
		char buf[1024];
		memset(buf, 0x00, sizeof(buf));
		sprintf(buf, "************************************%s***********************************", msg.c_str());
		string temp(buf);
 		printf("%s\n", temp.c_str());
 		mutex.Unlock();
 	}
}

int C103Device::SelectSocket(int socket, fd_set *readfds, fd_set *writefds, fd_set *exceptfds)
{
	struct timeval timeout = {10, 0};
	if (readfds != NULL)
	{
		FD_ZERO(readfds);  
	        FD_SET(socket, readfds);
		switch (select(socket+1, readfds, NULL, NULL, &timeout)) 
	        {  
	                case -1:
	                	{ 
	                		if (errno!=EINVAL && errno!=EAGAIN && errno!=EINTR) return -1;
	                	}
	                	break;
	                case 0:
	                        break; 
	                default:  
	                        if (FD_ISSET(socket, readfds)) 
	                        {  
	                        	return 1;
	                        }
	                        break;  
	        }  
	}
	if (writefds != NULL)
	{
	        FD_ZERO(writefds);  
	        FD_SET(socket, writefds);
	        switch (select(socket+1, NULL, writefds, NULL, &timeout)) 
	        {  
	                case -1:  
	                        {  
	                        	if (errno!=EINVAL && errno!=EAGAIN && errno!=EINTR) return -1;
	                	}
	                	break;
	                case 0:
	                        break; 
	                default:  
	                        if (FD_ISSET(socket, writefds)) 
	                        {  
	                        	return 1;
	                        } 
	                        break; 
	        }  
	}
	if (exceptfds != NULL)
	{
	        FD_ZERO(exceptfds);  
	        FD_SET(socket, exceptfds);
	        switch (select(socket+1, NULL, NULL, exceptfds, &timeout)) 
	        {  
	                case -1:  
	                        {  
	                        	if (errno!=EINVAL && errno!=EAGAIN && errno!=EINTR) return -1;
	                	}
	                	break;  
	                case 0:
	                        break; 
	                default:  
	                        if (FD_ISSET(socket, exceptfds)) 
	                        {  
	                        	return 1;
	                        }
	                        break;
	        }  
	}
	
	return 0;
}

bool C103Device::CreateMCastSocket(const char *ip, const int port)
{
	struct sockaddr_in local;
	local.sin_addr.s_addr = INADDR_ANY;
	local.sin_family = AF_INET;
	local.sin_port= htons(port);
	m_iMCastSocket = socket(AF_INET,SOCK_DGRAM,0);
	if (m_iMCastSocket < 0)
	{ 
		return false;
	}
	int sock_reuse=1;
	int ret = setsockopt(m_iMCastSocket, SOL_SOCKET, SO_REUSEADDR, \
		       (char *)&sock_reuse, sizeof(sock_reuse));
	if (ret < 0) 
	{
		close(m_iMCastSocket);
		return false;
    	}
    	
	int iRouteNum=1;
    	ret = setsockopt(m_iMCastSocket,IPPROTO_IP,IP_MULTICAST_TTL,\
			(char*)&iRouteNum,sizeof(int));
	if(ret < 0)
	{
		close(m_iMCastSocket);
		return false;
	}
	 
	int LoopBack=1;
	ret = setsockopt(m_iMCastSocket,IPPROTO_IP,IP_MULTICAST_LOOP,\
			(char*)&LoopBack,sizeof(int));
	if(ret < 0)
	{
		close(m_iMCastSocket);
		return false;
	}
	
	ret = bind(m_iMCastSocket,(sockaddr*)&(local),sizeof(local));
	if (ret < 0)
	{
		close(m_iMCastSocket);
		return false;
	}
	
	struct ip_mreq mcast;
	mcast.imr_interface.s_addr = INADDR_ANY;
	mcast.imr_multiaddr.s_addr = inet_addr (ip);
	ret = setsockopt(m_iMCastSocket,IPPROTO_IP,IP_ADD_MEMBERSHIP,\
		       (char*)&(mcast),sizeof(mcast));
	if (ret < 0)
	{
		close(m_iMCastSocket);
		return -1;
	}
	return true;
}

int C103Device::RecvMCastData(unsigned char *data, int &size)
{
	if (size == 0) return 0;
	struct sockaddr_in client;
	int ret = 0, len = sizeof(client);
	fd_set rfd;
	if ( (ret=SelectSocket(m_iMCastSocket, &rfd, NULL, NULL)) < 0 ) return ret;
	
	int total = 0, times = 0;
	while(total<size && times++<3)
	{
		ret = recvfrom(m_iMCastSocket,data+total,size-total,\
					0,(struct sockaddr*)&client,(socklen_t *)&len);
		if(ret < 0)//socket error?????? catch truth socket error
		{
			if (errno!=EINVAL && errno!=EAGAIN && errno!=EINTR) return -1;
			return total;
		}
		total += ret;
		usleep(times*100);
	}
	return total;
}

int C103Device::SendMCastData(const char *ip, const int port, unsigned char *data, int size)
{//don't apply
	struct sockaddr_in remote;
	remote.sin_addr.s_addr = inet_addr(ip);
	remote.sin_family = AF_INET ;
	remote.sin_port = htons(port);
	int ret = 0, len =sizeof(remote);
	fd_set wfd;
	if ( (ret=SelectSocket(m_iMCastSocket, NULL, &wfd, NULL)) < 0 ) return ret;	
	
	ret = sendto(m_iMCastSocket, data, size, 0,(sockaddr*)&remote, len);
	if(ret < 0)//socket error????? catch truth socket error
	{
		if (errno!=EINVAL && errno!=EAGAIN && errno!=EINTR) return -1;
		return 0;
	} 
	return ret;
}

bool C103Device::CreateUDPSocket(const char *ip, const int port)
{
	m_iUDPSocket = socket(AF_INET,SOCK_DGRAM,0);
	if (m_iUDPSocket < 0)
	{ 
		return false;
	}
	return true;
}

int C103Device::SendUDPData(const char *ip, const int port, unsigned char *data, int size)
{
	struct sockaddr_in remote;
	remote.sin_addr.s_addr = inet_addr(ip);
	remote.sin_family = AF_INET ;
	remote.sin_port = htons(port);
	int ret = 0, len =sizeof(remote);
	fd_set wfd;
	if ( (ret=SelectSocket(m_iMCastSocket, NULL, &wfd, NULL)) < 0 ) return ret;
	
	int total = 0, times = 0;
	while(total<size && times++<3)
	{
		ret = sendto(m_iUDPSocket, data+total, size-total, 0,(sockaddr*)&remote, len);
		if(ret < 0)//socket error????? catch truth socket error
		{
			if (errno!=EINVAL && errno!=EAGAIN && errno!=EINTR) return -1;
			return total;
		}
		total += ret;
		usleep(times*100);
	} 
	return total;
}

bool C103Device::InitSocket()
{
	char buf[100];
	if (m_iMCastSocket <= -1)
	{
		if (!CreateMCastSocket(m_szMCastIP.c_str(), m_iMCastPort)) 
		{
			Debug("Create MCast Socket Error");
			return false;
		}
		memset(buf, 0x00, sizeof(buf));
		sprintf(buf, "Create MCast Socket is %d", m_iMCastSocket);
		Debug(string(buf));
		m_bMCastError = false;
	}
	if (m_iUDPSocket <= -1)
	{
		if (!CreateUDPSocket(m_szUDPIP.c_str(), m_iUDPPort))
		{
			Debug("Create UDP Socket Error");
			ReleaseSocket();
			m_bMCastError = true;
			return false;
		}
		memset(buf, 0x00, sizeof(buf));
		sprintf(buf, "Create UDP Socket is %d", m_iUDPSocket);
		Debug(string(buf));
		m_bUDPError = false;
	}
	return true;
}


bool C103Device::ReleaseSocket()
{
	if (m_iMCastSocket >= 0) 
	{
		close(m_iMCastSocket);
		m_iMCastSocket = -1;
	}
	if (m_iUDPSocket >= 0) 
	{
		close(m_iUDPSocket);
		m_iUDPSocket = -1;
	}
	return true;
}

bool C103Device::IsCommError()
{
	if (m_bUDPError||m_bMCastError)
	{
		return true;
	}
	return false;
}

bool C103Device::CloseSocket()
{
	if (m_bMCastError)
	{
		if (m_iMCastSocket >= 0) 
		{
			close(m_iMCastSocket);
		}
		m_iMCastSocket = -1;
	}
	if (m_bUDPError)
	{	
		if (m_iUDPSocket >= 0) 
		{
			close(m_iUDPSocket);
		}
		m_iUDPSocket = -1;
	}
	return true;
}
bool C103Device::CheckComm()
{
	if (IsCommError())
	{
		(*it).bInit = false;
		CloseSocket();
		return (InitSocket() && ResetCU());
	}
	return true;
}

bool C103Device::SendViewData(CByteArray &Data, unsigned int Flag)
{
	if (g_PublicClass.m_MonitorData.m_MachineNo == (int)m_DevInfo.m_EquipNo)//閫佺粰鑷