gprsshortmessage.c

GPRS短信收发 基于linux平台

#include     <stdio.h>      
#include     <stdlib.h>     
#include     <unistd.h>     
#include     <sys/types.h>  
#include     <sys/stat.h>   
#include     <fcntl.h>      
#include     <termios.h>    
#include     <errno.h>      
#include 	 <signal.h>
#include 	 <sys/time.h>
#include 	 <time.h>
#include 	 <string.h>

#include     "gprsshortmessage.h"




int speed_arr[] = { B38400, B19200, B9600, B4800, B2400, B1200, B300,
            B38400, B19200, B9600, B4800, B2400, B1200, B300, };
int name_arr[] = {38400,  19200,  9600,  4800,  2400,  1200,  300,
            38400,  19200,  9600, 4800, 2400, 1200,  300, };
char *DEV="/dev/ttyS1";




void set_speed(int fd, int speed)
{
  int   i;
  int   status;
  struct termios   Opt;
  tcgetattr(fd, &Opt);
  for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++)
   {
   	if  (speed == name_arr[i])
   	{
   		tcflush(fd, TCIOFLUSH);
    		cfsetispeed(&Opt, speed_arr[i]);
    		cfsetospeed(&Opt, speed_arr[i]);
    		status = tcsetattr(fd, TCSANOW, &Opt);
    		if  (status != 0)
            		perror("tcsetattr fd1");
     		return;
     	}
   	tcflush(fd,TCIOFLUSH);
   }
}

int set_parity(int fd,int databits,int stopbits,int parity)
{
 struct termios options;
 if  ( tcgetattr( fd,&options)  !=  0)
  {
  	perror("SetupSerial 1");
  	return(FALSE);
  }
  options.c_cflag &= ~CSIZE;
  switch (databits) 
  {
  	case 5:
  		options.c_cflag |= CS5;
  		break;
  	case 6:
  		options.c_cflag |= CS6;
  		break;
  	case 7:
  		options.c_cflag |= CS7;
  		break;
  	case 8:
		options.c_cflag |= CS8;
		break;
	default:
		fprintf(stderr,"Unsupported data size\n");
		return (FALSE);
	}
  switch (parity)
  	{
  	case 'n':
	case 'N':
		options.c_cflag &= ~PARENB;   
		options.c_iflag &= ~INPCK;    
		break;
	case 'o':
	case 'O':
		options.c_cflag |= (PARODD | PARENB);   
		options.c_iflag |= INPCK;             
		break;
	case 'e':
	case 'E':
		options.c_cflag |= PARENB;     
		options.c_cflag &= ~PARODD;   
		options.c_iflag |= INPCK;       
		break;
	case 'S':
	case 's':  
		options.c_cflag &= ~PARENB;
		options.c_cflag &= ~CSTOPB;
		break;
	default:
		fprintf(stderr,"Unsupported parity\n");
		return (FALSE);
		}
  	 
  	switch (stopbits)
  	{
  	case 1:
  		options.c_cflag &= ~CSTOPB;
		break;
	case 2:
		options.c_cflag |= CSTOPB;
		break;
	default:
		fprintf(stderr,"Unsupported stop bits\n");
		return (FALSE);
	}
  	/* Set input parity option */
  	if (parity != 'n')
  		options.c_iflag |= INPCK;
    	
    	
	options.c_lflag  &= ~(ICANON | ECHO | ECHOE | ISIG);  /*Input*/
	options.c_oflag  &= ~OPOST;   /*Output*/
	
	options.c_iflag &= ~(IXON | IXOFF | IXANY);
		
    	options.c_cc[VTIME] = 10; // 1 seconds
    	options.c_cc[VMIN] = 0;

  	tcflush(fd,TCIFLUSH); /* Update the options and do it NOW */
  	if (tcsetattr(fd,TCSANOW,&options) != 0)
  	{
  		perror("SetupSerial 3");
		return (FALSE);
	}
  	return (TRUE);
}


void SetFlowControl(int com,int mode)
{
	struct termios options;
 	if  ( tcgetattr( com,&options)  !=  0)
  	{
  		perror("SetupSerial 1");
  		return;
  	}
  	switch(mode)
  	{
  		case 1:
  			options.c_cflag &= ~CRTSCTS;
			break;
		case 2:
			options.c_cflag |= CRTSCTS;
			break;
		case 3:
			options.c_cflag |= IXON|IXOFF|IXANY;
	}
	tcsetattr(com,TCSANOW,&options);
	
		
}


