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

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

gu906.文件如下

  1. #ifndef _GU906_H_
  2. #define _GU906_H_
  3. #include "sys.h"
  4. #define GU906GSM_EN   1    //是否开启短信功能
  5. #define GPRSCSQ       18   //信号强度,在使用GPRS功能时，最低要求信号强度不得低于18
  6. #define _ATOK          0  //执行成功
  7. #define _ATERROR      -1  //执行错误
  8. #define _ATOTIME      -2  //执行超时
  9. #define _LINKNOT      -3  //掉线了
  10. struct Gprs_Config{
  11. u8 *server_ip;     //服务器IP
  12. u32 server_port;   //服务器端口
  13. };
  14. #if GU906GSM_EN
  15. //根据实际内存情况而定
  16. struct user_simdata{
  17. char phone[15];  //用户手机号
  18. char dev[50];    //用户使用的设备
  19. char date[50];   //接收时间
  20. char data[200];  //接收的数据
  21. };
  22. extern struct user_simdata sim;
  23. s8 GU906_Read_UserSMS(void);
  24. s8 GU906_Chinese_text(charchar *phone,char* pmsg);
  25. #endif
  26. s8  GU906_init(void);
  27. s8  GU906_Module_State(void);
  28. s8  GU906_TCP_Socket(struct Gprs_Config *GprsCon);
  29. s8  GU906_DTU_Socket(struct Gprs_Config *GprsCon);
  30. s8  GU906_GPRS_write(char* pdat, int len);
  31. u32 GU906_GPRS_read(charchar *pout, int len);
  32. s8  GU906_make_phone(charchar *phone);
  33. s8  GU906_Answer_Phone(u32 Delay);
  34. s8  GU906_end_phone(void);
  35. s8  GU906_DtuOrAT(u8 type);
  36. #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. int main(void)
  10. {
  11. u32 ret = 0;
  12. char buff[200]="";
  13. struct Gprs_Config GprsCon;
  14. delay_init();
  15. usart4_Configuration(115200);    //GU900默认通信波特率是115200
  16. usart1_Configuration(115200);    //调试输出端口波特率设置
  17. delay_s(5);                      //刚上电 要等待10秒，等待GU906模块初始化完成
  18. printf("\r\nBegin...\r\n");
  19. GprsCon.server_ip = (u8 *)"210.66.59.211"; //GPRS通信时的服务器IP
  20. GprsCon.server_port = atoi("8888");        //GPRS通信时的服务器端口
  21. //GSM初始化
  22. while(1)
  23. {
  24. if(_ATOK == GU906_init()){
  25. printf("GU906 init ok.\r\n\r\n");
  26. break;
  27. }
  28. printf("init error.\r\n");
  29. delay_s(1);
  30. }
  31. /*****************************************************************************/
  32. //GU906 GPRS TCP 非透传模式通信测试
  33. while(1)
  34. {
  35. if(_ATOK == GU906_TCP_Socket(&GprsCon))
  36. {
  37. printf("socket ok\r\n\r\n");
  38. delay_s(3);
  39. while(1)
  40. {
  41. ret = GU906_GPRS_read(buff, 200);
  42. if(ret)
  43. {
  44. printf("GPRS:[%d][%s]\r\n", ret,buff);
  45. if(_ATOK != GU906_GPRS_write((charchar *)"OK", 2))
  46. {
  47. printf("Send Error.\r\n");
  48. }
  49. }
  50. }
  51. }
  52. printf("GU906_TCP_Socket ERROR.\r\n");
  53. while(1);
  54. }
  55. /*******************************************************************************/
  56. /*****************************************************************************/
  57. //GU906 GPRS TCP 透传模式通信测试
  58. while(1)
  59. {
  60. if(_ATOK == GU906_DTU_Socket(&GprsCon))
  61. {
  62. printf("socket ok\r\n\r\n");
  63. delay_s(3);
  64. while(1)
  65. {
  66. ret = GU906_GPRS_read(buff, 200);
  67. if(ret)
  68. {
  69. printf("GPRS:[%d][%s]\r\n", ret,buff);
  70. if(_ATOK != GU906_GPRS_write((charchar *)buff, ret))
  71. {
  72. printf("Send Error.\r\n");
  73. }
  74. if(strstr(buff,"CLOSE"))
  75. {
  76. GU906_DtuOrAT(0);
  77. }
  78. if(strstr(buff,"OPEN"))
  79. {
  80. GU906_DtuOrAT(1);
  81. }
  82. }
  83. }
  84. }
  85. printf("GU906_TCP_Socket ERROR.\r\n");
  86. while(1);
  87. }
  88. /*******************************************************************************/
  89. /*****************************************************************************/
  90. //发送短信测试
  91. while(_ATOK != GU906_Chinese_text("18750******", "123abd 测试"))
  92. {
  93. delay_s(5);
  94. }
  95. //接收短信测试
  96. while(1)
  97. {
  98. if(0 == GU906_Read_UserSMS())
  99. {
  100. printf("------------------------------\r\n");
  101. printf("号码:%s\r\n",sim.phone);
  102. printf("设备:%s\r\n",sim.dev);
  103. printf("时间:%s\r\n",sim.date);
  104. printf("信息:%s\r\n",sim.data);
  105. }
  106. delay_ms(50);
  107. }
  108. /******************************************************************************/
  109. /*****************************************************************************/
  110. //打电话测试
  111. if (_ATOK == GU906_make_phone("18750******"))
  112. {
  113. //等待接听
  114. while(_ATOTIME == GU906_Answer_Phone(1000))
  115. {
  116. printf("make ok\r\n");
  117. GU906_end_phone();
  118. }
  119. printf("make ok\r\n");
  120. }
  121. else
  122. {
  123. printf("make error\r\n");
  124. //SoftReset();
  125. }
  126. /******************************************************************************/
  127. while(1);
  128. }

