mbtcp.c

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

#include "include/mcuapi.h"
void *MBTCP(void * tmp)
{
	int retval = 109;
	unsigned char MBTCP_Type = HIBYTE(MyFlashBuff[ModbusTCP]);
	switch(MBTCP_Type)
	{
	case 1:
		MBTCP_Server();
		break;
	case 2:
		MBTCP_Client();
		break;
	default :
		pthread_exit(&retval);
		break;
	}
}
void MBTCPInit(void)
{
	int i;
	unsigned long ipaddr;
	int optval, optlen = sizeof(int);
	int ListenPort = 502,address_len;
	struct sockaddr_in address;
	for(i=0; i<2 ;i++)
	{
		GetIP(i, &ipaddr);
		MBTCP_ListenSocket[i] =socket(AF_INET,SOCK_STREAM,0);
		address.sin_family =AF_INET;
		address.sin_addr.s_addr =htonl(ipaddr);
		address.sin_port = htons(ListenPort);
		address_len     =sizeof(address);
		getsockopt(MBTCP_ListenSocket[i], SOL_SOCKET, SO_ERROR, &optval, &optlen);
		bind(MBTCP_ListenSocket[i], (struct sockaddr *)&address, address_len);	
		listen(MBTCP_ListenSocket[i], 6);
	}
	for(i=0; i<MBTCP_Client_Num; i++)
	{
		MBTCP_Conn_Clear(0, i);
		MBTCP_Conn_Clear(1, i);
	}
	MBTCP_AFlag = MBTCP_BFlag = 0;
}
void MBTCP_Conn_Clear(int NetGroup,int nIndex)
{
	switch(NetGroup)
	{
	case 0:
		MBTCP_A_ClientSocket[nIndex].Socket_fd				=0;
		MBTCP_A_ClientSocket[nIndex].inUse					=0;
		MBTCP_A_ClientSocket[nIndex].lport					=0;
		break;
	case 1:
		MBTCP_B_ClientSocket[nIndex].Socket_fd				=0;
		MBTCP_B_ClientSocket[nIndex].inUse					=0;
		MBTCP_B_ClientSocket[nIndex].lport					=0;
		break;
	}
}
void MBTCP_Server(void)
{
	struct linger lingero;
	int optval, optlen = sizeof(int);
	
	SOCKET Client_Temp;
	int i,j,k,m,ret,nRecv,nSend;
	int PreRead,MBTCP_Maxfd=0;
	fd_set MBTCP_Sockset;
	struct timeval TimeOut;;
	struct sockaddr_in client_addr;
	unsigned short StartAddr, ReqNum;
	unsigned char TempBuff[256];
	unsigned char SendBuff[256],RecvBuff[256];
	int client_len = sizeof(client_addr);
	
	MBTCPInit();
	FD_ZERO(&MBTCP_Sockset);
	for(i=0; i<2; i++)
	{
		FD_SET(MBTCP_ListenSocket[i], &MBTCP_Sockset);		
		MBTCP_Maxfd = max(MBTCP_Maxfd, MBTCP_ListenSocket[i]+1);
	}
	while(1)
	{
		for(i=0; i<MBTCP_Client_Num; i++)
		{
			if(MBTCP_A_ClientSocket[i].inUse)
			{
				MBTCP_A_ClientSocket[i].timeout_T1++;
				if (MBTCP_A_ClientSocket[i].timeout_T1>=TIMEOUT_TIMES)
				{
					MBTCP_AFlag --;
					FD_CLR(MBTCP_A_ClientSocket[i].Socket_fd,&MBTCP_Sockset);
					close(MBTCP_A_ClientSocket[i].Socket_fd);
					MBTCP_Conn_Clear(0,i);
				}
			}
			if(MBTCP_B_ClientSocket[i].inUse)
			{
				MBTCP_B_ClientSocket[i].timeout_T1++;
				if (MBTCP_B_ClientSocket[i].timeout_T1>=TIMEOUT_TIMES)
				{
					MBTCP_BFlag --;
					FD_CLR(MBTCP_B_ClientSocket[i].Socket_fd,&MBTCP_Sockset);
					close(MBTCP_B_ClientSocket[i].Socket_fd);
					MBTCP_Conn_Clear(1,i);
				}
			}
		}
		TimeOut.tv_sec  = SELECT_S;
		TimeOut.tv_usec = SELECT_US;		//select函数最多等待SELECT_US如果检测队列中没有描述可读，则返回
		if(select(MBTCP_Maxfd, &MBTCP_Sockset, NULL, NULL, &TimeOut)!=0)
		{
			for(k=0; k<2; k++)
			{
				if(FD_ISSET(MBTCP_ListenSocket[k], &MBTCP_Sockset))
				{
					getsockopt(MBTCP_ListenSocket[k], SOL_SOCKET, SO_ERROR, &optval, &optlen);
					switch(k)
					{
					case 0:
						if((MBTCP_AFlag<MBTCP_Client_Num)&&( ( i=GetMBTCPFreeConnect(k) ) >= 0))
						{
							Client_Temp = accept(MBTCP_ListenSocket[k],(struct sockaddr *)&client_addr,&client_len);
							if (Client_Temp>0)
							{
								fcntl(Client_Temp, F_SETFL, fcntl(Client_Temp, F_GETFL, 0) | O_NONBLOCK); 
								getsockopt(Client_Temp, SOL_SOCKET, SO_ERROR, &optval, &optlen);
								optlen = sizeof(lingero);
								lingero.l_onoff=1;
								lingero.l_linger=1;
								setsockopt(Client_Temp, SOL_SOCKET, SO_LINGER, &lingero, optlen);	

								MBTCP_AFlag ++;
								MBTCP_A_ClientSocket[i].Socket_fd=Client_Temp;
								MBTCP_A_ClientSocket[i].inUse =1;
								FD_SET(MBTCP_A_ClientSocket[i].Socket_fd,&MBTCP_Sockset);
								MBTCP_Maxfd = max(MBTCP_Maxfd, MBTCP_A_ClientSocket[i].Socket_fd+1);
							}
							else
							{
								getsockopt(MBTCP_ListenSocket[k], SOL_SOCKET, SO_ERROR, &optval, &optlen);
							}
						}
						break;
					case 1:
						if((MBTCP_BFlag<MBTCP_Client_Num)&&( ( i=GetMBTCPFreeConnect(k) ) >= 0))
						{
							Client_Temp = accept(MBTCP_ListenSocket[k],(struct sockaddr *)&client_addr,&client_len);
							if ( Client_Temp > 0 )
							{
								fcntl(Client_Temp, F_SETFL, fcntl(Client_Temp, F_GETFL, 0) | O_NONBLOCK); 
								getsockopt(Client_Temp, SOL_SOCKET, SO_ERROR, &optval, &optlen);
								optlen = sizeof(lingero);
								lingero.l_onoff=1;
								lingero.l_linger=1;
								setsockopt(Client_Temp, SOL_SOCKET, SO_LINGER, &lingero, optlen);
								
								MBTCP_BFlag ++;
								MBTCP_B_ClientSocket[i].Socket_fd=Client_Temp;
								MBTCP_B_ClientSocket[i].inUse =1;
								FD_SET(MBTCP_B_ClientSocket[i].Socket_fd,&MBTCP_Sockset);
								MBTCP_Maxfd = max(MBTCP_Maxfd, MBTCP_B_ClientSocket[i].Socket_fd+1);
								//printf("Accept i=%d \n",i);
							}
							else
							{
								getsockopt(MBTCP_ListenSocket[k], SOL_SOCKET, SO_ERROR, &optval, &optlen);
							}
						}
						break;
					}
				}
			}
			for(i=0; i<MBTCP_Client_Num; i++)
			{
				if( (MBTCP_A_ClientSocket[i].inUse) && (FD_ISSET(MBTCP_A_ClientSocket[i].Socket_fd, &MBTCP_Sockset)) )
				{	
					getsockopt(MBTCP_A_ClientSocket[i].Socket_fd, SOL_SOCKET, SO_ERROR, &optval, &optlen);
					PreRead = recv(MBTCP_A_ClientSocket[i].Socket_fd,RecvBuff,sizeof(RecvBuff),MSG_PEEK);//查看缓冲区,不清数据
					if (PreRead>0) 
					{
						MBTCP_A_ClientSocket[i].timeout_T1=0;	
						nRecv = Recv_MBTCP_Command(MBTCP_A_ClientSocket[i].Socket_fd, RecvBuff);
						if(nRecv>0)
						{
							memcpy(SendBuff, RecvBuff, 5);
							SendBuff[6] = RecvBuff[6] ;
							SendBuff[7] = RecvBuff[7] ;
							switch(RecvBuff[7])
							{
							case 0x03:
							case 0x04:
								StartAddr = RecvBuff[8]*256+RecvBuff[9];
								ReqNum = RecvBuff[10]*256+RecvBuff[11];
								m = RequireInvalid(YX_Msg, StartAddr, ReqNum); 
								if(m==0)
								{
									SendBuff[8] = ReqNum*2 ;
									SendBuff[5] = SendBuff[8] + 3 ;
									ret = GetYcResponseFrame(TempBuff,StartAddr,ReqNum);
									memcpy(SendBuff+9, TempBuff, ret);
									nSend = SendBuff[5]+6;
									CONN_SendBuff(MBTCP_A_ClientSocket[i].Socket_fd, SendBuff, nSend);
								}
								else
								{
									SendBuff[7] = RecvBuff[7] | 0x80;
									SendBuff[5] = 3 ;
									nSend = SendBuff[5]+6;
									CONN_SendBuff(MBTCP_A_ClientSocket[i].Socket_fd, SendBuff, nSend);
								}
								break;
							case 0x01:
							case 0x02:
								StartAddr = RecvBuff[8]*256+RecvBuff[9];
								ReqNum = RecvBuff[10]*256+RecvBuff[11];
								m = RequireInvalid(YX_Msg, StartAddr, ReqNum); 
								if(m==0)
								{
									SendBuff[7] = RecvBuff[7] ;
									if(ReqNum%8==0)
										SendBuff[8] = ReqNum/8 ;
									else
										SendBuff[8] = ReqNum/8+1 ;
									SendBuff[5] = SendBuff[8] + 3 ;
									ret = GetYxResponseFrame(TempBuff,StartAddr,ReqNum);
									memcpy(SendBuff+9, TempBuff, ret);
									nSend = SendBuff[5]+6;
									CONN_SendBuff(MBTCP_A_ClientSocket[i].Socket_fd, SendBuff, nSend);
								}
								else
								{
									SendBuff[7] = RecvBuff[7] | 0x80;
									SendBuff[5] = 3 ;
									nSend = SendBuff[5]+6;
									CONN_SendBuff(MBTCP_A_ClientSocket[i].Socket_fd, SendBuff, nSend);
								}
								break;
							case 0x05:	
							case 0x06:	
							case 0x10:
								memset(RecvBuff, 0, 5);
								SaveHMICommand(RecvBuff, nRecv);
								SendBuff[5] = 6 ;
								memcpy(SendBuff+7, RecvBuff+7, 5);
								nSend = SendBuff[5]+6;
								CONN_SendBuff(MBTCP_A_ClientSocket[i].Socket_fd, SendBuff, nSend);
								break;
							default :
								break;
						        }
						}
					}
					else if(PreRead==0) //客户端断开了连接
					{
						MBTCP_AFlag --;
						FD_CLR(MBTCP_A_ClientSocket[i].Socket_fd, &MBTCP_Sockset);
						close(MBTCP_A_ClientSocket[i].Socket_fd);
						MBTCP_Conn_Clear(0, i);
					}
					else
					{
						getsockopt(MBTCP_A_ClientSocket[i].Socket_fd, SOL_SOCKET, SO_ERROR, &optval, &optlen);
					}
				}
				if( (MBTCP_B_ClientSocket[i].inUse) && (FD_ISSET(MBTCP_B_ClientSocket[i].Socket_fd, &MBTCP_Sockset)) )
				{	
					getsockopt(MBTCP_B_ClientSocket[i].Socket_fd, SOL_SOCKET, SO_ERROR, &optval, &optlen);
					PreRead = recv(MBTCP_B_ClientSocket[i].Socket_fd,RecvBuff,sizeof(RecvBuff),MSG_PEEK);//查看缓冲区,不清数据
					if (PreRead>0) 
					{
						MBTCP_B_ClientSocket[i].timeout_T1=0;
						nRecv = Recv_MBTCP_Command(MBTCP_B_ClientSocket[i].Socket_fd, RecvBuff);
						if(nRecv>0)
						{
							//printf("Recv i=%d \n",i);
							memcpy(SendBuff, RecvBuff, 5);
							SendBuff[6] = RecvBuff[6] ;
							SendBuff[7] = RecvBuff[7] ;
							switch(RecvBuff[7])
							{
							case 0x03:
							case 0x04:
								StartAddr = RecvBuff[8]*256+RecvBuff[9];
								ReqNum = RecvBuff[10]*256+RecvBuff[11];
								m = RequireInvalid(YX_Msg, StartAddr, ReqNum); 
								if(m==0)
								{
									SendBuff[8] = ReqNum*2 ;
									SendBuff[5] = SendBuff[8] + 3 ;
									ret = GetYcResponseFrame(TempBuff,StartAddr,ReqNum);
									memcpy(SendBuff+9, TempBuff, ret);
									nSend = SendBuff[5]+6;
									CONN_SendBuff(MBTCP_B_ClientSocket[i].Socket_fd, SendBuff, nSend);
								}
								else
								{
									SendBuff[7] = RecvBuff[7] | 0x80;
									SendBuff[5] = 3 ;
									nSend = SendBuff[5]+6;
									CONN_SendBuff(MBTCP_B_ClientSocket[i].Socket_fd, SendBuff, nSend);
								}
								break;
							case 0x01:
							case 0x02:
								StartAddr = RecvBuff[8]*256+RecvBuff[9];
								ReqNum = RecvBuff[10]*256+RecvBuff[11];
								m = RequireInvalid(YX_Msg, StartAddr, ReqNum); 
								if(m==0)
								{
									SendBuff[7] = RecvBuff[7] ;
									if(ReqNum%8==0)
										SendBuff[8] = ReqNum/8 ;
									else
										SendBuff[8] = ReqNum/8+1 ;
									SendBuff[5] = SendBuff[8] + 3 ;
									ret = GetYxResponseFrame(TempBuff,StartAddr,ReqNum);
									memcpy(SendBuff+9, TempBuff, ret);
									nSend = SendBuff[5]+6;
									CONN_SendBuff(MBTCP_B_ClientSocket[i].Socket_fd, SendBuff, nSend);
								}
								else
								{
									SendBuff[7] = RecvBuff[7] | 0x80;
									SendBuff[5] = 3 ;
									nSend = SendBuff[5]+6;
									CONN_SendBuff(MBTCP_B_ClientSocket[i].Socket_fd, SendBuff, nSend);
								}
								break;
							case 0x05:	
							case 0x06:	
							case 0x10: