STM32F103 GU906B模块GPRS、短信收发、拨号等功能的实现

这个程序搞了我很久，尤其是对如何提高响应速度上，程序流程很简单，大概就是：

发送AT指令->等待模块响应->一旦响应了，立即返回，并处理掉。

这个程序不一定只能用在GU906上，程序框架在任何GPRS模块上都能用，只要修改相应的AT指令，按照对应模块的AT指令流程，做下流程上的修改，就没啥问题，框架很简单，不像某宝上店家的那些代码一样，那些代码反正我是看的头晕，程序接口我都留着，只要按照相应的流程调用接口就好。

下面是模块的代码gu906.c文件

[objc] view plain copy
  1. //                            _ooOoo_    
  2. //                           o8888888o    
  3. //                           88" . "88    
  4. //                           (| -_- |)    
  5. //                            O\ = /O    
  6. //                        ____/`---'\____    
  7. //                      .   ' \\| |// `.    
  8. //                       / \\||| : |||// \    
  9. //                     / _||||| -:- |||||- \    
  10. //                       | | \\\ - /// | |    
  11. //                     | \_| ''\---/'' | |    
  12. //                      \ .-\__ `-` ___/-. /    
  13. //                   ___`. .' /--.--\ `. . __    
  14. //                ."" '< `.___\_<|>_/___.' >'"".    
  15. //               | | : `- \`.;`\ _ /`;.`/ - ` : | |    
  16. //                 \ \ `-. \_ __\ /__ _/ .-` / /    
  17. //         ======`-.____`-.___\_____/___.-`____.-'======    
  18. //                            `=---='    
  19. //    
  20. //         .............................................    
  21. //                  佛祖保佑             永无BUG   
  22. //          佛曰:    
  23. //                 写字楼里写字间，写字间里程序员；    
  24. //                 程序人员写程序，又拿程序换酒钱。    
  25. //                 酒醒只在网上坐，酒醉还来网下眠；    
  26. //                 酒醉酒醒日复日，网上网下年复年。    
  27. //                 但愿老死电脑间，不愿鞠躬老板前；    
  28. //                 奔驰宝马贵者趣，公交自行程序员。    
  29. //                 别人笑我忒疯癫，我笑自己命太贱；    
  30. //                 不见满街漂亮妹，哪个归得程序员？    
  31. //////////////////////////////////////////////////////////  
  32. #include <string.h>  
  33. #include <stdlib.h>  
  34. #include "stdio.h"  
  35. #include "delay.h"  
  36. #include "config.h"  
  37. #include "usart4.h"  
  38. #include "gu906.h"  
  39.   
  40. #define DEBUG_EN  1  
  41.   
  42. //接收缓存  
  43. #define MAXRECVBUFF  USART4_BUFF  
  44.   
  45. #define AT                  "AT\r\n"                                        //测试命令  
  46. #define ATE(x)              ((x)?("ATE1\r\n"):("ATE0\r\n"))                 //开回显、关回显   
  47. #define ATESIM              "AT+ESIMS?\r\n"                                 //检测卡是否存在  
  48. #define ATCNMI              "AT+CNMI=2,1\r\n"                               //设置这组参数来了新信息存储起来   
  49. #define ATCMGD              "AT+CMGD=1,4\r\n"                               //删除当前存储器中全部短信   
  50. #define ATCMGF              "AT+CMGF=1\r\n"                                 //0设置短消息为PDU模式, 1设置短消息为txet模式  
  51. #define ATCSMP              "AT+CSMP=17,167,2,25\r\n"                       //设置文本模式的参数  
  52. #define ATUCS2              "AT+CSCS=\"UCS2\"\r\n"                          //设置为 UCS2 编码字符集  
  53. #define ATGB2312            "AT+CSCS=\"GB2312\"\r\n"                        //设置GB2312编码  
  54. #define ATATD               "ATD%s;\r\n"                                    //对指定手机拨号  
  55. #define ATATH               "ATH\r\n"                                       //挂机  
  56. #define ATGSM               "AT+CSCS=\"GSM\"\r\n"                           //设置GSM字符集    
  57. #define ATCPMS              "AT+CPMS=\"SM\",\"SM\",\"SM\"\r\n"              //设置短信存储单元为SIM卡   
  58. #define ATCSQ               "AT+CSQ\r\n"                                    //获取信号强度  
  59. #define ATCREG              "AT+CREG?\r\n"                                  //确保模块以及注册到GSM网络  
  60. #define ATCIICR             "AT+CIICR\r\n"                                  //让模块激活 GPRS 网络，在需要反复建立 TCP 链接的场合可提高速度         
  61. #define ATCIPSTARTOK        "AT+CIPSTART?\r\n"                              //查询当前是否有网络连接  
  62. #define ATCIPCLOSE          "AT+CIPCLOSE=0\r\n"                             //关闭网络连接  
  63. #define ATCIPSCONT(x)       ((x)?("AT+CIPSCONT=0,\"%s\",\"%s\",%d,2")\  
  64.                                 :("AT+CIPSCONT\r\n"))                       //保存设置       
  65. #define ATCIPSTART          "AT+CIPSTART=\"%s\",\"%s\",%d\r\n"              //设置TCP连接的IP和端口  
  66. #define ATCIPMUX            "AT+CIPMUX=0\r\n"                               //单链接模式  
  67. #define ATCIPMODE(x)        ((x)?("AT+CIPMODE=1,0\r\n")\  
  68.                                 :("AT+CIPMODE=0,0\r\n"))                    //数据透传输模式、非透传  
  69. #define ATCIPCFG(x)         ((x)?("AT+CIPCFG=1,50,0\r\n")\  
  70.                                 :("AT+CIPCFG=0,50,0\r\n"))                  //自动启动连接命令                        
  71. #define ATCIPPACK(x)        ((x)?("AT+CIPPACK=1,\"4C4F47494E3A31303031\"\r\n")\  
  72.                                 :("AT+CIPPACK=0,\"0102A0\"\r\n"))           //设备注册包、心跳包设置  
  73. #define ATCIPSEND(x)        ((x)?("AT+CIPSEND=%d\r\n")\  
  74.                                 :("AT+CIPSEND\r\n"))                        //设置发送的数据长度  
  75. #define ATCGMR              "AT+CGMR\r\n"                                   //获取基站信息            
  76. #define ATCMGS              "AT+CMGS=\"%s\"\r\n"                            //设置需要发送短信的手机号  
  77. #define ATCMGR              "AT+CMGR=%s\r\n"                                //设置要读取的短信的位置  
  78. #define ATCSTT              "AT+CSTT=\"CMNET\"\r\n"                         //账号配置  
  79. #define ATCIPSCONT_C        "AT+CIPSCONT?\r\n"                              //查询透传连接情况              
  80. #define GPRSSEND            0x1A                                   
  81. #define CLOSEDTU            "+++"                                            //关闭透传  
  82. #define OPENDTU             "ATO0\r\n"                                      //重新进入透传  
  83.   
  84. enum order{  
  85.     //与命令对应的  
  86.     _AT = 1,_ATE,_ATESIM,_ATCNMI,_ATCMGD,_ATCMGF,_ATCSMP,_ATUCS2,  
  87.     _ATGB2312,_ATATD,_ATATH,_ATGSM,_ATCPMS,_ATCSQ,_ATCREG,  
  88.     _ATCIICR,_ATCIPSTARTOK,_ATCIPCLOSE,_ATCIPSCONT,_ATCIPSTART,  
  89.     _ATCIPMUX,_ATCIPMODE,_ATCIPCFG,_ATCIPPACK,_ATCIPSEND,_ATCGMR,  
  90.     _ATCMGS,_ATCMGR,_GPRSSEND,_ATCSTT,_ATCIPSCONT_C,_CLOSEDTU,_OPENDTU,  
  91.       
  92.     //额外的数据类型  
  93.     _GSMSEND,_GSMSENDEND  
  94. };  
  95.   
  96. struct GprsData{  
  97.     charchar *order;     
  98.     int olen;           
  99.     enum order type;      
  100. };  
  101.   
  102. //GPRS数据保存位置  
  103. static char GPRS_Data[MAXRECVBUFF]={0};  
  104. static int  GPRS_Dlen = 0;  
  105. static u8   GPRS_Dtu_ConLock = 0;  
  106.   
  107. u8 RestartGprs = 0; //重启GPRS标志  
  108.   
  109. #if GU906GSM_EN  
  110. //短信信息在SIM卡中的位置  
  111. static char SIMDataID[5]="";   
  112. struct user_simdata sim;  
  113. #endif  
  114.   
  115. /********************************************************* 
  116.   * @function  GPRS_ascii_to_hex 
  117.   * @role       
  118.   * @input      
  119.   * @output    None 
  120.   * @return     
  121.   ********************************************************/  
  122. static int GPRS_ascii_to_hex(u8 *asc_data, u8 *hex_data, int len)  
  123. {  
  124.     int i;  
  125.     u8 tmp_dat;  
  126.     for(i = 0; i < len; i++)  
  127.     {  
  128.         if ((asc_data[i] >= '0') && (asc_data[i] <= '9')){  
  129.             tmp_dat = asc_data[i] - '0';  
  130.         }else if ((asc_data[i] >= 'A') && (asc_data[i] <= 'F')){ // A....F  
  131.             tmp_dat = asc_data[i] - 0x37;  
  132.         }  
  133.         else if((asc_data[i] >= 'a') && (asc_data[i] <= 'f')){ // a....f  
  134.             tmp_dat = asc_data[i] - 0x57;  
  135.         }else return -1;  
  136.         hex_data[i] = tmp_dat;    
  137.     }  
  138.     return 0;  
  139. }  
  140.   
  141. /********************************************************* 
  142.   * @function  mypow 
  143.   * @role      pow库函数的实现，计算num的n次幂，其中n为整数  
  144.   * @input     num 
  145.   * @output    n 
  146.   * @return    计算结果 
  147.   ******************************************************* 
  148. static int mypow(int num,int n) 
  149. { 
  150.     int powint=1; 
  151.     int i; 
  152.     for(i=1;i<=n;i++) powint*=num; 
  153.     return powint; 
  154. } 
  155. */  
  156. /********************************************************* 
  157.   * @function  FreeStr 
  158.   * @role      删除字符串中的字串，支持16进制数据，无视结束符 
  159.   * @input     字符串、字符串总长度、开始删除的起始位置、要删除的长度 
  160.   * @output    None 
  161.   * @return    None 
  162.   ********************************************************/  
  163. static void FreeStr(charchar *str, int strsiz, int head, int len)  
  164. {  
  165.     int i = 0;  
  166.     while(len--)  
  167.     {  
  168.         for(i = head; i < strsiz;i++)  
  169.         {  
  170.             str[i] = str[i+1];  
  171.         }  
  172.     }  
  173. }  
  174.   
  175. #if GU906GSM_EN  
  176. /********************************************************* 
  177.   * @function  GU906_ParsingSIM 
  178.   * @role      解析SIM卡中的短信数据 
  179.   * @input     卡中的数据 
  180.   * @output    None 
  181.   * @return    成功返回：0，失败返回：-1 
  182.     @data       
  183.     +CMGR: "REC READ","18750******",,"2015/03/14 20:02:15+32" 
  184.      124abcABC 
  185.  
  186.     OK 
  187.   ********************************************************/  
  188. static int GU906_ParsingSIM(charchar *pinput)  
  189. {  
  190.     charchar *p = pinput;  
  191.     int i;  
  192.     #if DEBUG_EN  
  193.     printf("\n分离手机号\n");  
  194.     #endif  
  195.     if((p = strstr(p,"\",\"")) == 0)  
  196.         return -1;  
  197.     p += 3;  
  198.     memset(sim.phone,0,sizeof(sim.phone));  
  199.     for (i = 0; (*p != '\"') && (*p != '\0'); ++i,p++){  
  200.         sim.phone[i] = *p;  
  201.     }  
  202.     sim.phone[i] = '\0';  
  203.     #if DEBUG_EN  
  204.     printf("sms.phone[%s]\r\n",sim.phone);  
  205.     printf("\n分离设备类型\n");  
  206.     #endif  
  207.       
  208.     p +=2;  
  209.     memset(sim.dev,0,sizeof(sim.dev));  
  210.     for (i = 0; (*p != ',') && (*p != '\0'); ++i,p++){  
  211.         sim.dev[i] = *p;  
  212.     }  
  213.     #if DEBUG_EN  
  214.     printf("sms.dev[%s]\r\n",sim.dev);  
  215.     printf("\n分离时间\n");  
  216.     #endif  
  217.       
  218.     p += 2;  
  219.     memset(sim.date,0,sizeof(sim.date));  
  220.     for (i = 0; (*p != '\"') && (*p != '\0'); ++i,p++){  
  221.         sim.date[i] = *p;  
  222.     }  
  223.     #if DEBUG_EN  
  224.     printf("sms.date[%s]\r\n",sim.date);  
  225.     printf("\n分离数据\n");  
  226.     #endif  
  227.       
  228.     p++;  
  229.     memset(sim.data,0,sizeof(sim.data));  
  230.     while((*p != '\0') && ((*p == '\n') || (*p == '\r')) ) p++;  
  231.     for (i = 0; (*p != '\0') && (*p != '\n') && (*p != '\r'); ++i,p++){  
  232.         sim.data[i] = *p;  
  233.     }  
  234.     sim.data[i] = '\0';  
  235.     #if DEBUG_EN  
  236.     printf("sms.data:[%s]\r\n",sim.data );  
  237.     #endif  
  238.     return 0;  
  239. }  
  240. #endif  
  241.   
  242. /********************************************************* 
  243.   * @function  GetRecvData 
  244.   * @role      提取字符串中跟命令无关的数据,有时在进行命令操作时， 
  245.                会突然收到短信，什么的，这里要做的就是处理并过滤掉这些数据。 
  246.                还有模块突然复位了，这里也做判断，并复位CPU。 
  247.   * @input     数据和数据长度 
  248.   * @output    None 
  249.   * @return    None 
  250.   ********************************************************/  
  251. static void GetRecvData(charchar *pBuff, intint *pLen)  
  252. {  
  253.     int rlen = 0;  
  254.     char buff[5]="";  
  255.     int i = 0;  
  256.     charchar *p1 = NULL;  
  257.     charchar *p2 = NULL;      
  258.   
  259.     if((pBuff == NULL) || (*pLen == 0))  
  260.         return;  
  261.     if (((p1 = strstr(pBuff, "+IPD,")) != 0) && ((p2 = strchr(pBuff, ':')) != 0))  
  262.     {  
  263.         p1+=5;  
  264.         for (i = 0; ((p1-pBuff) < *pLen) && (i < 5) && (*p1 != ':'); ++i,++p1) {  
  265.             buff[i] = *p1;  
  266.         }  
  267.         buff[i] = '\0';  
  268.         rlen = atoi(buff);  
  269.         p2++;  
  270.         GPRS_Dlen = ((rlen >= (*pLen - (p2 - pBuff)))?(*pLen - (p2 - pBuff)):rlen);  
  271.         memcpy(GPRS_Data, p2,GPRS_Dlen);  
  272.         rlen = GPRS_Dlen;  
  273.           
  274.         p1 = strstr(pBuff, "+IPD,");  
  275.         p2 = strchr(pBuff, ':');  
  276.         rlen += ((p2+1)-p1);  
  277.         FreeStr(pBuff, *pLen,p1-pBuff, rlen);  
  278.         if((*pLen -rlen) <=3)  
  279.             *pLen = 0;  
  280.         else  
  281.             *pLen -=rlen;  
  282.         #if DEBUG_EN  
  283.         printf("B[%d][%s]\r\n",*pLen, pBuff);  
  284.         #endif  
  285.     }  
  286.     #if GU906GSM_EN  
  287.     else if (strstr(pBuff, "+CMTI:") && ((p1 = strchr(pBuff, ',')) != 0)){   //+CMTI: "SM",2 有短信消息到来    
  288.         rlen = 0;  
  289.         p1++;  
  290.         for(i = 0; *p1 != '\r' && *p1 != '\n' && *p1 != '\0' && rlen < sizeof(SIMDataID);i++, p1++){  
  291.             if(*p1 >= '0' && *p1 <= '9')  
  292.                 SIMDataID[rlen++] = *p1;  
  293.         }  
  294.         SIMDataID[rlen] = '\0';   
  295.     }  
  296.     else if ((p1 = strstr(pBuff, "+CMGR:")) != 0){ //读取到短消息  
  297.         GU906_ParsingSIM(p1);  
  298.     }  
  299.     #endif  
  300.     else if(strstr(pBuff,"[0000]") || strstr(pBuff,"Build Time"))   
  301.     {  
  302.         #if (DEBUG_EN == 1)  
  303.         printf("restart...\r\n\r\n");  
  304.         #endif  
  305.         RestartGprs = 1;  
  306.     }  
  307. }  
  308.   
  309. /********************************************************* 
  310.   * @function  GetFreeBuff 
  311.   * @role      处理掉缓存中多余的数据,同时也起到延时200ms的作用， 
  312.                读取数据函数自带延时10ms，所以这里num=20, 
  313.                GU906发送命令不能太快，不然GU906会因为处理不过来，而导致出错。 
  314.   * @input     None 
  315.   * @output    None 
  316.   * @return    None 
  317.   ********************************************************/  
  318. static void GetFreeBuff(int num)  
  319. {  
  320.     char buff[MAXRECVBUFF] = {0};  
  321.     int siz = 0;  
  322.     while(num--)  
  323.     {  
  324.         siz = usart4_Receive(buff,MAXRECVBUFF);  
  325.         if(siz)  
  326.         {  
  327.             GetRecvData(buff, &siz);      
  328.         }  
  329.     }  
  330. }  
  331.   
  332.       
  333. /********************************************************* 
  334.   * @function  SendAT 
  335.   * @role      发送AT指令并接收 
  336.   * @input     gprs：要发送的参数 
  337.   * @output    out：返回的参数 
  338.   * @return    成功返回：_ATOK，失败返回：_ATERROR 
  339.   ********************************************************/  
  340. static s8 SendAT(struct GprsData *gprs, charchar *out, u32 Delay)  
  341. {  
  342.     int siz = 0;  
  343.     int i = 0;  
  344.     charchar *p = gprs->order;    
  345.     u8 dat[2];  
  346.     u8 csq = 0;  
  347.     s8 ret = _ATERROR;  
  348.     char buff[MAXRECVBUFF] = {0};  
  349.     RestartGprs = 0;  
  350.   
  351. #if (DEBUG_EN == 1)  
  352.     printf("\r\n------------------------------\r\n");  
  353.     printf("len[%d]\r\n", gprs->olen);  
  354.     for(i = 0; i< gprs->olen; i++,++p)  
  355.         printf("%c", *p);  
  356.     printf("\r\n");  
  357. #endif  
  358.     i = 0;  
  359.     p = NULL;  
  360.     GetFreeBuff(10);  
  361.     usart4_Send(gprs->order,gprs->olen);  
  362.     if((gprs->type == _GSMSEND) || (gprs->type == _ATATD))   
  363.     {  
  364.         ret = _ATOK;  
  365.         goto GU906_SENDATRET;  
  366.     }  
  367.   
  368.     while(1)  
  369.     {  
  370.         for(i = 0;i<sizeof(buff);i++)   
  371.             buff[i]=0;  
  372.         siz = 0; i = 0;  
  373.         while(siz == 0)  
  374.         {  
  375.             siz = usart4_Receive(buff,MAXRECVBUFF);  
  376.             if(siz){  
  377.                 #if (DEBUG_EN == 1)  
  378.                 printf("\r\nrecv:\r\n");  
  379.                 printf("[%s]\r\n",buff);  
  380.                 #endif  
  381.                 GetRecvData(buff, &siz);  
  382.             }  
  383.             if(i++ > Delay)   
  384.             {  
  385.                 ret = _ATOTIME;  
  386.                 goto GU906_SENDATRET;  
  387.             }  
  388.         }  
  389.           
  390.         if(RestartGprs){  
  391.             ret = _ATERROR;  
  392.             goto GU906_SENDATRET;  
  393.         }  
  394.           
  395.         switch(gprs->type)  
  396.         {  
  397.             case _AT:  
  398.             case _ATE:     
  399.             case _ATCNMI:  
  400.             case _ATCMGD:  
  401.             case _ATCMGF:  
  402.             case _ATCSMP:  
  403.             case _ATUCS2:  
  404.             case _ATATH :  
  405.             case _ATGSM :  
  406.             case _ATCSTT:  
  407.             case _ATCIICR:  
  408.             case _ATCIPCFG:  
  409.             case _ATCIPPACK:  
  410.             case _ATCIPSCONT:  
  411.             case _OPENDTU:  
  412.             case _CLOSEDTU:  
  413.             case _ATGB2312:  
  414.                 if(strstr(buff, "OK")){  
  415.                     ret = _ATOK;  
  416.                     goto GU906_SENDATRET;  
  417.                 }else if(strstr(buff, "ERROR") || strstr(buff,"NO CARRIER")) {  
  418.                     GetFreeBuff(100);  
  419.                     ret = _ATERROR;  
  420.                     goto GU906_SENDATRET;  
  421.                 }  
  422.             break;  
  423.                   
  424.             case _ATCPMS:  
  425.                 if(strstr(buff, "OK") && strstr(buff, "+CPMS:")){  
  426.                      ret = _ATOK;  
  427.                      goto GU906_SENDATRET;  
  428.                 }else if(strstr(buff, "ERROR")){  
  429.                     ret = _ATERROR;  
  430.                     goto GU906_SENDATRET;  
  431.                 }  
  432.                 break;  
  433.                   
  434.             case _ATESIM:  
  435.                 ret = _ATERROR;  
  436.                 if(strstr(buff, "OK"))  
  437.                 {  
  438.                     if((p = strstr(buff, "+ESIMS: ")) != 0)  
  439.                     {  
  440.                         p += 8;  
  441.                         if(1 == (*p -'0'))  
  442.                             ret = _ATOK;      
  443.                     }  
  444.                     goto GU906_SENDATRET;  
  445.                 }  
  446.                 break;  
  447.               
  448.             case _ATCMGS:  
  449.                 if(strstr(buff, ">")){  
  450.                     GetFreeBuff(1);  
  451.                     ret = _ATOK;  
  452.                     goto GU906_SENDATRET;  
  453.                 }  
  454.                 break;  
  455.   
  456.             case _ATCSQ:  
  457.                 if(strstr(buff, "OK"))  
  458.                 {  
  459.                     if((p = strstr(buff, "+CSQ:")) != 0)  
  460.                     {  
  461.                         GPRS_ascii_to_hex((u8 *)(p+6), dat, 2);  
  462.                         csq = dat[0]*10 + dat[1];  
  463.                         #if DEBUG_EN  
  464.                         printf("信号:[%d]\r\n", csq);  
  465.                         #endif    
  466.                         if (csq < 99 && csq >= GPRSCSQ){ //网络信号要大于GPRSCSQ(18)  
  467.                             ret = _ATOK;  
  468.                             goto GU906_SENDATRET;  
  469.                         } else {  
  470.                             ret = _ATERROR;  
  471.                             goto GU906_SENDATRET;  
  472.                         }     
  473.                     }  
  474.                 }  
  475.                 else{  
  476.                     ret = _ATERROR;  
  477.                     goto GU906_SENDATRET;  
  478.                 }  
  479.                 break;  
  480.   
  481.             case _ATCIPSTARTOK:  
  482.                 if(strstr(buff, "OK"))  
  483.                 {  
  484.                     if (strstr(buff, "+CIPSTART:")) {  
  485.                         ret = _ATOK;  
  486.                         goto GU906_SENDATRET;  
  487.                     }     
  488.                     ret = _ATERROR;  
  489.                     goto GU906_SENDATRET;                     
  490.                 }else if(strstr(buff, "ERROR")) {  
  491.                     ret = _ATERROR;  
  492.                     goto GU906_SENDATRET;  
  493.                 }  
  494.                 break;                
  495.               
  496.             case _ATCREG:  
  497.                 if(strstr(buff, "OK"))  
  498.                 {  
  499.                     if ((p = strstr(buff, "+CREG: ")) != 0)  
  500.                     {  
  501.                         p += 7;  
  502.                         if(('0' == *p) || ('5' == *p))   
  503.                         {  
  504.                             ret = _ATOK;  
  505.                             goto GU906_SENDATRET;  
  506.                         }  
  507.                     }     
  508.                     ret = _ATERROR;  
  509.                     goto GU906_SENDATRET;                     
  510.                 }else if(strstr(buff, "ERROR")) {  
  511.                     ret = _ATERROR;  
  512.                     goto GU906_SENDATRET;  
  513.                 }  
  514.                 break;  
  515.   
  516.             case _ATCIPSEND:  
  517.                 if (strstr(buff, ">")) {  
  518.                     ret = _ATOK;  
  519.                     goto GU906_SENDATRET;  
  520.                 }  
  521.                 else if (strstr(buff, "ERROR")){  
  522.                     ret = _ATERROR;  
  523.                     goto GU906_SENDATRET;  
  524.                 }  
  525.             break;  
  526.   
  527.             case _ATCIPMUX:  
  528.                 if(strstr(buff, "+CIPMUX: 0") && strstr(buff, "OK")) {  
  529.                     ret = _ATOK;  
  530.                     goto GU906_SENDATRET;  
  531.                 }else if (strstr(buff, "ERROR")){  
  532.                     ret = _ATERROR;  
  533.                     goto GU906_SENDATRET;  
  534.                 }  
  535.                 break;  
  536.   
  537.             case _ATCIPMODE:  
  538.                 if(strstr(buff, "+CIPMODE: ") && strstr(buff, "OK")) {  
  539.                     ret = _ATOK;  
  540.                     goto GU906_SENDATRET;  
  541.                 }else if (strstr(buff, "ERROR")){  
  542.                     ret = _ATERROR;  
  543.                     goto GU906_SENDATRET;  
  544.                 }  
  545.                 break;  
  546.   
  547.             case _GPRSSEND:  
  548.                 if(strstr(buff, "SEND OK")) {  
  549.                    ret = _ATOK;  
  550.                    goto GU906_SENDATRET;  
  551.                 }  
  552.             break;  
  553.   
  554.             case _ATCMGR:  
  555.                 GetRecvData(buff, &siz);  
  556.                 ret = _ATOK;  
  557.                 goto GU906_SENDATRET;  
  558.             //break;   
  559.   
  560.             case _ATCIPCLOSE:  
  561.                 if (strstr(buff, "CLOSE OK") || strstr(buff, "+CME ERROR:")) {  
  562.                     ret = _ATOK;  
  563.                     goto GU906_SENDATRET;  
  564.                 }  
  565.                 else if(strstr(buff, "ERROR")){  
  566.                     ret = _ATERROR;  
  567.                     goto GU906_SENDATRET;     
  568.                 }  
  569.             break;  
  570.   
  571.             case _ATCIPSTART:  
  572.                 if(!GPRS_Dtu_ConLock)  
  573.                 {  
  574.                     if(strstr(buff, "CONNECT OK")){  
  575.                         ret = _ATOK;  
  576.                         goto GU906_SENDATRET;  
  577.                     }  
  578.                     else if(strstr(buff, "RECONNECTING") || strstr(buff, "ERROR") || strstr(buff, "CONNECT FAIL")){  
  579.                         GetFreeBuff(100);  
  580.                         ret = _ATERROR;  
  581.                         goto GU906_SENDATRET;  
  582.                     }                      
  583.                 }  
  584.                 else if(strstr(buff, "OK")){  
  585.                     ret = _ATOK;  
  586.                     goto GU906_SENDATRET;  
  587.                 }  
  588.                 else if(strstr(buff, "ERROR")){  
  589.                     ret = _ATERROR;  
  590.                     goto GU906_SENDATRET;     
  591.                 }  
  592.                 break;  
  593.               
  594.             case _GSMSENDEND:   
  595.                 GetFreeBuff(100);  
  596.                 ret = _ATOK;  
  597.                 goto GU906_SENDATRET; //忽略返回信息  
  598.                 /* 
  599.                 if(strstr(buff, "+CMGS:")) { 
  600.                     if(strstr(buff, "OK")) 
  601.                         return _ATOK; 
  602.                     lock = 1; 
  603.                 } 
  604.                 else if(lock && strstr(buff, "OK")) { 
  605.                     return _ATOK; 
  606.                 }else return _ATOK; //忽略返回信息 
  607.                 break; 
  608.                 */  
  609.             case _ATCIPSCONT_C:  
  610.                 if(strstr(buff,"OK"))  
  611.                 {  
  612.                     printf("Line:%d\r\n",__LINE__);  
  613.                     if(0 != (p = strstr(buff,"+CIPMODE: ")))  
  614.                     {  
  615.                         p += 10;  
  616.                         printf("Line:%d\r\n",__LINE__);  
  617.                         if(1 == (*p -'0'))  
  618.                         {  
  619.                             printf("Line:%d\r\n",__LINE__);  
  620.                             if(0 != (p = strstr(buff,"+CIPSTART: ")))  
  621.                             {  
  622.                                 printf("Line:%d\r\n",__LINE__);  
  623.                                 if(strstr(buff,"218.66.59.201") && strstr(buff,"8888"))  
  624.                                 {  
  625.                                     printf("DTU OK\r\n");  
  626.                                     GPRS_Dtu_ConLock = 1;  
  627.                                     ret = _ATOK;  
  628.                                     goto GU906_SENDATRET;  
  629.                                 }  
  630.                             }                         
  631.                         }  
  632.                     }  
  633.                     GPRS_Dtu_ConLock = 0;  
  634.                     ret = _ATOK;  
  635.                     goto GU906_SENDATRET;  
  636.                 }else if(strstr(buff, "ERROR")){  
  637.                     ret = _ATERROR;  
  638.                     goto GU906_SENDATRET;     
  639.                 }  
  640.                 break;  
  641.                   
  642.             default: break;   
  643.         }     
  644.     }  
  645.     GU906_SENDATRET:  
  646.     return ret;  
  647. }  
  648.   
  649. /********************************************************* 
  650.   * @function  GU906_ExecuteOrder 
  651.   * @role      执行命令 
  652.   * @input     None 
  653.   * @output    None 
  654.   * @return    成功返回：_ATOK，失败返回：_ATERROR，超时返回：_ATOTIME 
  655.   ********************************************************/  
  656. static s8 GU906_ExecuteOrder(charchar *Order, u32 len, enum order type, u32 num)  
  657. {  
  658.     u32 i = 0;  
  659.     u32 delay_time = 1000;  
  660.     s8 ret = _ATOTIME;  
  661.     struct GprsData gprs;  
  662.       
  663.     if(type == _ATCIPSTART)  
  664.         delay_time = 4000;  
  665.     if(type == _GPRSSEND)  
  666.         delay_time = 10;  
  667.       
  668.     gprs.order = Order;  
  669.     gprs.olen = len;  
  670.     gprs.type = type;  
  671.     while((ret = SendAT(&gprs, NULL, delay_time)) != _ATOK)  
  672.     {  
  673.         if(ret == _ATERROR) {  
  674.             if(++i >= num) return _ATERROR;  
  675.             delay_s(1);  
  676.         }else return _ATOTIME;  
  677.     }  
  678.     return _ATOK;  
  679. }  
  680.   
  681. /********************************************************* 
  682.   * @function  GU906_init 
  683.   * @role      GSM初始化 
  684.   * @input     None 
  685.   * @output    None 
  686.   * @return    成功返回：_ATOK，失败返回：_ATERROR，超时返回：_ATOTIME 
  687.   ********************************************************/  
  688. s8 GU906_init(void)  
  689. {  
  690.     s8 ret = _ATOTIME;  
  691.   
  692.     // 开回显:ATE1 关回显:ATE0  
  693.     if(_ATOK != (ret = GU906_ExecuteOrder(ATE(0), strlen(ATE(0)), _ATE, 2)))  
  694.         return ret;  
  695.       
  696.     // 查询卡是否存在  
  697.     if(_ATOK != (ret = GU906_ExecuteOrder(ATESIM, strlen(ATESIM), _ATESIM, 10)))   
  698.         return ret;  
  699.   
  700. #if GU906GSM_EN  
  701.     // 设置短信模式为text模式  
  702.     if(_ATOK != (ret = GU906_ExecuteOrder(ATCMGF, strlen(ATCMGF), _ATCMGF, 2)))   
  703.         return ret;  
  704.   
  705.     // 设置短信存储单元为SIM卡  
  706.     if(_ATOK != (ret = GU906_ExecuteOrder(ATCPMS, strlen(ATCPMS), _ATCPMS, 2)))   
  707.         return ret;  
  708.   
  709.     // 设置这组参数来了新信息存储起来  
  710.     if(_ATOK != (ret = GU906_ExecuteOrder(ATCNMI, strlen(ATCNMI), _ATCNMI, 2)))   
  711.         return ret;  
  712. #endif  
  713.       
  714.     //删除SIM卡中的所有短信  
  715.     if(_ATOK != (ret = GU906_ExecuteOrder(ATCMGD, strlen(ATCMGD), _ATCMGD, 2)))   
  716.         return ret;  
  717.   
  718.     //查询信号强度 信号强度大于等于18才行  
  719.     while(_ATOK != (ret = GU906_ExecuteOrder(ATCSQ, strlen(ATCSQ), _ATCSQ, 60)))  
  720.     {  
  721.         if(ret == _ATOTIME) return ret;  
  722.     }  
  723.     return _ATOK;    
  724. }  
  725.   
  726. /********************************************************* 
  727.   * @function  GU906_Module_State 
  728.   * @role      判断GU906的状态 
  729.   * @input     None 
  730.   * @output    None 
  731.   * @return    成功返回：_ATOK，失败返回：_ATERROR，超时返回：_ATOTIME 
  732.   ********************************************************/  
  733. s8 GU906_Module_State(void)  
  734. {  
  735.     return GU906_ExecuteOrder(AT, strlen(AT), _AT, 0);  
  736. }  
  737.   
  738. /********************************************************* 
  739.   * @function  GU906_TCP_Socket 
  740.   * @role      进行TCP连接 
  741.   * @input     IP地址与端口 
  742.   * @output    None 
  743.   * @return    成功返回：_ATOK，失败返回：_ATERROR，超时返回：_ATOTIME 
  744.   ********************************************************/  
  745. s8 GU906_TCP_Socket(struct Gprs_Config *GprsCon)  
  746. {  
  747.     char cipstart[100] = {0};  
  748.     s8 ret = _ATOTIME;  
  749.       
  750.     if(GprsCon->server_ip == NULL || !GprsCon->server_port) return ret;  
  751.     if(!strlen((charchar *)GprsCon->server_ip)) return ret;  
  752.       
  753.     //确保模块以及注册到GSM网络  
  754.     if(_ATOK != (ret = GU906_ExecuteOrder(ATCREG, strlen(ATCREG), _ATCREG, 2)))   
  755.         return ret;  
  756.   
  757.     //让模块激活 GPRS 网络，在需要反复建立 TCP 链接的场合可提高速度  
  758.     if(_ATOK != (ret = GU906_ExecuteOrder(ATCIICR, strlen(ATCIICR), _ATCIICR, 2)))   
  759.         return ret;  
  760.       
  761.     //查询当前是否有网络连接  
  762.     while(_ATOK == GU906_ExecuteOrder(ATCIPSTARTOK, strlen(ATCIPSTARTOK), _ATCIPSTARTOK, 0))   
  763.     {  
  764.         //关闭网络连接  
  765.         if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPCLOSE, strlen(ATCIPCLOSE), _ATCIPCLOSE, 2)))   
  766.             return ret;  
  767.           
  768.         //保存设置  
  769.         if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPSCONT(0), strlen(ATCIPSCONT(0)), _ATCIPSCONT, 2)))   
  770.             return ret;  
  771.     }  
  772.    
  773.     //单链接模式  
  774.     if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPMUX, strlen(ATCIPMUX), _ATCIPMUX, 2)))   
  775.         return ret;  
  776.   
  777.     //非数据透传输模式  
  778.     if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPMODE(0), strlen(ATCIPMODE(0)), _ATCIPMODE, 2)))   
  779.         return ret;  
  780.   
  781.     //自动启动连接命令  
  782.     if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPCFG(0), strlen(ATCIPCFG(0)), _ATCIPCFG, 2)))   
  783.         return ret;  
  784.   
  785.     //心跳包设置  
  786.     if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPPACK(0), strlen(ATCIPPACK(0)), _ATCIPPACK, 2)))   
  787.         return ret;  
  788.       
  789.     //连接到服务器  
  790.     //cipstart=(char *)mymalloc(100);   
  791.     //if(cipstart==NULL) return -1;   
  792.     sprintf(cipstart, ATCIPSTART,"TCP", GprsCon->server_ip, GprsCon->server_port);  
  793.     ret = GU906_ExecuteOrder(cipstart, strlen(cipstart), _ATCIPSTART, 3);  
  794.       
  795.     //myfree(cipstart);  
  796.     return ret;  
  797. }  
  798.   
  799. /********************************************************* 
  800.   * @function  GU906_DTU_Socket 
  801.   * @role      设置透传模式 
  802.   * @input     IP地址与端口 
  803.   * @output    None 
  804.   * @return    成功返回：_ATOK，失败返回：_ATERROR，超时返回：_ATOTIME 
  805.   ********************************************************/  
  806. s8 GU906_DTU_Socket(struct Gprs_Config *GprsCon)  
  807. {  
  808.     char atorder[100] = "";  
  809.     s8 ret = _ATOTIME;  
  810.       
  811.     if(GprsCon->server_ip == NULL || !GprsCon->server_port) return ret;  
  812.     if(!strlen((charchar *)GprsCon->server_ip)) return ret;  
  813.       
  814.     //atorder=(char *)mymalloc(100);   
  815.     //if(atorder==NULL) return -1;   
  816.       
  817.     //查询数据透设置情况  
  818.     if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPSCONT_C, strlen(ATCIPSCONT_C), _ATCIPSCONT_C, 2)))   
  819.         goto GU906_DTU_SOCKETEND;  
  820.    
  821.     if(!GPRS_Dtu_ConLock)  
  822.     {  
  823.         //设置账号  
  824.         if(_ATOK != (ret = GU906_ExecuteOrder(ATCSTT, strlen(ATCSTT), _ATCSTT, 2)))   
  825.             goto GU906_DTU_SOCKETEND;  
  826.           
  827.         //透传参数设置  
  828.         if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPCFG(1), strlen(ATCIPCFG(1)), _ATCIPCFG, 2)))   
  829.             goto GU906_DTU_SOCKETEND;  
  830.           
  831.         //设置心跳  
  832.         if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPPACK(0), strlen(ATCIPPACK(0)), _ATCIPPACK, 2)))   
  833.             goto GU906_DTU_SOCKETEND;  
  834.           
  835.         //设置设备注册包  
  836.         if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPPACK(1), strlen(ATCIPPACK(1)), _ATCIPPACK, 2)))   
  837.             goto GU906_DTU_SOCKETEND;  
  838.           
  839.         //单链接模式  
  840.         if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPMUX, strlen(ATCIPMUX), _ATCIPMUX, 2)))   
  841.             goto GU906_DTU_SOCKETEND;  
  842.   
  843.         //数据透传输模式  
  844.         if(_ATOK != (ret = GU906_ExecuteOrder(ATCIPMODE(1), strlen(ATCIPMODE(1)), _ATCIPMODE, 2)))   
  845.             goto GU906_DTU_SOCKETEND;  
  846.   
  847.         //保存设置  
  848.         sprintf(atorder, ATCIPSCONT(1),"TCP", GprsCon->server_ip, GprsCon->server_port);  
  849.         if(_ATOK != (ret = GU906_ExecuteOrder(atorder, strlen(atorder), _ATCIPSCONT, 2)))   
  850.             goto GU906_DTU_SOCKETEND;  
  851.           
  852.         GPRS_Dtu_ConLock = 1;  
  853.     }  
  854.   
  855.     //建立数据透连接  
  856.     sprintf(atorder, ATCIPSTART, "TCP", GprsCon->server_ip, GprsCon->server_port);  
  857.     if(_ATOK != (ret = GU906_ExecuteOrder(atorder, strlen(atorder), _ATCIPSTART, 2)))   
  858.         goto GU906_DTU_SOCKETEND;  
  859.   
  860.     GU906_DTU_SOCKETEND:  
  861.     //myfree(atorder);  
  862.     return ret;  
  863. }  
  864.   
  865. /********************************************************* 
  866.   * @function  GU906_DtuOrAT 
  867.   * @role      透传模式与AT模式转换 
  868.   * @input     None 
  869.   * @output    None 
  870.   * @return    成功返回：_ATOK，失败返回：_ATERROR，超时返回：_ATOTIME 
  871.   ********************************************************/  
  872. s8 GU906_DtuOrAT(u8 type)  
  873. {  
  874.     s8 ret = _ATERROR;  
  875.     if(type)  
  876.     {  
  877.         while(!GPRS_Dtu_ConLock)  
  878.         {  
  879.             //打开透传  
  880.             delay_s(2);  
  881.             if(_ATOK != (ret = GU906_ExecuteOrder(OPENDTU, strlen(OPENDTU), _OPENDTU, 0)))   
  882.                 goto GU906_DTUOFFONEND;  
  883.             GPRS_Dtu_ConLock = 1;  
  884.         }  
  885.     }  
  886.     else  
  887.     {  
  888.         while(GPRS_Dtu_ConLock)  
  889.         {  
  890.             //关闭透传  
  891.             delay_s(2);  
  892.             if(_ATOK != (ret = GU906_ExecuteOrder(CLOSEDTU, strlen(CLOSEDTU), _CLOSEDTU, 0)))  
  893.             {  
  894.                 delay_s(1);  
  895.                 if(_ATOK != (GU906_Module_State()))  
  896.                     goto GU906_DTUOFFONEND;   
  897.             }  
  898.             GPRS_Dtu_ConLock = 0;  
  899.         }     
  900.     }  
  901.       
  902.     GU906_DTUOFFONEND:  
  903.     return ret;  
  904. }  
  905. /********************************************************* 
  906.   * @function  GU906_GPRS_write 
  907.   * @role      gprs发送数据 
  908.   * @input     要发送的数据与数据长度 
  909.   * @output    None 
  910.   * @return    成功返回：_ATOK，失败返回：_ATERROR，超时返回：_ATOTIME 
  911.   ********************************************************/  
  912. s8 GU906_GPRS_write(char* pdat, int len)  
  913. {  
  914.     char atorder[20] = "";  
  915.     s8 ret = -1;  
  916.     if(strlen(pdat) == 0) return 0;  
  917.       
  918.     //atorder = (char *)mymalloc(20);   
  919.     //if(atorder == NULL) return -1;   
  920.       
  921.     if(!GPRS_Dtu_ConLock)//非数据透模式  
  922.     {  
  923.         //设置数据长度  
  924.         sprintf(atorder, ATCIPSEND(1), len);  
  925.         if(_ATOK != (ret = GU906_ExecuteOrder(atorder, strlen(atorder), _ATCIPSEND, 0)))   
  926.             goto GU906_GPRS_WRITERET;  
  927.           
  928.         //发送数据  
  929.         if(_ATOK != (ret = GU906_ExecuteOrder(pdat, len, _GPRSSEND, 0)))   
  930.             goto GU906_GPRS_WRITERET;  
  931.     }  
  932.     else  
  933.     {  
  934.         //发送数据  
  935.         usart4_Send(pdat, len);  
  936.         ret = _ATOK;  
  937.     }  
  938.     GU906_GPRS_WRITERET:  
  939.     //myfree(atorder);  
  940.     return ret;  
  941. }  
  942.   
  943. /********************************************************* 
  944.   * @function  GU906_GPRS_read 
  945.   * @role      查询是否接收到数据 
  946.   * @input     输出缓存大小 
  947.   * @output    接收到的数据 
  948.   * @return    接收到的数据长度 
  949.   ********************************************************/  
  950. u32 GU906_GPRS_read(charchar *pout, int len)  
  951. {  
  952.     int i = 0;  
  953.       
  954.     if(!GPRS_Dtu_ConLock)  
  955.     {  
  956.         GPRSREAD:  
  957.         if(GPRS_Dlen){  
  958.             for(i = 0;(i < GPRS_Dlen) && (i < (len -1)); i++){  
  959.                 pout[i] = GPRS_Data[i];  
  960.             }  
  961.             memset(GPRS_Data, 0, sizeof(GPRS_Data));  
  962.             GPRS_Dlen = 0;  
  963.             return i;  
  964.         }else{  
  965.             GetFreeBuff(1);  
  966.             if(GPRS_Dlen)  
  967.                 goto GPRSREAD;  
  968.         }     
  969.     }  
  970.     else  
  971.     {  
  972.         return usart4_Receive(pout,len);  
  973.     }  
  974.     return 0;  
  975. }  
  976.   
  977. /********************************************************* 
  978.   * @function  GU906_make_phone 
  979.   * @role      向指定的手机拨号 
  980.   * @input     手机号 
  981.   * @output    None 
  982.   * @return    成功返回：_ATOK，失败返回：_ATERROR，超时返回：_ATOTIME 
  983.   ********************************************************/  
  984. s8 GU906_make_phone(charchar *phone)  
  985. {  
  986.     char mphone[20]="";  
  987.     sprintf(mphone, ATATD, phone);    
  988.     return GU906_ExecuteOrder(mphone, strlen(mphone), _ATATD, 0);  
  989. }  
  990.   
  991. /********************************************************* 
  992.   * @function  GU906_Answer_Phone 
  993.   * @role      等待电话被接听 
  994.   * @input     手机号 
  995.   * @output    None 
  996.   * @return    成功返回：_ATOK，失败返回：_ATERROR，超时返回：_ATOTIME 
  997.   ********************************************************/  
  998. s8 GU906_Answer_Phone(u32 Delay)  
  999. {  
  1000.     int siz = 0;  
  1001.     u32 i = 0;  
  1002.     char buff[MAXRECVBUFF] = "";  
  1003.       
  1004.     i = 0;  
  1005.     while(1)  
  1006.     {  
  1007.         siz = 0;  
  1008.         siz = usart4_Receive(buff,MAXRECVBUFF);  
  1009.         if(siz){  
  1010.             GetRecvData(buff, &siz);  
  1011.             if(strstr(buff, "+COLP:") && strstr(buff, "OK")){  
  1012.                 return _ATOK;  
  1013.             }else if(strstr(buff, "NO CARRIER") || strstr(buff, "+CREG: 1") || strstr(buff, "ERROR")){  
  1014.                 return _ATERROR;  
  1015.             }  
  1016.         }  
  1017.         if(i++ > Delay)   
  1018.         {  
  1019.             return _ATOTIME;  
  1020.         }  
  1021.     }  
  1022. }         
  1023. /********************************************************* 
  1024.   * @function  GU906_end_phone 
  1025.   * @role      挂机 
  1026.   * @input     None 
  1027.   * @output    None 
  1028.   * @return    成功返回：_ATOK，失败返回：_ATERROR，超时返回：_ATOTIME 
  1029.   ********************************************************/  
  1030. s8 GU906_end_phone(void)  
  1031. {  
  1032.     return GU906_ExecuteOrder(ATATH, strlen(ATATH), _ATATH, 0);  
  1033. }  
  1034.   
  1035. #if GU906GSM_EN  
  1036. /********************************************************* 
  1037.   * @function  GU906_Chinese_text 
  1038.   * @role      向指定的手机发送中文短信 
  1039.   * @input     phone 手机号指针，pmsg 短消息指针 
  1040.   * @output    None 
  1041.   * @return    成功返回：_ATOK，失败返回：_ATERROR，超时返回：_ATOTIME 
  1042.   ********************************************************/  
  1043. s8 GU906_Chinese_text(charchar *phone,char* pmsg)  
  1044. {  
  1045.     s8 ret = _ATOTIME;  
  1046.     char atphone[50] = "";  
  1047.     char end[]={0x1A,0x00};  
  1048.       
  1049.     if(strlen(phone) != 11)  return _ATERROR;  
  1050.     //atphone = (char *)mymalloc(50);   
  1051.     //if(atphone == NULL) return -1;   
  1052.       
  1053.     //设置短消息为txet模式  
  1054.     if(_ATOK != (ret = GU906_ExecuteOrder(ATCMGF, strlen(ATCMGF), _ATCMGF, 2)))   
  1055.         goto GU906_CHINESE_TEXTEND;  
  1056.       
  1057.     //设置GB2312编码  
  1058.     if(_ATOK != (ret = GU906_ExecuteOrder(ATGB2312, strlen(ATGB2312), _ATGB2312, 2)))   
  1059.         goto GU906_CHINESE_TEXTEND;  
  1060.       
  1061.     //设置这组参数来了新信息存储起来   
  1062.     if(_ATOK != (ret = GU906_ExecuteOrder(ATCNMI, strlen(ATCNMI), _ATCNMI, 2)))   
  1063.         goto GU906_CHINESE_TEXTEND;  
  1064.       
  1065.     //设置用户手机号  
  1066.     sprintf(atphone,ATCMGS,phone);  
  1067.     if(_ATOK != (ret = GU906_ExecuteOrder(atphone, strlen(atphone), _ATCMGS, 2)))   
  1068.         goto GU906_CHINESE_TEXTEND;  
  1069.       
  1070.     //发送数据  
  1071.     if(_ATOK == (ret = GU906_ExecuteOrder(pmsg, strlen(pmsg), _GSMSEND, 0)))   
  1072.     {  
  1073.         ret = GU906_ExecuteOrder(end, 1, _GSMSENDEND, 0);  
  1074.     }  
  1075.     GU906_CHINESE_TEXTEND:  
  1076.     //myfree(atphone);  
  1077.     return ret;  
  1078. }  
  1079.   
  1080. /********************************************************* 
  1081.   * @function  GU906_Read_SIM 
  1082.   * @role      读取短信信息 
  1083.   * @input     短信在SIM卡中的位置 
  1084.   * @output    None 
  1085.   * @return    成功返回：_ATOK，失败返回：_ATERROR，超时返回：_ATOTIME  
  1086.   ********************************************************/  
  1087. static s8 GU906_Read_SIM(charchar *pnum)  
  1088. {  
  1089.     s8 ret = _ATOTIME;  
  1090.     char cmgr[20]="";  
  1091.     //读取短信的编码格式为GB2312  
  1092.     if(_ATOK != (ret = GU906_ExecuteOrder(ATGB2312, strlen(ATGB2312), _ATGB2312, 2)))   
  1093.         return ret;  
  1094.       
  1095.     //读取短消息  
  1096.     sprintf(cmgr,ATCMGR,pnum);  
  1097.     return GU906_ExecuteOrder(cmgr, strlen(cmgr), _ATCMGR, 2);  
  1098. }  
  1099.   
  1100. /********************************************************* 
  1101.   * @function  GU906_DeleteSms 
  1102.   * @role      删除SIM卡中的所有短信 
  1103.   * @input     None 
  1104.   * @output    None 
  1105.   * @return    成功返回：_ATOK，失败返回：_ATERROR，超时返回：_ATOTIME  
  1106.   ********************************************************/  
  1107. static int GU906_DeleteSms(void)  
  1108. {  
  1109.     return GU906_ExecuteOrder(ATCMGD, strlen(ATCMGD), _ATCMGD, 2);  
  1110. }  
  1111.   
  1112. /********************************************************* 
  1113.   * @function  GU906_Read_UserSMS 
  1114.   * @role      查询并读取短信数据 
  1115.   * @input     None 
  1116.   * @output    None 
  1117.   * @return    0,接收到新数据，-1,未接收到新数据 
  1118.   ********************************************************/  
  1119. s8 GU906_Read_UserSMS(void)  
  1120. {  
  1121.     SMSREAD:  
  1122.     if(strlen(SIMDataID)){  
  1123.         #if DEBUG_EN  
  1124.         printf("SIMDataID[%s]\r\n",SIMDataID);  
  1125.         #endif  
  1126.         GU906_Read_SIM(SIMDataID);  
  1127.         GU906_DeleteSms();  
  1128.         memset(SIMDataID,0,sizeof(SIMDataID));  
  1129.         return 0;  
  1130.     }else{  
  1131.         GetFreeBuff(1);  
  1132.         if(strlen(SIMDataID))  
  1133.             goto SMSREAD;  
  1134.     }  
  1135.     return -1;  
  1136. }  
  1137. #endif  


