一个关于GPRS通信的代码求详细注解

nicmax

一个关于GPRS通信的代码求详细注解 [复制链接]

我是菜鸟，代码中的AT命令不需要什么封装就直接放在函数里么，直接就能被识别了？

1. #include
   
2. #include
   
3. 
   
4. #include "def.h"
   
5. #include "option.h"
   
6. #include "2410addr.h"
   
7. #include "2410lib.h"
   
8. //#include "2410slib.h"
   
9. //#include "mmu.h"
   
10. #include "gprs.h"
    
11. 
    
12. #define USE_TICK
    
13. //#define USE_TIMERTEST
    
14. 
    
15. struct MenuItem
    
16. {
    
17. char *name;
    
18. void (*func)(void);
    
19. };
    
20. 
    
21. 
    
22. #ifdef USE_TICK
    
23. static volatile unsigned int TickCount = 0;
    
24. static void InitTick(void);
    
25. #ifdef USE_TIMERTEST
    
26. static void TimerTest(void);
    
27. #endif
    
28. #endif
    
29. 
    
30. #ifdef USE_TICK
    
31. #define GETTICKCOUNT() (TickCount)
    
32. #define SLEEP(time) { \
    
33. unsigned int t = GETTICKCOUNT(); \
    
34. while(GETTICKCOUNT()-t < (time)) \
    
35. { \
    
36. IDLEPROCESS(GETDEFAULTCOMMBUF()); \
    
37. } \
    
38. }
    
39. #else
    
40. #define GETTICKCOUNT() 0
    
41. #endif
    
42. 
    
43. /*************************************
    
44. *缓冲区管理
    
45. *************************************/
    
46. #define COMMBUFSIZE 1024
    
47. struct CommBuf
    
48. {
    
49. char buf[COMMBUFSIZE+1];
    
50. unsigned int size;
    
51. char *rptr;
    
52. char *wptr;
    
53. };
    
54. 
    
55. #define COMMBUF_ISEMPTY(obj) ((obj)->size == 0)
    
56. #define COMMBUF_ISFULL(obj) ((obj)->size == COMMBUFSIZE)
    
57. #define COMMBUF_DATASIZE(obj) ((obj)->size)
    
58. #define COMMBUF_EMPTYSIZE(obj) (COMMBUFSIZE - COMMBUF_DATASIZE(obj))
    
59. #define INCRPTR(obj) { \
    
60. (obj)->rptr++; \
    
61. (obj)->size--; \
    
62. if((obj)->rptr >= (obj)->buf + COMMBUFSIZE) \
    
63. (obj)->rptr = (obj)->buf; \
    
64. }
    
65. 
    
66. #define INCWPTR(obj) { \
    
67. (obj)->wptr++; \
    
68. (obj)->size++; \
    
69. if((obj)->wptr >= (obj)->buf + COMMBUFSIZE) \
    
70. (obj)->wptr = (obj)->buf; \
    
71. }
    
72. 
    
73. #define IDLEPROCESS(obj) { \
    
74. while(rUFSTAT1 & 0x0f) \
    
75. { \
    
76. if(COMMBUF_ISFULL(obj)) \
    
77. break; \
    
78. *((obj)->wptr) = RdURXH1(); \
    
79. /*Uart_SendByte(*((obj)->wptr));*/ \
    
80. INCWPTR(obj); \
    
81. } \
    
82. }
    
83. 
    
84. static struct CommBuf RecvBuf;
    
85. #define GETDEFAULTCOMMBUF() (&RecvBuf)
    
86. 
    
87. void InitCommBuf(struct CommBuf *obj)
    
88. {
    
89. if(obj == NULL)
    
90. return;
    
91. memset(obj->buf, 0, sizeof(obj->buf));
    
92. obj->size = 0;
    
93. obj->rptr = obj->wptr = obj->buf;
    
94. }
    
95. 
    
96. void CommBuf_Clean(struct CommBuf *obj)
    
97. {
    
98. if(obj == NULL)
    
99. return;
    
100. obj->size = 0;
     
101. obj->rptr = obj->wptr;
     
102. }
     
103. 
     
104. void CommBuf_Dump(struct CommBuf *obj)
     