int Open_Init_COM(char *Dev)
{
	int	com=open( Dev, O_RDWR | O_NOCTTY);         
	if (-1 == com)
	{ 
		
		perror("Can't Open Serial Port");
		return -1;
	}
	
	fcntl(com,F_SETFL,0);
	
	set_speed(com,57600);
	set_parity(com,8,1,'s');
	SetFlowControl(com,1);	
	return com;
}



int ReadCOM(int n,char *buf,int length)
{
	return read(n,buf,length);
}

int WriteCOM(int n,char *buf,int length)
{
	return write(n,buf,length);
}

int CloseCOM(int n)
{
	return close(n);
}


int Gprs_SendMessage(int com,char at_cmd_array[][30],char * pMsg)
{
	int i,nRead,num=0;
	char gprs_reply_buf[100];
	char *at_cmd=at_cmd_array[0];
	while(strcmp(at_cmd,""))
	{	
		bzero(gprs_reply_buf,100);
		WriteCOM(com,at_cmd,strlen(at_cmd));
		sleep(2);
		if(strstr(at_cmd,"AT+CMGS")!=NULL)
		{
			//SEND MESSAGE
			strcat(pMsg,"\\r\032");
			WriteCOM(com,pMsg,strlen(pMsg));
		}
		nRead=ReadCOM(com,gprs_reply_buf,100);
		if(strstr(gprs_reply_buf,"OK")!=NULL) 
		{	
			num++;
			at_cmd=at_cmd_array[num];
			continue;
		}
		
		return num;
	}
	return -1;
		
}


int Gprs_ReceiveMessage(int com,char at_cmd_array[][30],struct shortmsg * pShortMsg)
{
	int i,nRead,num=0;
	char gprs_rev_buf[100];
	char *ptr;
	char *ptr1;
	char *at_cmd=at_cmd_array[0];
	nRead=0;

	writelog("enter Gprs_ReceiveMessage()\n");
	while(strcmp(at_cmd,""))
	{
		
		bzero(gprs_rev_buf,100);
		WriteCOM(com,at_cmd,strlen(at_cmd));
		sleep(2);
		if(strstr(at_cmd,"AT+CMGR")!=NULL)
		{
			
			nRead=ReadCOM(com,gprs_rev_buf,100);
			
			
			if(strlen(gprs_rev_buf)<=0)
				return -2;

			
			ptr=strstr(gprs_rev_buf,"+86");
			if (!ptr)				
			{	//printf("receive message error\n");
				writelog("receive message error\n");
				return -2;
			}

			
			strncpy(pShortMsg->sender,ptr,14);

			
			ptr=strstr(ptr,"\r\n");
			if (!ptr)
				
				writelog("receive message error\n");
			else
			{	
				ptr=ptr+2;
				ptr1=strstr(ptr,"\r\n");
				*ptr1=0;//the end of the short message's content
				strcpy(pShortMsg->msgcontent,ptr);
				num++;
				at_cmd=at_cmd_array[num];
				continue;
			}
				
			
		}
		else if(strstr(at_cmd,"AT+CMGL=ALL")!=NULL)
		{	
			
		}
		
			
		nRead=ReadCOM(com,gprs_rev_buf,100);
		if(strstr(gprs_rev_buf,"OK")!=NULL) 
		{	
			num++;
			at_cmd=at_cmd_array[num];
			continue;
		}
		
		return num;
	}
	return -1;

}

int Gprs_DeleteMessage(int com,int index)
{
	int i,nRead,num=0;
	char gprs_rev_buf[100];
	char index_ch[10];
	char *ptr;
	char at_cmd[100]="AT+CMGD=";
	nRead=0;

	
	writelog("enter Gprs_DeleteMessage()\n");
	bzero(gprs_rev_buf,100);
	bzero(index_ch,10);

	sprintf(index_ch,"%d\r",index);
	strcat(at_cmd,index_ch);
	
	WriteCOM(com,at_cmd,strlen(at_cmd));
	sleep(2);
		
					
	nRead=ReadCOM(com,gprs_rev_buf,100);
	if(strstr(gprs_rev_buf,"OK")!=NULL)
		return 0;		
	
	return -1;


}


