connect.c

泵站系统屏与屏之间的通信

		for(i=0 ; i< MAX_CLIENT ; i++)
		{	
			if(B_ClientSocket[i].lport == ENGINEER_PORT)	//把数据发送到B网的工程师站
				CONN_Send104Data(1,i,pucTCP,len);
		}
	}
}
void CONN_SendDataUp(int iPort,int NetGroup,int index,unsigned char *pucIEC104,unsigned char *pucIEC103)
{
	int i, ret;
	unsigned char ucAddr = *(pucIEC103+IEC103_OFFSET_ADDR);
	unsigned char ucCOT103 = *(pucIEC103+IEC103_OFFSET_COT);
	if (IEC_NeedBroadCast_103(ucCOT103,index))
	{
		ret = IEC_Frame_103To104(pucIEC104, pucIEC103);
		if(ret>0)
		{
			if((*(pucIEC104+6)==9)||(*(pucIEC104+6)==50))
				WriteMsgToShareMem(iPort,ret,pucIEC104,OperatorStation,YC_Msg);
			else
				WriteMsgToShareMem(iPort,ret,pucIEC104,OperatorStation,YX_Msg);
		}
		ret = IEC_Frame_103ToTCP(pucIEC104, pucIEC103);
		if(ret>0)
			WriteMsgToShareMem(iPort,ret,pucIEC104,EngineerStation,YX_Msg);
	}
	else
	{
		if (CONN_IsEngStation(NetGroup,index))
			ret=IEC_Frame_103ToTCP(pucIEC104,pucIEC103);
		else
			ret	=IEC_Frame_103To104(pucIEC104,pucIEC103);
		if (ret > 0)
			CONN_Send104Data(NetGroup,index,pucIEC104,ret);
	}
}
void  CONN_PackCount(int NetGroup,int iConect,unsigned char *pucData)
{
	switch(NetGroup)
	{
	case 0:
		pucData[2]	=(unsigned char)(A_ClientSocket[iConect].Conn_SendCount  & 0xff);
		pucData[3]	=(unsigned char)((A_ClientSocket[iConect].Conn_SendCount >> 8) & 0xff);
		pucData[4]	=(unsigned char)((A_ClientSocket[iConect].Conn_RecvCount & 0xff));
		pucData[5]	=(unsigned char)((A_ClientSocket[iConect].Conn_RecvCount >> 8) & 0xff);
		break;
	case 1:
		pucData[2]	=(unsigned char)(B_ClientSocket[iConect].Conn_SendCount  & 0xff);
		pucData[3]	=(unsigned char)((B_ClientSocket[iConect].Conn_SendCount >> 8) & 0xff);
		pucData[4]	=(unsigned char)((B_ClientSocket[iConect].Conn_RecvCount & 0xff));
		pucData[5]	=(unsigned char)((B_ClientSocket[iConect].Conn_RecvCount >> 8) & 0xff);
		break;
	}
}
void Conn_Clear(int NetGroup,int nIndex)
{
	switch(NetGroup)
	{
	case 0:
		A_ClientSocket[nIndex].Socket_fd				=0;
		A_ClientSocket[nIndex].inUse					=0;
		A_ClientSocket[nIndex].lport					=0;
		A_ClientSocket[nIndex].send_wait_count		=0;
		A_ClientSocket[nIndex].timeout_T1			=0;
		A_ClientSocket[nIndex].timeout_T2			=0;
		A_ClientSocket[nIndex].timeout_T3			=0;
		A_ClientSocket[nIndex].timeout_SConfirm		=0;
		A_ClientSocket[nIndex].timeout_RecData		=0;	
		A_ClientSocket[nIndex].timeout_NeedSConfirm	=0;	
		A_ClientSocket[nIndex].count_I_Send			=0;
		A_ClientSocket[nIndex].count_I_Recv			=0;
		A_ClientSocket[nIndex].IEC_Flag				=0;
		A_ClientSocket[nIndex].Conn_flag				=0;
		A_ClientSocket[nIndex].Conn_SendCount		=0;
		A_ClientSocket[nIndex].Conn_RecvCount		=0;
		A_ClientSocket[nIndex].NeedCheck			=0;
		A_ClientSocket[nIndex].DebugFlag			=0;
		break;
	case 1:
		B_ClientSocket[nIndex].Socket_fd				=0;
		B_ClientSocket[nIndex].inUse					=0;
		B_ClientSocket[nIndex].lport					=0;
		B_ClientSocket[nIndex].send_wait_count		=0;
		B_ClientSocket[nIndex].timeout_T1				=0;
		B_ClientSocket[nIndex].timeout_T2				=0;
		B_ClientSocket[nIndex].timeout_T3				=0;
		B_ClientSocket[nIndex].timeout_SConfirm		=0;
		B_ClientSocket[nIndex].timeout_RecData		=0;	
		B_ClientSocket[nIndex].timeout_NeedSConfirm	=0;	
		B_ClientSocket[nIndex].count_I_Send			=0;
		B_ClientSocket[nIndex].count_I_Recv			=0;
		B_ClientSocket[nIndex].IEC_Flag				=0;
		B_ClientSocket[nIndex].Conn_flag				=0;
		B_ClientSocket[nIndex].Conn_SendCount		=0;
		B_ClientSocket[nIndex].Conn_RecvCount		=0;
		B_ClientSocket[nIndex].NeedCheck			=0;
		B_ClientSocket[nIndex].DebugFlag				=0;
		break;
	}
}
void TcpInit(void)
{
	CurDebugPort = MyFlashBuff[DebugPortAddr];
	MAX_CLIENT = HIBYTE(MyFlashBuff[ComputerAddr])+LOBYTE(MyFlashBuff[ComputerAddr]);
	if( (MAX_CLIENT<1) || (MAX_CLIENT>(IEC_Client_Num-2) ) ) 
		MAX_CLIENT = IEC_Client_Num - 2 ;
	MAX_CLIENT += 2;		//其中一个MCUSET_PORT参数设置，DEBUG_PORT报文监视
	gwGlobal.Protocol_Version = XJ_IEC_2;
	gwGlobal.CONN_Remote_Number = MAX_CLIENT-1;
	gwGlobal.CONN_Engineer_Number = 1;
}
void NetInit(int NetGroup)
{
	int ret,i;
	int optval, optlen = sizeof(int);
	int ListenPort,address_len;
	struct sockaddr_in address;
	unsigned long int ipaddr;
	switch(NetGroup)
	{
	case 0:
		GetIP(NetGroup, &ipaddr);
		for(i=0; i<ListenPort_Num; i++)
		{
			switch(i)
			{
			case 0:
				ListenPort=OPERATOR_PORT;
				break;
			case 1:
				ListenPort=ENGINEER_PORT;
				break;
			case 2:
				ListenPort=MCUSET_PORT;
				break;
			case 3:
				ListenPort=DEBUG_PORT;
				break;
			}
			A_ListenSocket[i] 		= socket(AF_INET,SOCK_STREAM,0);
			fcntl(A_ListenSocket[i], F_SETFL, fcntl(A_ListenSocket[i], F_GETFL, 0) | O_NONBLOCK);
			getsockopt(A_ListenSocket[i], SOL_SOCKET, SO_ERROR, &optval, &optlen);
			address.sin_family 		= AF_INET;
			address.sin_addr.s_addr 	= htonl(ipaddr);
			address.sin_port 		= htons(ListenPort);
			address_len     			= sizeof(address);
			bind(A_ListenSocket[i],(struct sockaddr *)&address,address_len);
			listen(A_ListenSocket[i], MAX_CLIENT);
		}
		for(i=0;i<(sizeof(A_ClientSocket)/sizeof(CONNECTION));i++)
		{
			Conn_Clear(NetGroup, i);
		}
		A_Flag = 0;
		break;
	case 1:
		GetIP(NetGroup, &ipaddr);
		for(i=0; i<ListenPort_Num; i++)
		{
			switch(i)
			{
			case 0:
				ListenPort=OPERATOR_PORT;
				break;
			case 1:
				ListenPort=ENGINEER_PORT;
				break;
			case 2:
				ListenPort=MCUSET_PORT;
				break;
			case 3:
				ListenPort=DEBUG_PORT;
				break;
			}
			B_ListenSocket[i] 		= socket(AF_INET,SOCK_STREAM,0);
			fcntl(B_ListenSocket[i], F_SETFL, fcntl(B_ListenSocket[i], F_GETFL, 0) | O_NONBLOCK); 
			getsockopt(B_ListenSocket[i], SOL_SOCKET, SO_ERROR, &optval, &optlen);
			address.sin_family 		= AF_INET;
			address.sin_addr.s_addr 	= htonl(ipaddr);
			address.sin_port 		= htons(ListenPort);
			address_len     			= sizeof(address);
			bind(B_ListenSocket[i],(struct sockaddr *)&address,address_len);		
			listen(B_ListenSocket[i], MAX_CLIENT);
		}
		for(i=0;i<(sizeof(B_ClientSocket)/sizeof(CONNECTION));i++)
		{
			Conn_Clear(NetGroup, i);
		}
		B_Flag = 0;
		break;
	}
}
int	CONN_Need_RT(int NetGroup,int index,unsigned char *pucData)
{
	CONNECTION	*pConn;
	unsigned char ucTI;
	switch(NetGroup)
	{
	case 0:
		pConn	=&A_ClientSocket[index];
		break;
	case 1:
		pConn	=&B_ClientSocket[index];
		break;
	default :
		pConn	=&A_ClientSocket[index];
		break;
	}
	if (pConn->lport == ENGINEER_PORT)
	{
		ucTI	=pucData[TCP_OFFSET_TI];
		return IEC_RT_103(ucTI);
	}
	else
	{
		ucTI	=pucData[IEC104_OFFSET_TI];
		return	IEC_RT_104(ucTI);
	}
	return 0;
}
int RecvDataFromNet(SOCKET Client_Fd,unsigned char *NetRecvBuff)
{
	int k,SF=0,len = 0,nRecv = 0;
	unsigned char TempBuff[1];
	for(k=0; k<256; k++)
	{
		len = recv(Client_Fd, TempBuff, 1, MSG_DONTWAIT);	//每次读取一个字节
		if(len>0)
		{
			if((TempBuff[0]==0x68)&&(SF==0))
				SF = 1;
			if(SF==1)
			{
				memcpy( (NetRecvBuff+nRecv), TempBuff, len) ;
				nRecv += len;
				if ( (NetRecvBuff[0]==0x68) && (nRecv>=NetRecvBuff[1]+2) )
				{
					nRecv = *(NetRecvBuff+1)+2;
					return nRecv;
				}
			}
		}
		else
		{
			break;
		}
	}
	return 0;
}
int max( int a, int b)
{
	int themax;
	if ( a > b) 
		themax = a;
	else 
		themax = b;
	return themax;
}
void add_socket(fd_set *sockset,SOCKET *ListenSockfd,CONNECTION *ClientSockfd)
{
	int i;
	FD_ZERO(sockset);
	for(i=0;i<ListenPort_Num;i++)
	{
		FD_SET(ListenSockfd[i],sockset);
	}
	for(i=0;i<MAX_CLIENT;i++)
	{
		if(ClientSockfd[i].inUse==1)
		{
			FD_SET(ClientSockfd[i].Socket_fd,sockset);
		}	
	}
}
void *A_NetRecv(void *tmp)
{
	struct linger lingero;
	int optval, optlen = sizeof(int);
	
	int i,j,k,m,n,ret,nRecv,PreRead;
	int uiCount,nPort,A_Maxfd=0;
	int client_len,iCon_Number;
	unsigned char ucPI;
	SOCKET Client_Temp;
	CurrentTime timeBAK;
	unsigned char TempBuff[256];
	unsigned char SendBuff[256],RecvBuff[256];
	unsigned char OpeTimeBuff[32],EngTimeBuff[32];
	fd_set A_Sockset;
	struct timeval TimeOut;
	struct sockaddr_in client_addr;
	client_len = sizeof(client_addr);
	
	NetInit(0);
	FD_ZERO(&A_Sockset);
	for(i=0;i<ListenPort_Num;i++)
	{
		FD_SET(A_ListenSocket[i],&A_Sockset);		
		A_Maxfd = max(A_Maxfd,A_ListenSocket[i]+1);
	}
	while(1)
	{
		CurNetA ++ ;
		CheckNetConnected(0);
		//////////////////////////////////////////处理A网的连接,数据/////////////////////////////////////////////////////////
		for(i=0;i<MAX_CLIENT;i++)
		{
			if(A_ClientSocket[i].inUse)
			{
				A_ClientSocket[i].timeout_T1++;
				if (A_ClientSocket[i].timeout_T1>=TIMEOUT_TIMES)
				{
					if((A_ClientSocket[i].lport==OPERATOR_PORT)||(A_ClientSocket[i].lport==ENGINEER_PORT))
					{
						A_Flag--;
					}
					FD_CLR(A_ClientSocket[i].Socket_fd,&A_Sockset);
					close(A_ClientSocket[i].Socket_fd);
					Conn_Clear(0,i);
				}
			}
		}
		TimeOut.tv_sec  = SELECT_S;
		TimeOut.tv_usec = SELECT_US;//select函数最多等待200ms如果检测队列中没有描述可读，则返回
		if(select(A_Maxfd,&A_Sockset,NULL,NULL,&TimeOut) != 0)
		{
			for(k=0;k<ListenPort_Num;k++)
			{
				if( (FD_ISSET(A_ListenSocket[k],&A_Sockset)) && ( ( i=GetFreeConnect(0) )>= 0) )
				{
					//printf("printf i = %d \n", i);
					getsockopt(A_ListenSocket[k], SOL_SOCKET, SO_ERROR, &optval, &optlen);
					Client_Temp = accept(A_ListenSocket[k],(struct sockaddr *)&client_addr,&client_len);
					if(Client_Temp<0)
					{
						printf("accept error \n");
					}
					else
					{
						fcntl(Client_Temp, F_SETFL, fcntl(Client_Temp, F_GETFL, 0) | O_NONBLOCK); 
						A_ClientSocket[i].Socket_fd = Client_Temp;
						A_ClientSocket[i].inUse =1;
						switch(k)
						{
						case 0:
							A_Flag++; 
							A_ClientSocket[i].lport=OPERATOR_PORT;
							break;
						case 1:
							A_Flag++; 
							A_ClientSocket[i].lport=ENGINEER_PORT;
							break;
						case 2:
							A_ClientSocket[i].lport=MCUSET_PORT;
							break;
						case 3:
							A_ClientSocket[i].lport=DEBUG_PORT;
							break;
						}
						FD_SET(Client_Temp, &A_Sockset);
						A_Maxfd = max(A_Maxfd, Client_Temp+1);
						
						getsockopt(A_ClientSocket[i].Socket_fd, SOL_SOCKET, SO_ERROR, &optval, &optlen);
						optlen = sizeof(lingero);
						lingero.l_onoff=1;
						lingero.l_linger=1;
						setsockopt(A_ClientSocket[i].Socket_fd, SOL_SOCKET, SO_LINGER, &lingero, optlen);	
					}
				}
			}
			for(i=0;i<MAX_CLIENT;i++)
			{
				if( (A_ClientSocket[i].inUse) && (FD_ISSET(A_ClientSocket[i].Socket_fd,&A_Sockset)) )
				{	
					getsockopt(A_ClientSocket[i].Socket_fd, SOL_SOCKET, SO_ERROR, &optval, &optlen);
					PreRead = recv(A_ClientSocket[i].Socket_fd,TempBuff,sizeof(TempBuff), MSG_DONTWAIT | MSG_PEEK);	//查看缓冲区,不清数据
					if(PreRead>0) 
					{
						A_ClientSocket[i].timeout_T1 = 0;
						nRecv = RecvDataFromNet(A_ClientSocket[i].Socket_fd,RecvBuff);
						if(nRecv>0)
						{
							if(A_ClientSocket[i].lport==MCUSET_PORT)
							{
								if((nRecv == 6 )&&(RecvBuff[2]==0x43))
								{
									RecvBuff[2]=0x83;
									CONN_SendBuff(A_ClientSocket[i].Socket_fd, RecvBuff, 6);
								}
								else
								{
									ProcessParameters(0,i,RecvBuff);
								}
							}
							else if(A_ClientSocket[i].lport==DEBUG_PORT)
							{
								if((nRecv == 6 )&&(RecvBuff[2]==0x43))
								{
									RecvBuff[2]=0x83;
									CONN_SendBuff(A_ClientSocket[i].Socket_fd, RecvBuff, 6);
								}
								else
								{
									ProcessDebugParameters(0,i,RecvBuff);
								}
							}
							else
							{
								if ( nRecv == 6 )
								{
									switch( RecvBuff[2] )
									{
									case 0x43:	//TESTFR
										RecvBuff[2] = 0x83;
										CONN_SendBuff(A_ClientSocket[i].Socket_fd, RecvBuff, 6);
										A_ClientSocket[i].NeedCheck = 1;
										break;
									case 0x13:	//STOPDT
										RecvBuff[2] = 0x23;
										A_ClientSocket[i].IEC_Flag &= (~IEC104_FLAG_START);
										CONN_SendBuff(A_ClientSocket[i].Socket_fd, RecvBuff, 6);
										break;
									case STOPDT_CONFIRM: