gsm_gprs.c

本程序为s3c2410实现收发短消息

// this is a test about GPRS

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <fcntl.h>	// open() close() 
#include <unistd.h>	// read() write()

#include <termios.h>	// set baud rate

#include <fcntl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>

#define FUNC_RUN		0
#define FUNC_NOT_RUN		1

#define SIMPLE_TEST 		1
#define READ_SIM_CARD_ID 	2
#define MAKE_A_CALL 		3
#define WAIT_A_CALL	 	4
#define SHORT_MESSAGE 		5
#define FUNC_QUIT 		6

#define SEND_SHORT_MESSAGE		1
#define READ_SHORT_MESSAGE		2
#define CONFIG_SHORT_MESSAGE_ENV        3
#define QUIT_SHORT_MESSAGE		4

#define DEVICE_TTYS "/dev/ttyS1"
#define MAX_LEN_OF_SHORT_MESSAGE	140


#define RECEIVE_BUF_WAIT_1S 1
#define RECEIVE_BUF_WAIT_2S 2
#define RECEIVE_BUF_WAIT_3S 3
#define RECEIVE_BUF_WAIT_4S 4
#define RECEIVE_BUF_WAIT_5S 5

//------------------------------------- read datas from GSM/GPRS --------------------------------------------
// succese return 1
// error   return 0
int read_GSM_GPRS_datas(int fd, char *rcv_buf,int rcv_wait)
{
	int retval;
	fd_set rfds;
	struct timeval tv;

	int ret,pos;

	tv.tv_sec = rcv_wait;	// wait 2.5s
        tv.tv_usec = 0;

	pos = 0; // point to rceeive buf
	
	while (1)
	{
		FD_ZERO(&rfds);
                FD_SET(fd, &rfds);

		retval = select(fd+1 , &rfds, NULL, NULL, &tv);

                if (retval == -1) 
		{
                        perror("select()");
                        break;
                }
		else if (retval) 
		{// pan duan shi fou hai you shu ju 
                        ret = read(fd, rcv_buf+pos, 2048);
                        pos += ret;
                        if (rcv_buf[pos-2] == '\r' && rcv_buf[pos-1] == '\n') 
			{
                                FD_ZERO(&rfds);
                                FD_SET(fd, &rfds);

                                retval = select(fd+1 , &rfds, NULL, NULL, &tv);

                                if (!retval) break;// no datas, break
                        }
                } 
		else 
		{
                        printf("No data\n");
                        break;
                }
	}

	return 1;
} // end read_GSM_GPRS_datas


//------------------------------------- send cmd ------------------------------------------------------------
// succese return 1
// error   return 0
int send_GSM_GPRS_cmd(int fd, char *send_buf)
{
	ssize_t ret;
	
	ret = write(fd,send_buf,strlen(send_buf));
	if (ret == -1)
        {
                printf ("write device %s error\n", DEVICE_TTYS);
                return -1;
        }

	return 1;
} // end send_GSM_GPRS_cmd

//------------------------------------- send cmd and read back result ---------------------------------------
void GSM_GPRS_send_cmd_read_result(int fd, char *send_buf, int rcv_wait)
{
        char rcv_buf[2048];

	if((send_buf==NULL) || (send_GSM_GPRS_cmd(fd,send_buf)))
	{	// send success , then read
		bzero(rcv_buf,sizeof(rcv_buf));
		if (read_GSM_GPRS_datas(fd,rcv_buf,rcv_wait))
                {
                        printf ("%s\n",rcv_buf);
                }
                else
                {
                        printf ("read error\n");
                }

	}
	else
	{
		printf("write error\n");
	}
} // end GSM_GPRS_send_cmd_read_result

//------------------------------------- send cmd : "at" to GSM/GPRS MODEM -----------------------------------
void GSM_simple_test(int fd)
{
	char *send_buf="at\r";
	
	GSM_GPRS_send_cmd_read_result(fd,send_buf,RECEIVE_BUF_WAIT_1S);

} // end GSM_simple_test

//------------------------------------- send cmd : "at+ccid" to GSM/GPRS MODEM ------------------------------
void GSM_read_sim_card_id(int fd)
{
        char *send_buf="at+ccid\r";

	GSM_GPRS_send_cmd_read_result(fd,send_buf,RECEIVE_BUF_WAIT_1S);

} // end GSM_read_sim_card_id

//------------------------------------- send cmd : "atd<tel_num>;" to GSM/GPRS MODEM ------------------------
//------------------------------------- finish call, send cmd:  "ath" to GSM MODEM --------------------------
void GSM_call(int fd)
{
	char send_buf[17];
	char *send_cmd_ath = "ath\r";
	int i;

        // input telephone number
        bzero(send_buf,sizeof(send_buf));
	
        send_buf[0]='a';
        send_buf[1]='t';
        send_buf[2]='d';
	send_buf[16] = '\0';

        printf("please input telephone number:");

        i = 3;
        while (1)
        {
                send_buf[i]=getchar();
                if (send_buf[i]=='\n') break;
                i++;
        }

        send_buf[i]=';';
        send_buf[i+1]='\r';
	// end input telphone number

	// send cmd
	GSM_GPRS_send_cmd_read_result(fd,send_buf,RECEIVE_BUF_WAIT_1S);

        //quit call
        printf("press ENTER for quit:");
        getchar();

        // send cmd
	GSM_GPRS_send_cmd_read_result(fd,send_cmd_ath,RECEIVE_BUF_WAIT_1S);
	
} // end GSM_call

//------------------------------------- wait for GSM/GPRS call signal ---------------------------------------
void GSM_wait_call(int fd)
{
	char rcv_buf[2048];
	char *send_cmd_ath = "ath\r";
        int wait_RING;

        wait_RING = 10;
        while (wait_RING!=0)
        {	
		bzero(rcv_buf,sizeof(rcv_buf));

		if (read_GSM_GPRS_datas(fd,rcv_buf,RECEIVE_BUF_WAIT_1S))
                {
                        printf ("%s\n",rcv_buf);
                }
                else
                {
                        printf ("read error\n");
                }
		wait_RING--;
        }
	
	GSM_GPRS_send_cmd_read_result(fd,send_cmd_ath,RECEIVE_BUF_WAIT_1S);

        printf("quit wait_call\n");

} // end GSM_wait_call

//------------------------------------- GSM/GPRS send short message -----------------------------------------
void GSM_Send_Message(int fd)
{
        char cmd_buf[23];
        char short_message_buf[MAX_LEN_OF_SHORT_MESSAGE];
	int  i;
        char rcv_buf;

        bzero(cmd_buf,sizeof(cmd_buf));
	bzero(short_message_buf,sizeof(short_message_buf));

        printf ("send short message:\n");

        cmd_buf[0]='a';
        cmd_buf[1]='t';
        cmd_buf[2]='+';
        cmd_buf[3]='c';
        cmd_buf[4]='m';
        cmd_buf[5]='g';
        cmd_buf[6]='s';
        cmd_buf[7]='=';
        cmd_buf[8]='"';

        printf ("please input telephone number:");

        i = 9;
        while (1)
        {
                cmd_buf[i]=getchar();
                if (cmd_buf[i]=='\n') break;
                i++;
        }
	cmd_buf[i]='"';
        cmd_buf[i+1]='\r';
	cmd_buf[i+2]='\0';

        // send cmd :  at+cmgs="(telephone number)"
	GSM_GPRS_send_cmd_read_result(fd,cmd_buf,RECEIVE_BUF_WAIT_1S);
	
 	// input short message
        printf("please input short message:");

        i = 0;
        while(i < MAX_LEN_OF_SHORT_MESSAGE-2)
        {
                short_message_buf[i] = getchar();
                if (short_message_buf[i]=='\n') break;
                i++;
        }
        short_message_buf[i] = 0x1A;
        short_message_buf[i+1] = '\r';
	short_message_buf[i+2] = '\0';

        // send short message
	GSM_GPRS_send_cmd_read_result(fd, short_message_buf,RECEIVE_BUF_WAIT_4S);

        printf("\nend send short message\n");
} // end GSM_Send_Message

//------------------------------------- GSM/GPRS read all short message -------------------------------------
void GSM_Read_Message(int fd)
{
	char *send_buf="at+cmgl=\"ALL\"\r";
	char rcv_buf[2048];

        GSM_GPRS_send_cmd_read_result(fd,send_buf,RECEIVE_BUF_WAIT_3S);

	printf("end read all short message\n");

} // end GSM_Read_Message