105. {
     
106. SLEEP(1000);
     
107. //Uart_Printf("\n----------log----------\n");
     
108. //Uart_Printf(RecvBuf.buf);
     
109. //Uart_Printf("\n----------end----------\n");
     
110. }
     
111. 
     
112. //从缓冲区读一个字符
     
113. char CommBuf_ReadChar(struct CommBuf *obj, int timeout, int *err)
     
114. {
     
115. char c;
     
116. unsigned int t = GETTICKCOUNT();
     
117. while(COMMBUF_ISEMPTY(obj))
     
118. {
     
119. if(GETTICKCOUNT()-t > timeout)
     
120. {
     
121. if(err != NULL)
     
122. *err = -1;
     
123. return '\0';
     
124. }
     
125. IDLEPROCESS(obj);
     
126. }
     
127. c = *obj->rptr;
     
128. INCRPTR(obj);
     
129. if(err != NULL)
     
130. *err = 0;
     
131. return c;
     
132. }
     
133. 
     
134. //等待字符串，成功返回0，否则返回-1。
     
135. int CommBuf_WaitString(struct CommBuf *obj, char *str, int timeout)
     
136. {
     
137. int err;
     
138. char c;
     
139. char *p = str;
     
140. while(1)
     
141. {
     
142. if(*p == '\0')
     
143. return 0;
     
144. c = CommBuf_ReadChar(obj, timeout, &err);
     
145. if(err)
     
146. break;
     
147. if(*p == c)
     
148. p++;
     
149. else
     
150. {
     
151. p = str;
     
152. if(*p == c)
     
153. p++;
     
154. }
     
155. }
     
156. return -1;
     
157. }
     
158. 
     
159. //读缓冲区
     
160. int ReadCommBuf(struct CommBuf *obj, void *pBuf, size_t sizebuf, unsigned int timeout)
     
