zoukankan      html  css  js  c++  java

  • 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 "                                        //测试命令  
    46. #define ATE(x)              ((x)?("ATE1 "):("ATE0 "))                 //开回显、关回显   
    47. #define ATESIM              "AT+ESIMS? "                                 //检测卡是否存在  
    48. #define ATCNMI              "AT+CNMI=2,1 "                               //设置这组参数来了新信息存储起来   
    49. #define ATCMGD              "AT+CMGD=1,4 "                               //删除当前存储器中全部短信   
    50. #define ATCMGF              "AT+CMGF=1 "                                 //0设置短消息为PDU模式, 1设置短消息为txet模式  
    51. #define ATCSMP              "AT+CSMP=17,167,2,25 "                       //设置文本模式的参数  
    52. #define ATUCS2              "AT+CSCS="UCS2" "                          //设置为 UCS2 编码字符集  
    53. #define ATGB2312            "AT+CSCS="GB2312" "                        //设置GB2312编码  
    54. #define ATATD               "ATD%s; "                                    //对指定手机拨号  
    55. #define ATATH               "ATH "                                       //挂机  
    56. #define ATGSM               "AT+CSCS="GSM" "                           //设置GSM字符集    
    57. #define ATCPMS              "AT+CPMS="SM","SM","SM" "              //设置短信存储单元为SIM卡   
    58. #define ATCSQ               "AT+CSQ "                                    //获取信号强度  
    59. #define ATCREG              "AT+CREG? "                                  //确保模块以及注册到GSM网络  
    60. #define ATCIICR             "AT+CIICR "                                  //让模块激活 GPRS 网络，在需要反复建立 TCP 链接的场合可提高速度         
    61. #define ATCIPSTARTOK        "AT+CIPSTART? "                              //查询当前是否有网络连接  
    62. #define ATCIPCLOSE          "AT+CIPCLOSE=0 "                             //关闭网络连接  
    63. #define ATCIPSCONT(x)       ((x)?("AT+CIPSCONT=0,"%s","%s",%d,2")  
    64.                                 :("AT+CIPSCONT "))                       //保存设置       
    65. #define ATCIPSTART          "AT+CIPSTART="%s","%s",%d "              //设置TCP连接的IP和端口  
    66. #define ATCIPMUX            "AT+CIPMUX=0 "                               //单链接模式  
    67. #define ATCIPMODE(x)        ((x)?("AT+CIPMODE=1,0 ")  
    68.                                 :("AT+CIPMODE=0,0 "))                    //数据透传输模式、非透传  
    69. #define ATCIPCFG(x)         ((x)?("AT+CIPCFG=1,50,0 ")  
    70.                                 :("AT+CIPCFG=0,50,0 "))                  //自动启动连接命令                        
    71. #define ATCIPPACK(x)        ((x)?("AT+CIPPACK=1,"4C4F47494E3A31303031" ")  
    72.                                 :("AT+CIPPACK=0,"0102A0" "))           //设备注册包、心跳包设置  
    73. #define ATCIPSEND(x)        ((x)?("AT+CIPSEND=%d ")  
    74.                                 :("AT+CIPSEND "))                        //设置发送的数据长度  
    75. #define ATCGMR              "AT+CGMR "                                   //获取基站信息            
    76. #define ATCMGS              "AT+CMGS="%s" "                            //设置需要发送短信的手机号  
    77. #define ATCMGR              "AT+CMGR=%s "                                //设置要读取的短信的位置  
    78. #define ATCSTT              "AT+CSTT="CMNET" "                         //账号配置  
    79. #define ATCIPSCONT_C        "AT+CIPSCONT? "                              //查询透传连接情况              
    80. #define GPRSSEND            0x1A                                   
    81. #define CLOSEDTU            "+++"                                            //关闭透传  
    82. #define OPENDTU             "ATO0 "                                      //重新进入透传  
    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(" 分离手机号 ");  
    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 != ''); ++i,p++){  
    200.         sim.phone[i] = *p;  
    201.     }  
    202.     sim.phone[i] = '';  
    203.     #if DEBUG_EN  
    204.     printf("sms.phone[%s] ",sim.phone);  
    205.     printf(" 分离设备类型 ");  
    206.     #endif  
    207.       
    208.     p +=2;  
    209.     memset(sim.dev,0,sizeof(sim.dev));  
    210.     for (i = 0; (*p != ',') && (*p != ''); ++i,p++){  
    211.         sim.dev[i] = *p;  
    212.     }  
    213.     #if DEBUG_EN  
    214.     printf("sms.dev[%s] ",sim.dev);  
    215.     printf(" 分离时间 ");  
    216.     #endif  
    217.       
    218.     p += 2;  
    219.     memset(sim.date,0,sizeof(sim.date));  
    220.     for (i = 0; (*p != '"') && (*p != ''); ++i,p++){  
    221.         sim.date[i] = *p;  
    222.     }  
    223.     #if DEBUG_EN  
    224.     printf("sms.date[%s] ",sim.date);  
    225.     printf(" 分离数据 ");  
    226.     #endif  
    227.       
    228.     p++;  
    229.     memset(sim.data,0,sizeof(sim.data));  
    230.     while((*p != '') && ((*p == ' ') || (*p == ' ')) ) p++;  
    231.     for (i = 0; (*p != '') && (*p != ' ') && (*p != ' '); ++i,p++){  
    232.         sim.data[i] = *p;  
    233.     }  
    234.     sim.data[i] = '';  
    235.     #if DEBUG_EN  
    236.     printf("sms.data:[%s] ",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] = '';  
    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] ",*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 != ' ' && *p1 != ' ' && *p1 != '' && rlen < sizeof(SIMDataID);i++, p1++){  
    291.             if(*p1 >= '0' && *p1 <= '9')  
    292.                 SIMDataID[rlen++] = *p1;  
    293.         }  
    294.         SIMDataID[rlen] = '';   
    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... ");  
    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(" ------------------------------ ");  
    353.     printf("len[%d] ", gprs->olen);  
    354.     for(i = 0; i< gprs->olen; i++,++p)  
    355.         printf("%c", *p);  
    356.     printf(" ");  
    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(" recv: ");  
    379.                 printf("[%s] ",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] ", 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 ",__LINE__);  
    613.                     if(0 != (p = strstr(buff,"+CIPMODE: ")))  
    614.                     {  
    615.                         p += 10;  
    616.                         printf("Line:%d ",__LINE__);  
    617.                         if(1 == (*p -'0'))  
    618.                         {  
    619.                             printf("Line:%d ",__LINE__);  
    620.                             if(0 != (p = strstr(buff,"+CIPSTART: ")))  
    621.                             {  
    622.                                 printf("Line:%d ",__LINE__);  
    623.                                 if(strstr(buff,"218.66.59.201") && strstr(buff,"8888"))  
    624.                                 {  
    625.                                     printf("DTU OK ");  
    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] ",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(" Begin... ");  
    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. ");  
    29.             break;  
    30.         }  
    31.         printf("init error. ");  
    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 ");  
    42.             delay_s(3);   
    43.             while(1)  
    44.             {  
    45.                 ret = GU906_GPRS_read(buff, 200);  
    46.                 if(ret)  
    47.                 {  
    48.                     printf("GPRS:[%d][%s] ", ret,buff);  
    49.                     if(_ATOK != GU906_GPRS_write((charchar *)"OK", 2))  
    50.                     {  
    51.                         printf("Send Error. ");  
    52.                     }                     
    53.                 }  
    54.             }  
    55.         }  
    56.         printf("GU906_TCP_Socket ERROR. ");  
    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 ");  
    68.             delay_s(3);   
    69.             while(1)  
    70.             {  
    71.                 ret = GU906_GPRS_read(buff, 200);  
    72.                 if(ret)  
    73.                 {  
    74.                     printf("GPRS:[%d][%s] ", ret,buff);  
    75.                     if(_ATOK != GU906_GPRS_write((charchar *)buff, ret))  
    76.                     {  
    77.                         printf("Send Error. ");  
    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. ");  
    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("------------------------------ ");  
    109.             printf("号码:%s ",sim.phone);  
    110.             printf("设备:%s ",sim.dev);  
    111.             printf("时间:%s ",sim.date);  
    112.             printf("信息:%s ",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 ");  
    126.             GU906_end_phone();            
    127.         }  
    128.         printf("make ok ");  
    129.     }  
    130.     else   
    131.     {  
    132.         printf("make error ");  
    133.         //SoftReset();  
    134.     }  
    135.     /******************************************************************************/  
    136.     while(1);  
    137. }  



    工程下载：

    链接：http://pan.baidu.com/s/1dEQwME9 密码：9fwz
  • 相关阅读:
    json解析与序列化
    js实现千位分隔符
    map.(parseInt)方法详解
    js实现翻转一个字符串
    一个满屏 品 字布局 如何设计?
    new操作符实现过程
    常见的函数式编程模型
    Azure DevOps Server 2019 (TFS）安装教程
    在Azure DevOps Server （TFS） 中修改团队项目名称
    你好，Azure DevOps Server 2019；再见，Team Foundation Server
  • 原文地址：https://www.cnblogs.com/wanghuaijun/p/7810212.html
Copyright © 2011-2022 走看看