int sendshortmessagethread(struct shortmsg * pSendMsg)
{
	int fd,reval;
	char SendMessageCmd[][30]={{"ATZ\r"},{"AT+CMGF=1\r"},{"AT+CSCA=\"[phone]\"\r"},{"AT+CMGS=\""},{""}};
	
	int Try_Send=3;
	int Try_Receive=3;
	//struct shortmsg * pRevMsg=(struct shortmsg *)malloc(sizeof(struct shortmsg));	
	
	if((fd=Open_Init_COM(DEV))==-1)
	{
		
		return -1;
	}

	
	strcat(SendMessageCmd[3],pSendMsg->sender);
	strcat(SendMessageCmd[3],"\"\r");
		
	
	while ((Try_Send--)>=3)
	{	
		reval=Gprs_SendMessage(fd,SendMessageCmd,pSendMsg->msgcontent);
		if(-1==reval)
		{
			writelog("send message success\n");
			break;			
		}
		else
		{
			writelog("AT COMMAND %s EXECUTE ERROR\n",SendMessageCmd[reval]);
			
		}
	}

	close(fd);
	if(Try_Send<0)
	{		
		return -1;
	}	
	
	return 0;
}



int messagepromptfunc(struct shortmsg * pRevMsg)
{
	//sendshortmessagethread(pRevMsg);
	
	if(strcmp(pRevMsg->msgcontent,"A0"))
	{//

	}
	else if(strcmp(pRevMsg->msgcontent,"A1"))
		{
		
		}
		else if(strcmp(pRevMsg->msgcontent,"B0"))
			{

			}
			else if(strcmp(pRevMsg->msgcontent,"B1"))
				 {

				  }
				else if(strcmp(pRevMsg->msgcontent,"C0"))
				  	 {

				  	  }
					 else if(strcmp(pRevMsg->msgcontent,"C1"))
				  	     	  {
								
								
				  	     	    }
					         else if(strcmp(pRevMsg->msgcontent,"D0"))
				  	     	         {
				  	     	       	  
				  	     	          }
							  else if(strcmp(pRevMsg->msgcontent,"D1"))
				  	     	       	   {
											
				  	     	       	   }
							         else
							         {

								   };
	sendshortmessagethread(pRevMsg);
	
									 
}



void shortmessage_prompt_info()
{
	int fd,reval;
	int Try_Receive=3;
	struct shortmsg * pRevMsg=(struct shortmsg *)malloc(sizeof(struct shortmsg));	
	char ReceiveMessageCmd[][30]={{"ATZ\r"},{"AT+CMGF=1\r"},{"AT+CSCA=\"[phone]\"\r"},{"AT+CMGR=1\r"},{""}};

	writelog("enter shortmessage_prompt_info\n");
		  
	if((fd=Open_Init_COM(DEV))==-1)
	{
		//exit(0);
		writelog("shortmessage thread open com fail\n");
		return ;
		//continue;
	}
	
	while ((Try_Receive--)>=0)
	{	
		reval=Gprs_ReceiveMessage(fd,ReceiveMessageCmd,pRevMsg);
		if(-1==reval)
		{//
			//printf("receive message success\n");
			writelog("receive message success\n");	
				
			Gprs_DeleteMessage(fd,1);
			close(fd);
				
			messagepromptfunc(pRevMsg);
				
			break;			
		}
		else if(-2==reval)
			 {
				writelog("no shortmessage\n");
				break;
			  }
			  else
			  {
					//printf("AT COMMAND %s EXECUTE ERROR\n",ReceiveMessageCmd[reval]);
					writelog("RECEIVE AT COMMAND ERROR\n");
			  }
	}
	close(fd);	
}


void shortmessage_init_sigaction(void)
{
    struct sigaction act;
    act.sa_handler=shortmessage_prompt_info;
    act.sa_flags=0;
    sigemptyset(&act.sa_mask);
    sigaction(SIGPROF,&act,NULL);    
}

void shortmessage_init_timer()
{
    struct itimerval value;
        
    value.it_value.tv_sec=10;
    value.it_value.tv_usec=0;
    value.it_interval=value.it_value;     
    setitimer(ITIMER_PROF,&value,NULL);
}



int receiveshortmessagethread(void)
{	

	writelog("enter receiveshortmessagethread()\n");
	
	shortmessage_init_sigaction();
	shortmessage_init_timer();
	while(1)
	{
		
	}
		
	return 0;	
}