gu906.文件如下

[objc] view plain copy
  1. #ifndef _GU906_H_  
  2. #define _GU906_H_  
  3. #include "sys.h"  
  4.   
  5. #define GU906GSM_EN   1    //是否开启短信功能   
  6. #define GPRSCSQ       18   //信号强度,在使用GPRS功能时，最低要求信号强度不得低于18  
  7.   
  8. #define _ATOK          0  //执行成功  
  9. #define _ATERROR      -1  //执行错误  
  10. #define _ATOTIME      -2  //执行超时  
  11. #define _LINKNOT      -3  //掉线了  
  12.   
  13. struct Gprs_Config{  
  14.     u8 *server_ip;     //服务器IP  
  15.     u32 server_port;   //服务器端口  
  16. };  
  17.   
  18. #if GU906GSM_EN  
  19. //根据实际内存情况而定  
  20. struct user_simdata{  
  21.     char phone[15];  //用户手机号  
  22.     char dev[50];    //用户使用的设备  
  23.     char date[50];   //接收时间  
  24.     char data[200];  //接收的数据  
  25. };  
  26. extern struct user_simdata sim;  
  27. s8 GU906_Read_UserSMS(void);  
  28. s8 GU906_Chinese_text(charchar *phone,char* pmsg);  
  29. #endif  
  30.   
  31. s8  GU906_init(void);  
  32. s8  GU906_Module_State(void);  
  33. s8  GU906_TCP_Socket(struct Gprs_Config *GprsCon);  
  34. s8  GU906_DTU_Socket(struct Gprs_Config *GprsCon);  
  35. s8  GU906_GPRS_write(char* pdat, int len);  
  36. u32 GU906_GPRS_read(charchar *pout, int len);  
  37.   
  38. s8  GU906_make_phone(charchar *phone);  
  39. s8  GU906_Answer_Phone(u32 Delay);  
  40. s8  GU906_end_phone(void);  
  41. s8  GU906_DtuOrAT(u8 type);  
  42.   
  43.   
  44. #endif  