工程下载：

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

STM32F103 GU906B模块GPRS、短信收发、拨号等功能的实现的更多相关文章

  1. linux下利用GPRS模块发短信、打电话

    一.开发环境     内核版本:linux-3.0    开发板:FL2440(nandflash:K9F1G08 128M)    GPRS模块:SIM900   二.与发短信和拨号相关的 AT 指 ...

  2. Linux-C实现GPRS模块发送短信

    “GSM模块,是将GSM射频芯片.基带处理芯片.存储器.功放器件等集成在一块线路板上,具有独立的操作系统.GSM射频处理.基带处理并提供标准接口的功能模块.GSM模块根据其提供的数据传输速率又可以分为 ...

  3. 树莓派.GPRS.短信接收器

    起因 曾经用过西门子出的短信猫, 好处是直接有SDK开发包, 不会硬件开发也能直接使用 缺点也是明显的, 就是只支持Windows系统, 另外就是在Windows下工作很不稳定, 隔开几天就会出现收不 ...

  4. 在Linux下用C语言实现短信收发

     本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/lyserver/archive/2008/10/01/3007090.aspx 首先,我根据功能需要创建了几个头文件 ...

  5. 使用python移动飞信模块发送短信

    作者:miaoo 1.应用场景 由于自己做的一个系统需要用到发送短信到自己手机的功能,于是搜索了一下,发现了一个通过移动飞信通道发送短信开源库:PyFetion PyFetion 模拟实现了飞信的通信 ...

  6. iOS打电话、发短信、发邮件功能开发

    本文转载至 http://www.lvtao.net/ios/506.html 今天把APP里常用小功能 例如发短信.发邮件.打电话.全部拿出来简单说说它们的实现思路. 1.发短信实现打电话的功能,主 ...

  7. Android 节日短信送祝福（功能篇：1-数据库操作类与自定义ContentProvider）

    首先,还是展示一下部分目录结构:  在节日短信送祝福的功能实现方面,为了能够方便直观展示实现过程,小编我以Java文件为基础,一个一个来展示,免得到时候这个java文件写点,一下又跳到另外一个java ...

  8. Android短信收发（二）

    接收SMS类,代码如下 //for receive SMS private SmsReceiver mSmsReceiver; @Override protected void onResume() ...

  9. iOS 打电话、发短信、发邮件功能

    打电话 方法1 最简单最直接的方式:直接跳到拨号界面 NSURL *url = [NSURL URLWithString:@"tel://10010"]; [[UIApplicat ...

随机推荐

  1. html禁止浏览器默认行为，让页面更像应用。

    在html或body行内写入:oncontextmenu="return false" ondragstart='return false;' onselectstart=&quo ...

  2. 搭建 GIT 服务器

    Git 是一款免费.开源的分布式版本控制系统,用于敏捷高效地处理任何或小或大的项目. 此实验以 CentOS 7.2 x64 的系统为环境,搭建 git 服务器. 安装依赖库和编译工具 为了后续安装能 ...

  3. LeetCode 136. Single Number(只出现一次的数字)

    LeetCode 136. Single Number(只出现一次的数字)

  4. 隐藏当前Activity而不关闭

    startActivity后调用 overridePendingTransition(R.anim.zoomin, R.anim.zoomout); 可以实现Activity跳转的动画效果 打开act ...

  5. 简述HttpSession的作用、使用方法，可用代码说明

    HttpSession中可以跟踪并储存用户信息,把值设置到属性中,有2个方法:setAttribute(),getAttrribute(): 例如:在一个方法中用session.setAttribut ...

  6. BZOJ1019 汉诺塔

    定义f[i][j]为将i柱上的j个盘挪走(按优先级)的步数 p[i][j]为将i柱上的j个盘按优先级最先挪至何处 首先考虑一定p[i][j]!=i 设初始为a柱,p[i][j-1]为b柱 考虑两种情况 ...

  7. Codeforces 798D

    这两天后缀数组整多了整点有意思的,随机算法. 题意给你两个数组,让你求一个排列使得这个排列对应的两个数组前n/2+1个数之和的二倍大于每个序列总和. 下面先贴下这题正解 二维贪心,按a从大到小排,把第 ...

  8. [APIO2015]巴厘岛的雕塑 --- 贪心 + 枚举

    [APIO2015]巴厘岛的雕塑  题目描述 印尼巴厘岛的公路上有许多的雕塑,我们来关注它的一条主干道. 在这条主干道上一共有\(N\)座雕塑,为方便起见,我们把这些雕塑从 1 到\(N\)连续地进行 ...

  9. App图标生成器的实现，附源码

    背景 网上各种生成app图标的网站和工具,感觉还是用自己写的心里畅快点,所以花了1个小时自己写了个.按照网上给的图标尺寸规范把所有尺寸的都生成了. 建了一个讨论群,533838427.很明显是针对独立 ...

  10. Gridview数据导出excel时身份证号码为科学计数法的解决方法

    if (e.Row.RowType == DataControlRowType.DataRow) { string id = this.GridView1.DataKeys[e.Row.RowInde ...