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

发送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. loadrunner场景执行出现：Failed to Initialize. Reason: TimeOut

      问题1: Failed to Initialize. Reason: TimeOut LoadRunner的异常原因(Failed to Initialize. Reason: TimeOut) ...

  2. ul>li中自定义属性后取值的问题

    动态赋值的li: $.ajax({ type: "POST", url: "${base}/before/subDemand/listType", succes ...

  3. MVC Partial页面的使用

    先建立Action: public PartialViewResult CurrentCount() { ViewBag.Count = CurrentUserCount; return Partia ...

  4. Ngnix的日志管理和用定时任务完成日志切割

    一.日志管理 先来看看ngnix的配置文件的server段 接下来我们解释一下默认格式的具体意思 #log_format main '$remote_addr(远程IP) - $remote_user ...

  5. Java中的强引用，软引用，弱引用

    作者:winterSunshine链接:https://www.zhihu.com/question/37401125/answer/100981172来源:知乎著作权归作者所有.商业转载请联系作者获 ...

  6. codevs 5294 挖地雷

    5294 挖地雷  时间限制: 1 s  空间限制: 1000 KB  题目等级 : 黄金 Gold   题目描述 Description 在一个地图上有N个地窖(N<=20),每个地窖中埋有一 ...

  7. 【轮廓线DP】POJ2411-Mondriaan's Dream

    今天美国的院士过来讲课XD以为会很无聊但是谜之好听,而且英语基本上都听懂了的样子♪(´▽｀) 逃到图书馆来写解题报告 [题目大意] 给出一个m*n的方格,用2*1的骨牌覆盖有几种情况. [思路] 最基 ...

  8. 2017-2018-1 JAVA实验站 冲刺 day01

    2017-2018-1 JAVA实验站 冲刺 day01 各个成员在 Alpha 阶段认领的任务 小组成员 分工 任务量 张韵琪 写博客.后期市场推广,营销.打杂.各职能的配合 齐力锋 提供宣传用图. ...

  9. Hash表及hash算法的分析

    Hash表中的一些原理/概念,及根据这些原理/概念: 一.       Hash表概念 二.       Hash构造函数的方法,及适用范围 三.       Hash处理冲突方法,各自特征 四.   ...

  10. Dubbo整合SpringCloud图片显示问题

    Dubbo整合SpringCloud图片显示问题 Tips:公司项目,记录一点经验吧,理解的不对的地方欢迎大神指点 问题:商品图片上传功能(公司没有专门文件服务器)写的保存目录直接是保存在docker ...