main.c

[objc] view plain copy
  1. #include <string.h>  
  2. #include <stdlib.h>  
  3. #include "stdio.h"  
  4. #include "delay.h"  
  5. #include "GU906.h"  
  6. #include "config.h"  
  7. #include "usart1.h"  
  8. #include "usart4.h"  
  9.   
  10. int main(void)  
  11. {      
  12.     u32 ret = 0;  
  13.     char buff[200]="";  
  14.     struct Gprs_Config GprsCon;  
  15.     delay_init();  
  16.     usart4_Configuration(115200);    //GU900默认通信波特率是115200  
  17.     usart1_Configuration(115200);    //调试输出端口波特率设置  
  18.     delay_s(5);                      //刚上电 要等待10秒，等待GU906模块初始化完成  
  19.       
  20.     printf("\r\nBegin...\r\n");  
  21.     GprsCon.server_ip = (u8 *)"210.66.59.211"; //GPRS通信时的服务器IP  
  22.     GprsCon.server_port = atoi("8888");        //GPRS通信时的服务器端口  
  23.       
  24.     //GSM初始化  
  25.     while(1)  
  26.     {  
  27.         if(_ATOK == GU906_init()){  
  28.             printf("GU906 init ok.\r\n\r\n");  
  29.             break;  
  30.         }  
  31.         printf("init error.\r\n");  
  32.         delay_s(1);  
  33.     }  
  34.       
  35.     /*****************************************************************************/  
  36.     //GU906 GPRS TCP 非透传模式通信测试  
  37.     while(1)  
  38.     {  
  39.         if(_ATOK == GU906_TCP_Socket(&GprsCon))  
  40.         {  
  41.             printf("socket ok\r\n\r\n");  
  42.             delay_s(3);   
  43.             while(1)  
  44.             {  
  45.                 ret = GU906_GPRS_read(buff, 200);  
  46.                 if(ret)  
  47.                 {  
  48.                     printf("GPRS:[%d][%s]\r\n", ret,buff);  
  49.                     if(_ATOK != GU906_GPRS_write((charchar *)"OK", 2))  
  50.                     {  
  51.                         printf("Send Error.\r\n");  
  52.                     }                     
  53.                 }  
  54.             }  
  55.         }  
  56.         printf("GU906_TCP_Socket ERROR.\r\n");  
  57.         while(1);  
  58.     }  
  59.     /*******************************************************************************/  
  60.       
  61.     /*****************************************************************************/  
  62.     //GU906 GPRS TCP 透传模式通信测试  
  63.     while(1)  
  64.     {  
  65.         if(_ATOK == GU906_DTU_Socket(&GprsCon))  
  66.         {  
  67.             printf("socket ok\r\n\r\n");  
  68.             delay_s(3);   
  69.             while(1)  
  70.             {  
  71.                 ret = GU906_GPRS_read(buff, 200);  
  72.                 if(ret)  
  73.                 {  
  74.                     printf("GPRS:[%d][%s]\r\n", ret,buff);  
  75.                     if(_ATOK != GU906_GPRS_write((charchar *)buff, ret))  
  76.                     {  
  77.                         printf("Send Error.\r\n");  
  78.                     }                     
  79.                       
  80.                     if(strstr(buff,"CLOSE"))  
  81.                     {  
  82.                         GU906_DtuOrAT(0);  
  83.                     }  
  84.                     if(strstr(buff,"OPEN"))  
  85.                     {  
  86.                         GU906_DtuOrAT(1);  
  87.                     }  
  88.                 }  
  89.             }  
  90.         }  
  91.         printf("GU906_TCP_Socket ERROR.\r\n");  
  92.         while(1);  
  93.     }  
  94.     /*******************************************************************************/  
  95.       
  96.     /*****************************************************************************/  
  97.     //发送短信测试  
  98.     while(_ATOK != GU906_Chinese_text("18750******", "123abd 测试"))  
  99.     {  
  100.         delay_s(5);  
  101.     }  
  102.   
  103.     //接收短信测试  
  104.     while(1)  
  105.     {  
  106.         if(0 == GU906_Read_UserSMS())  
  107.         {  
  108.             printf("------------------------------\r\n");  
  109.             printf("号码:%s\r\n",sim.phone);  
  110.             printf("设备:%s\r\n",sim.dev);  
  111.             printf("时间:%s\r\n",sim.date);  
  112.             printf("信息:%s\r\n",sim.data);  
  113.         }  
  114.         delay_ms(50);  
  115.     }  
  116.     /******************************************************************************/  
  117.       
  118.     /*****************************************************************************/  
  119.     //打电话测试  
  120.     if (_ATOK == GU906_make_phone("18750******"))  
  121.     {  
  122.         //等待接听  
  123.         while(_ATOTIME == GU906_Answer_Phone(1000))  
  124.         {  
  125.             printf("make ok\r\n");  
  126.             GU906_end_phone();            
  127.         }  
  128.         printf("make ok\r\n");  
  129.     }  
  130.     else   
  131.     {  
  132.         printf("make error\r\n");  
  133.         //SoftReset();  
  134.     }  
  135.     /******************************************************************************/  
  136.     while(1);  
  137. }  



工程下载：

链接：http://pan.baidu.com/s/1dEQwME9 密码：9fwz


posted @ 2017-11-09 16:46  专注it  阅读(560)  评论(0)  编辑  收藏  举报