comapi.c

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

#include		<stdio.h>      
#include		<stdlib.h> 
#include		<memory.h>    
#include		<unistd.h> 
#include		<fcntl.h>      
#include		<termios.h>    
#include		<errno.h>  
#include 	<sys/time.h>
#include 	<sys/select.h>
#include		<sys/types.h>  
#include		<sys/stat.h>   
#include		<sys/ioctl.h>   
#include		"include/ComApi.h"
#include		"include/Timer.h" 
#include		"include/Connect.h" 
void DelayBaud(int iPort)
{
	struct timeval tv;
	unsigned int TempBaud = ComBaudRate[iPort];
	if(TempBaud<MinBaudRate) TempBaud = MinBaudRate;
	float fbaud = (float)TempBaud;
	float tmptime = 10000000.0*EveryRead/fbaud + 1.0;
	long iDelay = (long)tmptime;

	tv.tv_sec = iDelay/1000000;
	tv.tv_usec = iDelay%1000000; 
	while(select(0, NULL, NULL, NULL, &tv) != 0);
}
void OpenCOM(int iPort)
{
	char *pCOM = NULL;
	switch(iPort)
	{
	case 1:
		pCOM = COM1;
		break;
	case 2:
		pCOM = COM2;
		break;
	case 3:
		pCOM = COM3;
		break;
	case 4:
		pCOM = COM4;
		break;
	case 5:
		pCOM = COM5;
		break;
	case 6:
		pCOM = COM6;
		break;
	case 7:
		pCOM = COM7; 
		break;
	case 8:
		pCOM = COM8;
		break;	
	}
	COM[iPort] = open( pCOM, O_RDWR | O_NOCTTY | O_NONBLOCK );
	if(COM[iPort] == -1)
	{ 
		perror("Can't Open Serial Port");
	}
}
int Com_Config(int iPort, unsigned short speed, int databits, int stopbits, int parity)
{
	struct termios new_option;
	bzero(&new_option, sizeof (&new_option));

	new_option.c_cflag = BAUDRATE(speed);
	new_option.c_cflag |= CLOCAL | CREAD;
	new_option.c_cflag &= ~CSIZE;
	switch(databits) 
	{
	case 7:
		new_option.c_cflag |= CS7;
		break;
	case 8:
		new_option.c_cflag |= CS8;
		break;
	default :
		new_option.c_cflag |= CS8;
		break;
	}
	switch(parity)
	{
	case 'n':
	case 'N':
		new_option.c_cflag &= ~PARENB;		//Clear parity enable 
		break;
	case 'o':
	case 'O':
		new_option.c_cflag |= (PARODD | PARENB); 
		break;
	case 'e':
	case 'E':
		new_option.c_cflag |= PARENB;		
		new_option.c_cflag &= ~PARODD;	
		break;
	default :
		new_option.c_cflag &= ~PARENB;		//Clear parity enable 
		break;
	}
	switch(stopbits)
	{
	case 1:
		new_option.c_cflag &= ~CSTOPB;
		break;
	case 2:
		new_option.c_cflag |= CSTOPB;
		break;
	default :
		new_option.c_cflag &= ~CSTOPB;
		break;
	}
	new_option.c_iflag = 0;						//input flags
	new_option.c_lflag = 0;						//local flags
	new_option.c_oflag = 0;						//output flags
	new_option.c_cc[VTIME] = 10; 				// unit: 1/10 second. 
	new_option.c_cc[VMIN] = 1;					// minimal characters for reading
	tcflush(COM[iPort], TCIFLUSH); 				//Update the new_option and do it NOW
	if (tcsetattr(COM[iPort],TCSANOW,&new_option) < 0)
	{
		perror("Setup Serial Error");
		return FALSE;
	}
	return TRUE;
}
int COMM_SendBuff(int iPort, unsigned char *data, int datalength)
{
	fd_set fs_write;
	struct timeval tv_timeout;
	int i, k, len, nWrite = 0;
	int byteleft = datalength;
	COM_Clear(iPort);
	FD_ZERO(&fs_write);
	FD_SET(COM[iPort], &fs_write);
	tv_timeout.tv_sec = 0;
	tv_timeout.tv_usec = 200000;
	if( select(COM[iPort] + 1,  NULL, &fs_write, NULL, &tv_timeout) != 0 )
	{
		if(FD_ISSET(COM[iPort], &fs_write))
		{
			if(ComBaudRate[iPort]>2400)
			{
				for(k=0;k<10;k++)
				{
					if( byteleft > 0 )
					{
						len = write(COM[iPort], &data[nWrite], byteleft);
						if( len > 0 )
						{
							nWrite +=len;
							byteleft -= len;
						}
					}
					else
					{
						break;
					}
				}	
			}
			else
			{
				for(i=0; i<datalength; i++)
				{
					for(k=0;k<3;k++)
					{
						SYS_Delay(10);
						len = write(COM[iPort], data+i, 1);
						if(len>0)
						{
							nWrite ++;
							break;
						}
					}					
				}
			}
			PrintDebugInfo(iPort, Send_Data, data, nWrite);
		}
	}
	return nWrite;
}
int ComDataCome(int iPort, int TimeOut)
{
	int retval = 0;
	fd_set fs_read;
	struct timeval tv_timeout;
	long iDelay = TimeOut*1000;
	FD_ZERO(&fs_read);
	FD_SET(COM[iPort], &fs_read);
	tv_timeout.tv_sec = iDelay/1000000;
	tv_timeout.tv_usec = iDelay%1000000; 
	retval = select(COM[iPort] + 1, &fs_read, NULL, NULL, &tv_timeout);
	return (retval&FD_ISSET(COM[iPort], &fs_read));
}
int ReadComPort(int iPort, unsigned char *data, int datalength)
{
	fd_set fs_read;
	struct timeval tv_timeout;
	int k, iError = 0, len = 0, nRecv = 0;
	unsigned char TempBuff[EveryRead];
	FD_ZERO(&fs_read);
	FD_SET(COM[iPort], &fs_read);
	tv_timeout.tv_sec = TIMEOUT_SEC(datalength, ComBaudRate[iPort]) ;
	tv_timeout.tv_usec = TIMEOUT_USEC;
	if( select(COM[iPort] + 1, &fs_read, NULL, NULL, &tv_timeout) != 0 )
	{
		if(FD_ISSET(COM[iPort], &fs_read))
		{
			for(k=0;k<(datalength*2)/EveryRead;k++)
			{
				len = read(COM[iPort], TempBuff, sizeof(TempBuff));
				if( len > 0 )
				{
					iError = 0 ;
					if( nRecv+len < datalength )
					{
						memcpy(data+nRecv, TempBuff, len);
						nRecv += len ;
					}
				}
				else
				{
					iError ++;
					if(iError > 20) break;
					DelayBaud(iPort);
				}
			}
			PrintDebugInfo(iPort, Recv_Data, data, nRecv);
			return nRecv;
		}
	}
	return 0;
}
void COM_Clear(int iPort)
{
	tcflush(COM[iPort], TCIOFLUSH); 
	SYS_Delay(20);
	/*int k, len;
	fd_set fs_read;
	struct timeval tv_timeout;
	unsigned char TempBuff[EveryRead];
	FD_ZERO(&fs_read);
	FD_SET(COM[iPort], &fs_read);
	tv_timeout.tv_sec = 0;
	tv_timeout.tv_usec = 200000;
	if( select(COM[iPort] + 1, &fs_read, NULL, NULL, &tv_timeout) != 0 )
	{
		if(FD_ISSET(COM[iPort], &fs_read))
		{
			for(k=0;k<200;k++)
			{
				len = read(COM[iPort], TempBuff, sizeof(TempBuff));
				if(len>0)
					DelayBaud(iPort);
				else
					break;
			}
		}
	}*/
}
int BAUDRATE(unsigned short baudrate)
{
	switch(baudrate) 
	{
	case 1200:
		return (B1200);
	case 2400:
		return (B2400);
	case 4800:
		return (B4800);	
	case 9600:
		return (B9600);
	case 19200:
		return (B19200);
	case 38400:
		return (B38400);	
	default :
		return (B9600);
	}
}
void OpenComPort(int iPort, unsigned short baudrate, int databit, int stopbit, char parity)
{	
	OpenCOM(iPort);
	
	ComBaudRate[iPort] = baudrate;
	
	Com_Config(iPort, baudrate, databit, stopbit, parity);
}

//add for 联华励磁(LH-WLT02)  下发时每个字节之间延时10ms
int COMM_SendBuff_LHLC(int iPort, unsigned char *data, int datalength)
{
	fd_set fs_write;
	struct timeval tv_timeout;
	int i, k, len, nWrite = 0;
	int byteleft = datalength;
	COM_Clear(iPort);
	FD_ZERO(&fs_write);
	FD_SET(COM[iPort], &fs_write);
	tv_timeout.tv_sec = 0;
	tv_timeout.tv_usec = 200000;
	if( select(COM[iPort] + 1,  NULL, &fs_write, NULL, &tv_timeout) != 0 )
	{
		if(FD_ISSET(COM[iPort], &fs_write))
		{
			for(i=0; i<datalength; i++)
			{
				for(k=0;k<3;k++)
				{
					SYS_Delay(10);
					len = write(COM[iPort], data+i, 1);
					if(len>0)
					{
						nWrite ++;
						break;
					}
				}					
			}
		       PrintDebugInfo(iPort, Send_Data, data, nWrite);
	       }
	}
	return nWrite;
}