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

Posted 专注it

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了STM32F103 GU906B模块GPRS短信收发拨号等功能的实现相关的知识,希望对你有一定的参考价值。

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

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

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

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

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


gu906.文件如下

  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

  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


以上是关于STM32F103 GU906B模块GPRS短信收发拨号等功能的实现的主要内容,如果未能解决你的问题,请参考以下文章

STM32F103学习笔记——NB-IoT模块BC26使用

STM32F103学习笔记——NB-IoT模块BC26使用

我想用STM32连接USB摄像头实现图像采集,再用GPRS传输图像,麻烦给推荐一款STM32开发板!!谢谢~~

基于STM32F103——SIM900A发送短信+串口打印

基于STM32F103——SIM900A发送短信+串口打印

GSM模块_STM32实现GPRS与服务器数据传输经验总结