//------------------------------------- GSM/GPRS Config short message env -----------------------------------
void GSM_Conf_Message(int fd)
{
	char *send_buf="at+cmgf=1\r";
	char *send_center_buf="at+csca=\"[phone]\"\r";

	GSM_GPRS_send_cmd_read_result(fd,send_buf,RECEIVE_BUF_WAIT_1S);

        // set short message center number
        GSM_GPRS_send_cmd_read_result(fd,send_center_buf,RECEIVE_BUF_WAIT_1S);

        printf("end config short message env\n");
} // end GSM_Conf_Message


//------------------------------------- GSM/GPRS short message ----------------------------------------------
void GSM_short_mesg(int fd)
{
        int flag_sm_run, flag_sm_select;

        flag_sm_run = FUNC_RUN;
        while (flag_sm_run == FUNC_RUN)
        {
                printf ("\n Select:\n");
                printf ("1 : Send short message \n");
                printf ("2 : Read all short message \n");
                printf ("3 : Config short message env\n");
                printf ("4 : quit\n");
                printf (">");
                scanf("%d",&flag_sm_select);
                getchar();
		// temp
	//	printf ("input select:%d\n",flag_sm_select);
		// end temp
                switch (flag_sm_select)
                {
                        case SEND_SHORT_MESSAGE         :       { GSM_Send_Message(fd);         break; }
                        case READ_SHORT_MESSAGE         :       { GSM_Read_Message(fd);         break; }
                        case CONFIG_SHORT_MESSAGE_ENV   :       { GSM_Conf_Message(fd);         break; }
                        case QUIT_SHORT_MESSAGE         :       { flag_sm_run = FUNC_NOT_RUN;	break; }
                        default :
                                {
                                        printf("please input your select use 1 to 3\n");
                                }
                }
        }
        printf ("\n");

} // end GSM_send_mesg

//------------------------------------- print ---------------------------------------------------------------
void print_prompt(void)
{
        printf ("Select what you want to do:\n");
        printf ("1 : Simple Test\n");
        printf ("2 : Read SIM CARD ID\n");
        printf ("3 : Make A Call\n");
        printf ("4 : Wait A Call\n");
        printf ("5 : Short message\n");
        printf ("6 : Quit\n");
        printf (">");
} // end print_prompt

//------------------------------------- Control GSM/GPRS MODULE ---------------------------------------------
void func_GSM(int fd)
{
        int flag_func_run;
        int flag_select_func;
        ssize_t ret;

        flag_func_run = FUNC_RUN;

        while (flag_func_run == FUNC_RUN)
        {
                print_prompt();			// print select functions
                scanf("%d",&flag_select_func);	// user input select
                getchar();

                switch(flag_select_func)
                {
                        case SIMPLE_TEST        : {GSM_simple_test(fd);         break;}
                        case READ_SIM_CARD_ID   : {GSM_read_sim_card_id(fd);    break;}
                        case MAKE_A_CALL        : {GSM_call(fd);                break;}
                        case WAIT_A_CALL        : {GSM_wait_call(fd);           break;}
                        case SHORT_MESSAGE      : {GSM_short_mesg(fd);          break;}
                        case FUNC_QUIT          :
                                                {
                                                        flag_func_run = FUNC_NOT_RUN;
                                                        printf("Quit GSM/GPRS function.  byebye\n");
                                                        break;
                                                }
                        default :
                        {
                                printf("please input your select use 1 to 7\n");
                        }
                }

        }
}// end func_GPRS

//------------------------------------- init seriel port  ---------------------------------------------------
void init_ttyS(int fd)
{
        struct termios options;

        bzero(&options, sizeof(options));       // clear options

        cfsetispeed(&options,B9600);            // setup baud rate
        cfsetospeed(&options,B9600);

        options.c_cflag |= (CRTSCTS | CS8 | CLOCAL | CREAD);
	options.c_iflag = IGNPAR;

	tcflush(fd, TCIFLUSH);

        tcsetattr(fd, TCSANOW, &options);

}//end init_ttyS


//------------------------------------- main ----------------------------------------------------------------
int main(void)
{
        int fd;

        printf("\nGSM/GPRS TESTS\n\n");

        // open seriel port
        fd = open(DEVICE_TTYS, O_RDWR);

        if (fd == -1)
        {
                printf("open device %s error\n",DEVICE_TTYS);
        }
        else
        {
		init_ttyS(fd);	// init device
		func_GSM(fd);	// GSM/GPRS functions
                
		// close ttyS0
                if (close(fd)!=0) printf("close device %s error",DEVICE_TTYS);
        }

        return 0;
}// end main