161. {
     
162. int i;
     
163. char *buf = pBuf;
     
164. unsigned int t;
     
165. if(obj == NULL)
     
166. return -2;
     
167. t = GETTICKCOUNT();
     
168. while(COMMBUF_ISEMPTY(obj))
     
169. {
     
170. if(GETTICKCOUNT()-t > timeout)
     
171. return -1;
     
172. IDLEPROCESS(obj);
     
173. }
     
174. 
     
175. for(i=0; i
176. {
     
177. while(COMMBUF_ISEMPTY(obj))
     
178. {
     
179. if(GETTICKCOUNT()-t > timeout/*100*/)
     
180. return i;
     
181. IDLEPROCESS(obj);
     
182. }
     
183. *buf = *obj->rptr;
     
184. INCRPTR(obj);
     
185. IDLEPROCESS(obj);
     
186. }
     
187. return i;
     
188. }
     
189. 
     
190. #if 0
     
191. int WriteCommBuf(struct CommBuf *obj, void *pBuf, size_t size)
     
192. {
     
193. int i;
     
194. char *buf = pBuf;
     
195. if(obj == NULL)
     
196. return 0;
     
197. if(size > COMMBUF_EMPTYSIZE(obj))
     
198. {
     
199. return 0;
     
200. }
     
201. 
     
202. for(i=0; i < size; i++)
     
203. {
     
204. *(obj->wptr) = *buf;
     
205. INCWPTR(obj);
     
206. }
     
207. return i;
     
208. }
     
209. #endif
     
210. 
     
211. 
     
212. /********************************************/
     
213. //GPRS 初始化和通信处理
     
214. 
     
215. static void InitUart1(int baud)
     
216. {
     
217. int i;
     
218. rGPHCON = 0x2afaaa;
     
219. rGPHUP = 0x7ff;
     
220. 
     
221. rULCON1 = 0x03;
     
222. rUFCON1 = 0x07;//(3<<6) | (3<<4) | (1<<2) | (1<<1) | (1<<0);//0x07;
     
223. rUCON1 = 0x005;//0x245;
     
224. rUBRDIV1=((int)(PCLK/(16*baud))-1);
     
225. for(i=0;i<5000;i++);
     
226. rUMCON1 = 0x10;
     
227. }
     
228. 
     
229. //GPRS 初始化
     
230. static void InitGPRS(void)
     
231. {
     
232. InitUart1(9600);//初使化串口1
     
233. #ifdef USE_TICK
     
234. InitTick();
     
235. #ifdef USE_TIMERTEST
     
236. TimerTest();
     
237. #endif//USE_TIMERTEST
     
238. #endif//USE_TICK
     
239. }
     
240. 
     
241. 
     
242. void GPRS_SendChar(char c)
     
243. {
     
244. while(rUFSTAT1 & 0x200)
     
245. {
     
246. IDLEPROCESS(GETDEFAULTCOMMBUF());
     
247. }
     
248. WrUTXH1(c);
     
249. }
     
250. 
     
251. void GPRS_SendString(char *str)
     
252. {
     
253. for(; *str; str++)
     
254. {
     
255. GPRS_SendChar(*str);
     
256. }
     
257. }
     
258. 
     
259. //用“AT”命令测试GPRS模块，成功返回1，否则返回0
     
260. int GPRS_TestGPRS(void)
     
261. {
     
262. char log[32];
     
263. int len;
     
264. InitCommBuf(GETDEFAULTCOMMBUF());
     
265. GPRS_SendString("at\r");
     
266. if((len=ReadCommBuf(GETDEFAULTCOMMBUF(), log, sizeof(log)-1, 1000)) > 0)
     
267. {
     
268. log[len] = '\0';
     
269. if(strstr(log, "OK"))
     
270. return 1;
     
271. }
     
272. return 0;
     
273. }
     
274. 
     
275. 
     
276. /***********************************************/
     
277. //短信功能
     
278. 
     
279. //发送短消息，成功返回0，否则返回 -1：GPRS模块没有应答、-2：操作被拒绝、-3：发送失败
     
280. int GPRS_SendTextSMS(char *phone, char *text)
     
281. {
     
282. char log[64];
     
283. int len;
     
284. 
     
285. InitCommBuf(GETDEFAULTCOMMBUF());
     
286. //初使化CommBuf
     
287. GPRS_SendString("at+csca="+8613800571500"\r"); //by cx 设置短消息中心
     
288. SLEEP(1000);
     
289. // 延时
     
290. GPRS_SendString("at+cmgf=1\r"); //by cx 设置短消息格式
     
291. SLEEP(1000);
     
292. CommBuf_Clean(GETDEFAULTCOMMBUF());
     
293. 
     
294. //清空CommBuf
     
295. 
     
296. GPRS_SendString("at+cmgs="");
     
297. GPRS_SendString(phone);
     
298. GPRS_SendString(""\r");
     
299. len = ReadCommBuf(GETDEFAULTCOMMBUF(), log, sizeof(log)-1, 1000);
     
300. if(len > 0)
     
301. {
     
302. log[len] = '\0';
     
303. Uart_Printf(log);
     
304. if(strstr(log, "> ") && !strstr(log, "ERROR"))
     
305. {
     
306. GPRS_SendString(text);
     
307. GPRS_SendString("\x1a\r");
     
308. if(!CommBuf_WaitString(GETDEFAULTCOMMBUF(), "OK", 10000))
     
309. return 0;//发送成功
     
310. else
     
311. return -3;//发送失败
     
312. }
     
313. 
     
314. return -2;//操作被拒绝
     
315. }
     
316. return -1;//GPRS模块没有应答
     
317. }
     
318. 
     
319. //发送短信UI
     
320. void GPRS_SendSmsUI(void)
     
321. {
     
322. char tel[32];
     
323. char smstext[512];
     
324. 
     
325. Uart_Printf("\n\n[发送短信息]");
     
326. Uart_Printf("\n电话号码：");
     
327. Uart_GetString(tel);
     
328. //从串口读出电话号码
     
329. Uart_Printf("\n短信内容：\n");
     
330. Uart_GetString(smstext);
     
331. // 从串口读出短信息
     
332. Uart_Printf("\n正在发送...");
     
333. 
     
334. 
     
335. 
     
336. switch(GPRS_SendTextSMS(tel, smstext))
     
337. {
     
338. case -1:
     
339. Uart_Printf("\n***GPRS模块没有应答");
     
340. break;
     
341. case -2:
     
342. Uart_Printf("\n***操作被拒绝");
     
343. break;
     
344. case -3:
     
345. Uart_Printf("\n***发送失败");
     
346. break;
     
347. case 0:
     
348. Uart_Printf("\n发送成功");
     
349. break;
     
350. }
     
351. CommBuf_Dump(GETDEFAULTCOMMBUF());
     
352. }
     
353. 
     
354. 
     
355. /***********************************/
     
356. //电话功能
     
357. 
     
358. //设置来电显示
     
359. int GPRS_InitCall(void)
     
360. {
     
361. char log[32];
     
362. int len;
     
363. InitCommBuf(GETDEFAULTCOMMBUF());
     
364. GPRS_SendString("AT+CR=1\r");
     
365. len = ReadCommBuf(GETDEFAULTCOMMBUF(), log, sizeof(log)-1, 1000);
     
366. if(len > 0)
     
367. {
     
368. log[len] = '\0';
     
369. if(strstr(log, "OK"))
     
370. {
     
371. CommBuf_Clean(GETDEFAULTCOMMBUF());
     
372. GPRS_SendString("AT+CLIP=1\r");
     
373. len = ReadCommBuf(GETDEFAULTCOMMBUF(), log, sizeof(log)-1, 1000);
     
374. if(len > 0)
     
375. {
     
376. log[len] = '\0';
     
377. if(strstr(log, "OK"))
     
378. return 0;//成功
     
379. }
     
380. }
     
381. }
     
382. return -1;//失败
     
383. }
     
384. 
     
385. //电话呼叫
     
386. int GPRS_Call(char *phone, volatile int *stop)
     
387. {
     
388. char log[128];
     
389. unsigned int t;
     
390. int len, ret;
     
391. InitCommBuf(GETDEFAULTCOMMBUF());
     
392. GPRS_SendString("atd");
     
393. GPRS_SendString(phone);
     
394. GPRS_SendString(";\r");
     
395. Uart_Printf("\n正在呼叫...");
     
396. SLEEP(1000);
     
397. CommBuf_Clean(GETDEFAULTCOMMBUF());
     
398. t = GETTICKCOUNT();
     
399. len = 0;
     
400. do
     
401. {
     
402. ret = ReadCommBuf(GETDEFAULTCOMMBUF(), &log[len], sizeof(log)-1-len, 1000);
     
403. if(ret > 0)
     
404. {
     
405. len += ret;
     
406. log[len] = '\0';
     
407. //Uart_Printf(log);
     
408. if(strstr(log, "OK"))
     
409. {
     
410. Uart_Printf("\n已经接通。");
     
411. SLEEP(5000);
     
412. }
     
413. else if(strstr(log, "BUSY"))
     
414. {
     
415. Uart_Printf("\nBUSY");
     
416. }
     
417. else if(strstr(log, "NO ANSWER"))
     
418. {
     
419. Uart_Printf("\nNO ANSWER");
     
420. }
     
421. else if(strstr(log, "NO CARRIER"))
     
422. {
     
423. Uart_Printf("\nNO CARRIER");
     
424. }
     
425. else
     
426. {
     
427. continue;
     
428. }
     
429. ret = 0;
     
430. break;
     
431. }
     
432. ret = -1;
     
433. }while(GETTICKCOUNT()-t < 120000);
     
434. GPRS_SendString("ath\r");
     
435. if(ret == -1)
     
436. Uart_Printf("\n无应答。");
     
437. SLEEP(1000);
     
438. return ret;
     
439. }
     
440. 
     
441. void GPRS_CallUI(void)
     
442. {
     
443. char phone[32];
     
444. Uart_Printf("\n[电话呼叫]\n电话号码：");
     
445. Uart_GetString(phone);
     
446. GPRS_Call(phone, NULL);
     
447. CommBuf_Dump(GETDEFAULTCOMMBUF());
     
448. }
     
449. 
     
450. /***********************************/
     
451. //AT命令行接口
     
452. static void GPRS_CommandLine(void)
     
453. {
     
454. char key=0;
     
455. Uart_Printf("\n[GPRS AT命令]\n");
     
456. while(1)
     
457. {
     
458. if(rUFSTAT0 & 0x0f)
     
459. {
     
460. key = RdURXH0();//串口0读出数据
     
461. if(key == 0x1b)
     
462. break;
     
463. while(rUFSTAT1 & 0x200);
     
464. WrUTXH1(key);//串口1写数据
     
465. }
     
466. 
     
467. if(rUFSTAT1 & 0x0f)
     
468. {
     
469. while(rUFSTAT0 & 0x200);
     
470. //WrUTXH0(RdURXH1());
     
471. key = RdURXH1();
     
472. if(rUERSTAT1 & 0x0f);
     
473. //Uart_Printf("");
     
474. WrUTXH0(key);
     
475. }
     
476. }
     
477. }
     
478. 
     
479. 
     
480. /***********************************/
     
481. //菜单处理
     
482. 
     
483. const struct MenuItem menu[] = {
     
484. {"AT命令行", GPRS_CommandLine},
     
485. {"发送短信", GPRS_SendSmsUI},
     
486. {"电话呼叫", GPRS_CallUI}
     
487. };//数组变量
     
488. #define MENUITEMCOUNT (sizeof(menu)/sizeof(menu[0]))
     
489. 
     
490. static int ShowMenu(void)
     
491. {
     
492. int i;
     
493. Uart_Printf("\n\n\n--------= GPRS MENU =--------\n");
     
494. for(i=0; i
495. {
     
496. Uart_Printf(" [%d] %s\n", i, menu[i].name);
     
497. }
     
498. Uart_Printf("选择：");
     
499. do//输入所选的菜单
     
500. {
     
501. i = Uart_Getch() - '0';//字符变成数字
     
502. }while(i<0 || i>=MENUITEMCOUNT);//对输入的数字是否有效
     
503. Uart_Printf("%d\n", i);
     
504. return i;
     
505. }
     
506. 
     
507. void GPRS_Test(void)
     
508. {
     
509. int i;
     
510. InitGPRS();//初使化GPRS
     
511. InitCommBuf(GETDEFAULTCOMMBUF());
     
512. if(!GPRS_TestGPRS())
     
513. {
     
514. Uart_Printf("\n没有检测到GPRS模块。");
     
515. return;
     
516. }
     
517. while(1)
     
518. {
     
519. i = ShowMenu();//打印菜单
     
520. if(menu[i].func)
     
521. menu[i].func();
     
522. }
     
523. }
     
524. 
     
525. 
     
526. /*****************************************/
     
527. #ifdef USE_TICK
     
528. #ifdef USE_TIMERTEST
     
529. static void TimerTest(void)
     
530. {
     
531. unsigned int t;
     
532. char h,m,s;
     
533. Uart_Printf("\n[Timer Test]\n");
     
534. Uart_Printf("\nHour:");
     
535. h = Uart_GetIntNum();
     
536. Uart_Printf("\nMin:");
     
537. m = Uart_GetIntNum();
     
538. Uart_Printf("\nSec:");
     
539. s = Uart_GetIntNum();
     
540. Uart_Printf("\n\n%02d:%02d:%02d", h, m, s);
     
541. t = GETTICKCOUNT();
     
542. while(1)
     
543. {
     
544. if(GETTICKCOUNT() - t > 1000)
     
545. {
     
546. t = GETTICKCOUNT();
     
547. if(s < 59)
     
548. s++;
     
549. else if(m < 59)
     
550. {
     
551. s = 0;
     
552. m++;
     
553. }
     
554. else if(h < 23)
     
555. {
     
556. s = m = 0;
     
557. h++;
     
558. }
     
559. else
     
560. {
     
561. s = m = h = 0;
     
562. }
     
563. Uart_Printf("\b\b\b\b\b\b\b\b%02d:%02d:%02d", h, m, s);
     
564. }
     
565. }
     
566. }
     
567. #endif //USE_TIMERTEST
     
568. 
     
569. static void __irq TickCountInt(void)
     
570. {
     
571. rSRCPND = BIT_TIMER4;
     
572. rINTPND = BIT_TIMER4;
     
573. if(rINTPND);
     
574. TickCount++;
     
575. }
     
576. 
     
577. static void InitTick(void)
     
578. {
     
579. pISR_TIMER4 = (unsigned)TickCountInt;
     
580. rTCFG0 = 0x00fc00; //Dead zone=0,Prescaler1=15(0x0f),Prescaler0=15(0x0f)
     
581. rTCFG1 = 0x000000; //All interrupt,Mux4=1/2,Mux3=1/4,Mux2=1/8,Mux1=1/16,Mux0=1/16
     
582. rTCNTB4 = 0x64;
     
583. rTCON = 0x600000; //Auto reload, Inverter off, Manual update, Dead zone disable, Stop
     
584. rTCON = 0x500000; //Auto reload(T0=One-shot),Inverter off,No operation,Dead zone disable,Start
     
585. //
     
586. rINTMSK &= ~BIT_TIMER4;
     
587. }
     
588. #endif //USE_TICK

复制代码

daicheng

程序很长
我看了一下程序注释很详细啊,我简单分析两个如果不明白咱们在讨论
比如:
1：GSM是串口操作的所在首先初始化一个串口给GSM
//GPRS 初始化
static void InitGPRS(void)
{
  InitUart1(9600);//初使化串口1
  #ifdef USE_TICK
   InitTick();
  #ifdef USE_TIMERTEST
   TimerTest();
  #endif//USE_TIMERTEST
  #endif//USE_TICK
}
用串口发送给GSM模块 一个字符
void GPRS_SendChar(char c)
{
  while(rUFSTAT1 & 0x200)
  {
    IDLEPROCESS(GETDEFAULTCOMMBUF());
  }
  WrUTXH1(c);
}
用串口发送给GSM模块 字符串
void GPRS_SendString(char *str)
{
   for(; *str; str++)
   {
     GPRS_SendChar(*str);
   }
}
2:操作模块
//用“AT”命令测试GPRS模块，成功返回1，否则返回0
int GPRS_TestGPRS(void)
{
    char log[32];
    int len;
    //初始化串口缓冲
    InitCommBuf(GETDEFAULTCOMMBUF());
    //发送AT
    GPRS_SendString("at\r");
    //读串口 判断是否有数据  正确是应该回复OK
    if((len=ReadCommBuf(GETDEFAULTCOMMBUF(), log, sizeof(log)-1, 1000)) > 0)
    {
       log[len] = '\0';
       if(strstr(log, "OK"))
       return 1;
    }
  return 0;
}
主要功能就是你发送GSM模块一个 AT字符串 返回一个OK 判断是否成功
3:拿短信功能举例
短信有两种方式
  1:字符方式 下面的代码就是
    基本内容为 at+cmgf=1设置字符模式 如果使用PDU at+cmgf=0
    返回OK
    at+cmgs="手机号"
    >发送内容 +01A
    返回OK
int GPRS_SendTextSMS(char *phone, char *text)
{
   char log[64];
   int len;

   InitCommBuf(GETDEFAULTCOMMBUF());
   //初使化CommBuf
   GPRS_SendString("at+csca=\"+8613800571500\"\r"); //by cx 设置短消息中心
   SLEEP(1000);
   // 延时
   GPRS_SendString("at+cmgf=1\r"); //by cx 设置短消息格式
   SLEEP(1000);
   CommBuf_Clean(GETDEFAULTCOMMBUF());
   //清空CommBuf
   //at+cmgs= "手机号"
   GPRS_SendString("at+cmgs=\"");
   GPRS_SendString(phone);
   GPRS_SendString("\"\r");
  如果接收到数据 发送数据
   len = ReadCommBuf(GETDEFAULTCOMMBUF(), log, sizeof(log)-1, 1000);
   if(len > 0)
   {
     log[len] = '\0';
     Uart_Printf(log);
     if(strstr(log, "> ") && !strstr(log, "ERROR"))
     {
       GPRS_SendString(text);
       GPRS_SendString("\x1a\r");
       if(!CommBuf_WaitString(GETDEFAULTCOMMBUF(), "OK", 10000))
         return 0;//发送成功
       else
         return -3;//发送失败
     }

     return -2;//操作被拒绝
   }
  return -1;//GPRS模块没有应答
}
  2:pDU编码
  首先你应该看PDU编码方式下面的代码你就能看明白了

  PDU中包括 中心号  目标地址手机号  时间 响应参数  数据长度 内容 PDU的号码是需要转换的

[ 本帖最后由 daicheng 于 2010-6-8 11:07 编辑 ]

nicmax

恩 那2410是怎么识别AT命令的 我看了代码也没看到 难道2410直接能读出AT+CMGF=1是AT命令吗

daicheng

是的,2410直接发送的是AT命令,为什么 要识别AT命令呢?
GSM模块内部识别,并对AT解析!

nicmax

我以为是要把AT命令转换成一个格式MC55或者2410才能识别
AT命令也就是他们两者之间的通信规则咯