金笛工业手机论坛  

返回   金笛工业手机论坛 > 开发者乐园 > 短信开发资料

短信开发资料 短信开发技巧,代码分析

回复
 
LinkBack 主题工具 显示模式
旧 2012-08-24   #1 (permalink)
论坛管理员
 
admin 的头像
 
注册日期: 2009-06-30
帖子: 861
admin 的声望功能已被禁用
默认 GSM短信发送PDU编码解码C++控制台实现

GSM短信发送PDU编码解码C++控制台实现

//SendMsg.cpp
  1. #include "StdAfx.h" </SPAN>
  2. #include "SendMsg.h" </SPAN>
  3. HANDLE hComm;//串口设备句柄 </SPAN>
  4. // 正常顺序的字符串转换为两两颠倒的字符串,若长度为奇数,补'F'凑成偶数 </SPAN>
  5. // 如:"8613722216254" --> "683127226152F4" </SPAN>
  6. // pSrc: 源字符串指针 </SPAN>
  7. // pDst: 目标字符串指针 </SPAN>
  8. // nSrcLength: 源字符串长度 </SPAN>
  9. // 返回: 目标字符串长度 </SPAN>
  10. int SendMsg::gsmInvertNumbers(const char* pSrc,char* pDst,int nSrcLength) </SPAN>
  11. {
  12. int nDstLength; // 目标字符串长度 </SPAN>
  13. char ch; // 用于保存一个字符 </SPAN>
  14. // 复制串长度 </SPAN>
  15. nDstLength = nSrcLength;
  16. // 两两颠倒 </SPAN>
  17. for(int i=0; i<nSrcLength;i+=2) </SPAN>
  18. {
  19. ch = *pSrc++; // 保存先出现的字符 </SPAN>
  20. *pDst++ = *pSrc++; // 复制后出现的字符 </SPAN>
  21. *pDst++ = ch; // 复制先出现的字符 </SPAN>
  22. }
  23. // 源串长度是奇数吗? </SPAN>
  24. if(nSrcLength & 1) </SPAN>
  25. {
  26. *(pDst-2) = 'F'; // 补'F' </SPAN>
  27. nDstLength++; // 目标串长度加1 </SPAN>
  28. }
  29. // 输出字符串加个结束符 </SPAN>
  30. *pDst = '/0'; </SPAN>
  31. // 返回目标字符串长度 </SPAN>
  32. return nDstLength; </SPAN>
  33. }
  34. // 两两颠倒的字符串转换为正常顺序的字符串 </SPAN>
  35. // 如:"683127226152F4" --> "8613722216254" </SPAN>
  36. // pSrc: 源字符串指针 </SPAN>
  37. // pDst: 目标字符串指针 </SPAN>
  38. // nSrcLength: 源字符串长度 </SPAN>
  39. // 返回: 目标字符串长度 </SPAN>
  40. int SendMsg::gsmSerializeNumbers(const char* pSrc, char* pDst, int nSrcLength) </SPAN>
  41. {
  42. int nDstLength; // 目标字符串长度 </SPAN>
  43. char ch; // 用于保存一个字符 </SPAN>
  44. // 复制串长度 </SPAN>
  45. nDstLength = nSrcLength;
  46. // 两两颠倒 </SPAN>
  47. for(int i=0; i<nSrcLength;i+=2) </SPAN>
  48. {
  49. ch = *pSrc++; // 保存先出现的字符 </SPAN>
  50. *pDst++ = *pSrc++; // 复制后出现的字符 </SPAN>
  51. *pDst++ = ch; // 复制先出现的字符 </SPAN>
  52. }
  53. // 最后的字符是'F'吗? </SPAN>
  54. if(*(pDst-1) == 'F') </SPAN>
  55. {
  56. pDst--;
  57. nDstLength--; // 目标字符串长度减1 </SPAN>
  58. }
  59. // 输出字符串加个结束符 </SPAN>
  60. *pDst = '/0'; </SPAN>
  61. // 返回目标字符串长度 </SPAN>
  62. return nDstLength; </SPAN>
  63. }
  64. // 7-bit编码 </SPAN>
  65. // pSrc: 源字符串指针 </SPAN>
  66. // pDst: 目标编码串指针 </SPAN>
  67. // nSrcLength: 源字符串长度 </SPAN>
  68. // 返回: 目标编码串长度 </SPAN>
  69. int SendMsg::gsmEncode7bit(const char* pSrc, unsigned char* pDst, int nSrcLength) </SPAN>
  70. {
  71. int nSrc; // 源字符串的计数值 </SPAN>
  72. int nDst; // 目标编码串的计数值 </SPAN>
  73. int nChar; // 当前正在处理的组内字符字节的序号,范围是0-7 </SPAN>
  74. unsigned char nLeft; // 上一字节残余的数据 </SPAN>
  75. // 计数值初始化 </SPAN>
  76. nSrc = 0;
  77. nDst = 0;
  78. // 将源串每8个字节分为一组,压缩成7个字节 </SPAN>
  79. // 循环该处理过程,直至源串被处理完 </SPAN>
  80. // 如果分组不到8字节,也能正确处理 </SPAN>
  81. while(nSrc<nSrcLength) </SPAN>
  82. {
  83. // 取源字符串的计数值的最低3位 </SPAN>
  84. nChar = nSrc & 7;
  85. // 处理源串的每个字节 </SPAN>
  86. if(nChar == 0) </SPAN>
  87. {
  88. // 组内第一个字节,只是保存起来,待处理下一个字节时使用 </SPAN>
  89. nLeft = *pSrc;
  90. }
  91. else </SPAN>
  92. {
  93. // 组内其它字节,将其右边部分与残余数据相加,得到一个目标编码字节 </SPAN>
  94. *pDst = (*pSrc << (8-nChar)) | nLeft;
  95. // 将该字节剩下的左边部分,作为残余数据保存起来 </SPAN>
  96. nLeft = *pSrc >> nChar;
  97. // 修改目标串的指针和计数值 pDst++; </SPAN>
  98. nDst++;
  99. }
  100. // 修改源串的指针和计数值 </SPAN>
  101. pSrc++; nSrc++;
  102. }
  103. // 返回目标串长度 </SPAN>
  104. return nDst; </SPAN>
  105. }
  106. // 7-bit解码 </SPAN>
  107. // pSrc: 源编码串指针 </SPAN>
  108. // pDst: 目标字符串指针 </SPAN>
  109. // nSrcLength: 源编码串长度 </SPAN>
  110. // 返回: 目标字符串长度 </SPAN>
  111. int SendMsg::gsmDecode7bit(const unsigned char* pSrc, char* pDst, int nSrcLength) </SPAN>
  112. {
  113. int nSrc; // 源字符串的计数值 </SPAN>
  114. int nDst; // 目标解码串的计数值 </SPAN>
  115. int nByte; // 当前正在处理的组内字节的序号,范围是0-6 </SPAN>
  116. unsigned char nLeft; // 上一字节残余的数据 </SPAN>
  117. // 计数值初始化 </SPAN>
  118. nSrc = 0;
  119. nDst = 0;
  120. // 组内字节序号和残余数据初始化 </SPAN>
  121. nByte = 0;
  122. nLeft = 0;
  123. // 将源数据每7个字节分为一组,解压缩成8个字节 </SPAN>
  124. // 循环该处理过程,直至源数据被处理完 </SPAN>
  125. // 如果分组不到7字节,也能正确处理 </SPAN>
  126. while(nSrc<nSrcLength) </SPAN>
  127. {
  128. // 将源字节右边部分与残余数据相加,去掉最高位,得到一个目标解码字节 </SPAN>
  129. *pDst = ((*pSrc << nByte) | nLeft) & 0x7f;
  130. // 将该字节剩下的左边部分,作为残余数据保存起来 </SPAN>
  131. nLeft = *pSrc >> (7-nByte);
  132. // 修改目标串的指针和计数值 </SPAN>
  133. pDst++;
  134. nDst++;
  135. // 修改字节计数值 </SPAN>
  136. nByte++;
  137. // 到了一组的最后一个字节 </SPAN>
  138. if(nByte == 7) </SPAN>
  139. {
  140. // 额外得到一个目标解码字节 </SPAN>
  141. *pDst = nLeft;
  142. // 修改目标串的指针和计数值 </SPAN>
  143. pDst++;
  144. nDst++;
  145. // 组内字节序号和残余数据初始化 </SPAN>
  146. nByte = 0;
  147. nLeft = 0;
  148. }
  149. // 修改源串的指针和计数值 </SPAN>
  150. pSrc++;
  151. nSrc++;
  152. }
  153. *pDst = 0;
  154. // 返回目标串长度 </SPAN>
  155. return nDst; </SPAN>
  156. }
  157. // 8bit编码 </SPAN>
  158. // 输入: pSrc - 源字符串指针 </SPAN>
  159. // nSrcLength - 源字符串长度 </SPAN>
  160. // 输出: pDst - 目标编码串指针 </SPAN>
  161. // 返回: 目标编码串长度 </SPAN>
  162. int SendMsg::gsmEncode8bit(const char* pSrc,unsigned char* pDst,int nSrcLength) </SPAN>
  163. {
  164. // 简单复制 </SPAN>
  165. memcpy(pDst, pSrc, nSrcLength);
  166. return nSrcLength; </SPAN>
  167. }
  168. // 8bit解码 </SPAN>
  169. // 输入: pSrc - 源编码串指针 </SPAN>
  170. // nSrcLength - 源编码串长度 </SPAN>
  171. // 输出: pDst - 目标字符串指针 </SPAN>
  172. // 返回: 目标字符串长度 </SPAN>
  173. int SendMsg::gsmDecode8bit(const unsigned char* pSrc, char* pDst, int nSrcLength) </SPAN>
  174. {
  175. // 简单复制 </SPAN>
  176. memcpy(pDst, pSrc, nSrcLength);
  177. // 输出字符串加个结束符 </SPAN>
  178. *pDst = '/0 '; </SPAN>
  179. return nSrcLength; </SPAN>
  180. }
  181. // UCS2编码 </SPAN>
  182. // 输入: pSrc - 源字符串指针 </SPAN>
  183. // nSrcLength - 源字符串长度 </SPAN>
  184. // 输出: pDst - 目标编码串指针 </SPAN>
  185. // 返回: 目标编码串长度 </SPAN>
  186. int SendMsg::gsmEncodeUcs2(const char* pSrc, unsigned char* pDst, int nSrcLength) </SPAN>
  187. {
  188. int nDstLength; // UNICODE宽字符数目 </SPAN>
  189. WCHAR wchar[128]; // UNICODE串缓冲区 </SPAN>
  190. // 字符串-->UNICODE串 </SPAN>
  191. nDstLength = MultiByteToWideChar(CP_ACP, 0, pSrc, nSrcLength, wchar, 128);
  192. // 高低字节对调,输出 </SPAN>
  193. for(int i=0; i<nDstLength; i++) </SPAN>
  194. {
  195. *pDst++ = wchar[i] >> 8; // 先输出高位字节 </SPAN>
  196. *pDst++ = wchar[i] & 0xff; // 后输出低位字节 </SPAN>
  197. }
  198. // 返回目标编码串长度 </SPAN>
  199. return nDstLength * 2; </SPAN>
  200. }
  201. // UCS2解码 </SPAN>
  202. // 输入: pSrc - 源编码串指针 </SPAN>
  203. // nSrcLength - 源编码串长度 </SPAN>
  204. // 输出: pDst - 目标字符串指针 </SPAN>
  205. // 返回: 目标字符串长度 </SPAN>
  206. // </SPAN>
  207. int SendMsg::gsmDecodeUcs2(const unsigned char* pSrc, char* pDst, int nSrcLength) </SPAN>
  208. {
  209. int nDstLength; // UNICODE宽字符数目 </SPAN>
  210. WCHAR wchar[128]; // UNICODE串缓冲区 </SPAN>
  211. // 高低字节对调,拼成UNICODE </SPAN>
  212. for(int i=0; i<nSrcLength/2; i++) </SPAN>
  213. {
  214. wchar[i] = *pSrc++ << 8; // 先高位字节 </SPAN>
  215. wchar[i] |= *pSrc++; // 后低位字节 </SPAN>
  216. }
  217. // UNICODE串-->字符串 </SPAN>
  218. nDstLength = WideCharToMultiByte(CP_ACP, 0, wchar, nSrcLength/2, pDst, 160, NULL, NULL);
  219. // 输出字符串加个结束符 </SPAN>
  220. pDst[nDstLength] = '/0'; </SPAN>
  221. // 返回目标字符串长度 </SPAN>
  222. return nDstLength; </SPAN>
  223. }
  224. // 可打印字符串转换为字节数据 </SPAN>
  225. // 如:"C8329BFD0E01" --> {0xC8, 0x32, 0x9B, 0xFD, 0x0E, 0x01} </SPAN>
  226. // pSrc: 源字符串指针 </SPAN>
  227. // pDst: 目标数据指针 </SPAN>
  228. // nSrcLength: 源字符串长度 </SPAN>
  229. // 返回: 目标数据长度 </SPAN>
  230. int SendMsg::gsmString2Bytes(const char* pSrc, unsigned char* pDst, int nSrcLength) </SPAN>
  231. {
  232. for(int i=0; i<nSrcLength; i+=2) </SPAN>
  233. {
  234. // 输出高4位 </SPAN>
  235. if(*pSrc>='0' && *pSrc<='9') </SPAN>
  236. {
  237. *pDst = (*pSrc - '0') << 4; </SPAN>
  238. }
  239. else </SPAN>
  240. {
  241. *pDst = (*pSrc - 'A' + 10) << 4; </SPAN>
  242. }
  243. pSrc++;
  244. // 输出低4位 </SPAN>
  245. if(*pSrc>='0' && *pSrc<='9') </SPAN>
  246. {
  247. *pDst |= *pSrc - '0'; </SPAN>
  248. }
  249. else </SPAN>
  250. {
  251. *pDst |= *pSrc - 'A' + 10; </SPAN>
  252. }
  253. pSrc++;
  254. pDst++;
  255. }
  256. // 返回目标数据长度 </SPAN>
  257. return nSrcLength / 2; </SPAN>
  258. }
  259. // 字节数据转换为可打印字符串 </SPAN>
  260. // 如:{0xC8, 0x32, 0x9B, 0xFD, 0x0E, 0x01} --> "C8329BFD0E01" </SPAN>
  261. // pSrc: 源数据指针 </SPAN>
  262. // pDst: 目标字符串指针 </SPAN>
  263. // nSrcLength: 源数据长度 </SPAN>
  264. // 返回: 目标字符串长度 </SPAN>
  265. int SendMsg::gsmBytes2String(const unsigned char* pSrc, char* pDst, int nSrcLength) </SPAN>
  266. {
  267. const char tab[]="0123456789ABCDEF"; // 0x0-0xf的字符查找表 </SPAN>
  268. for(int i=0; i<nSrcLength; i++) </SPAN>
  269. {
  270. // 输出低4位 </SPAN>
  271. *pDst++ = tab[*pSrc >> 4];
  272. // 输出高4位 </SPAN>
  273. *pDst++ = tab[*pSrc & 0x0f];
  274. pSrc++;
  275. }
  276. // 输出字符串加个结束符 </SPAN>
  277. *pDst = '/0'; </SPAN>
  278. // 返回目标字符串长度 </SPAN>
  279. return nSrcLength * 2; </SPAN>
  280. }
  281. // PDU编码,用于编制、发送短消息 </SPAN>
  282. // pSrc: 源PDU参数指针 </SPAN>
  283. // pDst: 目标PDU串指针 </SPAN>
  284. // 返回: 目标PDU串长度 </SPAN>
  285. int SendMsg::gsmEncodePdu(const SM_PARAM* pSrc, char* pDst) </SPAN>
  286. {
  287. int nLength; // 内部用的串长度 </SPAN>
  288. int nDstLength; // 目标PDU串长度 </SPAN>
  289. unsigned char buf[256]; // 内部用的缓冲区 </SPAN>
  290. // SMSC地址信息段 </SPAN>
  291. nLength = strlen(pSrc->SCA); // SMSC地址字符串的长度 </SPAN>
  292. buf[0] = (char)((nLength & 1) == 0 ? nLength : nLength + 1) / 2 + 1; // SMSC地址信息长度 </SPAN>
  293. buf[1] = 0x91; // 固定: 用国际格式号码 </SPAN>
  294. nDstLength = gsmBytes2String(buf, pDst, 2); // 转换2个字节到目标PDU串 </SPAN>
  295. nDstLength +=gsmInvertNumbers(pSrc->SCA, &pDst[nDstLength], nLength); // 转换SMSC到目标PDU串 </SPAN>
  296. // TPDU段基本参数、目标地址等 </SPAN>
  297. nLength = strlen(pSrc->TPA); // TP-DA地址字符串的长度 </SPAN>
  298. buf[0] = 0x11; // 是发送短信(TP-MTI=01),TP-VP用相对格式(TP-VPF=10) </SPAN>
  299. buf[1] = 0; // TP-MR=0 </SPAN>
  300. buf[2] = (char)nLength; // 目标地址数字个数(TP-DA地址字符串真实长度) </SPAN>
  301. buf[3] = 0x91; // 固定: 用国际格式号码 </SPAN>
  302. nDstLength +=gsmBytes2String(buf, &pDst[nDstLength], 4); // 转换4个字节到目标PDU串 </SPAN>
  303. nDstLength +=gsmInvertNumbers(pSrc->TPA, &pDst[nDstLength], nLength); // 转换TP-DA到目标PDU串 </SPAN>
  304. // TPDU段协议标识、编码方式、用户信息等 </SPAN>
  305. nLength = strlen(pSrc->TP_UD); // 用户信息字符串的长度 </SPAN>
  306. buf[0] = pSrc->TP_PID; // 协议标识(TP-PID) </SPAN>
  307. buf[1] = pSrc->TP_DCS; // 用户信息编码方式(TP-DCS) </SPAN>
  308. buf[2] = 0; // 有效期(TP-VP)为5分钟 </SPAN>
  309. if(pSrc->TP_DCS == GSM_7BIT) </SPAN>
  310. {
  311. // 7-bit编码方式 </SPAN>
  312. buf[3] = nLength; // 编码前长度 </SPAN>
  313. nLength =gsmEncode7bit(pSrc->TP_UD, &buf[4], nLength+1) + 4; // 转换TP-DA到目标PDU串 </SPAN>
  314. }
  315. else if(pSrc->TP_DCS == GSM_UCS2) </SPAN>
  316. {
  317. // UCS2编码方式 </SPAN>
  318. buf[3] =gsmEncodeUcs2(pSrc->TP_UD, &buf[4], nLength); // 转换TP-DA到目标PDU串 </SPAN>
  319. nLength = buf[3] + 4; // nLength等于该段数据长度 </SPAN>
  320. }
  321. else </SPAN>
  322. {
  323. // 8-bit编码方式 </SPAN>
  324. buf[3] =gsmEncode8bit(pSrc->TP_UD, &buf[4], nLength); // 转换TP-DA到目标PDU串 </SPAN>
  325. nLength = buf[3] + 4; // nLength等于该段数据长度 </SPAN>
  326. }
  327. nDstLength +=gsmBytes2String(buf, &pDst[nDstLength], nLength); // 转换该段数据到目标PDU串 </SPAN>
  328. // 返回目标字符串长度 </SPAN>
  329. return nDstLength; </SPAN>
  330. }
  331. // PDU解码,用于接收、阅读短消息 </SPAN>
  332. // pSrc: 源PDU串指针 </SPAN>
  333. // pDst: 目标PDU参数指针 </SPAN>
  334. // 返回: 用户信息串长度 </SPAN>
  335. int SendMsg::gsmDecodePdu(const char* pSrc, SM_PARAM* pDst) </SPAN>
  336. {
  337. int nDstLength; // 目标PDU串长度 </SPAN>
  338. unsigned char tmp; // 内部用的临时字节变量 </SPAN>
  339. unsigned char buf[256]; // 内部用的缓冲区 </SPAN>
  340. //printf("Msg=%s/n",pSrc); </SPAN>
  341. // SMSC地址信息段 </SPAN>
  342. gsmString2Bytes(pSrc, &tmp, 2); // 取长度 </SPAN>
  343. tmp = (tmp - 1) * 2; // SMSC号码串长度 </SPAN>
  344. pSrc += 4; // 指针后移 </SPAN>
  345. gsmSerializeNumbers(pSrc, pDst->SCA, tmp); // 转换SMSC号码到目标PDU串 </SPAN>
  346. pSrc += tmp; // 指针后移 </SPAN>
  347. //printf("SMSC=%s/n",pDst->SCA); </SPAN>
  348. // TPDU段基本参数、回复地址等 </SPAN>
  349. gsmString2Bytes(pSrc, &tmp, 2); // 取基本参数 </SPAN>
  350. pSrc += 2; // 指针后移 </SPAN>
  351. // if(tmp & 0x80) </SPAN>
  352. //{ </SPAN>
  353. // 包含回复地址,取回复地址信息 </SPAN>
  354. gsmString2Bytes(pSrc, &tmp, 2); // 取长度 </SPAN>
  355. if(tmp & 1) tmp += 1; // 调整奇偶性 </SPAN>
  356. pSrc += 4; // 指针后移 </SPAN>
  357. gsmSerializeNumbers(pSrc, pDst->TPA, tmp); // 取TP-RA号码 </SPAN>
  358. pSrc += tmp; // 指针后移 </SPAN>
  359. //printf("TP-RA=%s/n",pDst->TPA); </SPAN>
  360. //} </SPAN>
  361. // TPDU段协议标识、编码方式、用户信息等 </SPAN>
  362. gsmString2Bytes(pSrc, (unsigned char*)&pDst->TP_PID, 2); // 取协议标识(TP-PID) </SPAN>
  363. //printf("TP-PID=%c/n",pDst->TP_PID); </SPAN>
  364. pSrc += 2; // 指针后移 </SPAN>
  365. gsmString2Bytes(pSrc, (unsigned char*)&pDst->TP_DCS, 2); // 取编码方式(TP-DCS) </SPAN>
  366. //printf("TP-DCS=%c/n",pDst->TP_DCS); </SPAN>
  367. pSrc += 2; // 指针后移 </SPAN>
  368. gsmSerializeNumbers(pSrc, pDst->TP_SCTS, 14); // 服务时间戳字符串(TP_SCTS) </SPAN>
  369. //printf("TP-SCTS=%s/n",pDst->TP_SCTS); </SPAN>
  370. pSrc += 14; // 指针后移 </SPAN>
  371. gsmString2Bytes(pSrc, &tmp, 2); // 用户信息长度(TP-UDL) </SPAN>
  372. pSrc += 2; // 指针后移 </SPAN>
  373. if(pDst->TP_DCS == GSM_7BIT) </SPAN>
  374. {
  375. // 7-bit解码 </SPAN>
  376. nDstLength = gsmString2Bytes(pSrc, buf, tmp & 7 ? (int)tmp * 7 / 4 + 2 : (int)tmp * 7 / 4); // 格式转换 </SPAN>
  377. gsmDecode7bit(buf, pDst->TP_UD, nDstLength); // 转换到TP-DU </SPAN>
  378. nDstLength = tmp;
  379. }
  380. else if(pDst->TP_DCS == GSM_UCS2) </SPAN>
  381. {
  382. // UCS2解码 </SPAN>
  383. nDstLength = gsmString2Bytes(pSrc, buf, tmp * 2); // 格式转换 </SPAN>
  384. nDstLength = gsmDecodeUcs2(buf, pDst->TP_UD, nDstLength); // 转换到TP-DU </SPAN>
  385. }
  386. else </SPAN>
  387. {
  388. // 8-bit解码 </SPAN>
  389. nDstLength = gsmString2Bytes(pSrc, buf, tmp * 2); // 格式转换 </SPAN>
  390. nDstLength = gsmDecode8bit(buf, pDst->TP_UD, nDstLength); // 转换到TP-DU </SPAN>
  391. }
  392. //printf("MessgeContent=%s/n",pDst->TP_UD); </SPAN>
  393. // 返回目标字符串长度 </SPAN>
  394. return nDstLength; </SPAN>
  395. }
  396. // 发送短消息 </SPAN>
  397. // pSrc: 源PDU参数指针 </SPAN>
  398. BOOL SendMsg::gsmSendMessage(const SM_PARAM* pSrc) </SPAN>
  399. {
  400. int nPduLength; // PDU串长度 </SPAN>
  401. unsigned char nSmscLength; // SMSC串长度 </SPAN>
  402. int nLength; // 串口收到的数据长度 </SPAN>
  403. char cmd[16]; // 命令串 </SPAN>
  404. char pdu[512]; // PDU串 </SPAN>
  405. char ans[128]; // 应答串 </SPAN>
  406. nPduLength = gsmEncodePdu(pSrc, pdu); // 根据PDU参数,编码PDU串 </SPAN>
  407. strcat(pdu, "/x01a"); // 以Ctrl-Z结束 </SPAN>
  408. gsmString2Bytes(pdu, &nSmscLength, 2); // 取PDU串中的SMSC信息长度 </SPAN>
  409. nSmscLength++; // 加上长度字节本身 </SPAN>
  410. // 命令中的长度,不包括SMSC信息长度,以数据字节计 </SPAN>
  411. sprintf(cmd, "AT+CMGS=%d/r", nPduLength / 2 - nSmscLength); // 生成命令 </SPAN>
  412. WriteComm(cmd, strlen(cmd)); // 先输出命令串 </SPAN>
  413. nLength = ReadComm(ans, 128); // 读应答数据 </SPAN>
  414. // 根据能否找到"/r/n> "决定成功与否 </SPAN>
  415. if(nLength == 4 && strncmp(ans, "/r/n> ", 4) == 0) </SPAN>
  416. {
  417. WriteComm(pdu, strlen(pdu)); // 得到肯定回答,继续输出PDU串 </SPAN>
  418. nLength =ReadComm(ans, 128); // 读应答数据 </SPAN>
  419. // 根据能否找到"+CMS ERROR"决定成功与否 </SPAN>
  420. if(nLength > 0 && strncmp(ans, "+CMS ERROR", 10) != 0) </SPAN>
  421. {
  422. return TRUE; </SPAN>
  423. }
  424. }
  425. return FALSE; </SPAN>
  426. }
  427. // 删除短消息 </SPAN>
  428. // index: 短消息序号,从1开始 </SPAN>
  429. BOOL SendMsg::gsmDeleteMessage(const int index) </SPAN>
  430. {
  431. int nLength; // 串口收到的数据长度 </SPAN>
  432. char cmd[16]; // 命令串 </SPAN>
  433. char ans[128]; // 应答串 </SPAN>
  434. sprintf(cmd, "AT+CMGD=%d/r", index); // 生成命令 </SPAN>
  435. // 输出命令串 </SPAN>
  436. WriteComm(cmd, strlen(cmd));
  437. // 读应答数据 </SPAN>
  438. nLength = ReadComm(ans, 128);
  439. // 根据能否找到"+CMS ERROR"决定成功与否 </SPAN>
  440. if(nLength > 0 && strncmp(ans, "+CMS ERROR", 10) != 0) </SPAN>
  441. {
  442. return TRUE; </SPAN>
  443. }
  444. return FALSE; </SPAN>
  445. }
  446. // 打开串口 </SPAN>
  447. // pPort: 串口名称或设备路径,可用"COM1" </SPAN>
  448. // nBaudRate: 波特率 </SPAN>
  449. // nParity: 奇偶校验 </SPAN>
  450. // nByteSize: 数据字节宽度 </SPAN>
  451. // nStopBits: 停止位 </SPAN>
  452. BOOL SendMsg::OpenComm(const char* pPort, int nBaudRate, int nParity, int nByteSize, int nStopBits) </SPAN>
  453. {
  454. DCB dcb; // 串口控制块 </SPAN>
  455. COMMTIMEOUTS timeouts = { // 串口超时控制参数 </SPAN>
  456. 100, // 读字符间隔超时时间: 100 ms </SPAN>
  457. 1, // 读操作时每字符的时间: 1 ms (n个字符总共为n ms) </SPAN>
  458. 500, // 基本的(额外的)读超时时间: 500 ms </SPAN>
  459. 1, // 写操作时每字符的时间: 1 ms (n个字符总共为n ms) </SPAN>
  460. 100}; // 基本的(额外的)写超时时间: 100 ms </SPAN>
  461. hComm = CreateFile(pPort, // 串口名称或设备路径 </SPAN>
  462. GENERIC_READ | GENERIC_WRITE, // 读写方式 </SPAN>
  463. 0, // 共享方式:独占 </SPAN>
  464. NULL, // 默认的安全描述符 </SPAN>
  465. OPEN_EXISTING, // 创建方式 </SPAN>
  466. 0, // 不需设置文件属性 </SPAN>
  467. NULL); // 不需参照模板文件 </SPAN>
  468. if(hComm == INVALID_HANDLE_VALUE) </SPAN>
  469. return FALSE; // 打开串口失败 </SPAN>
  470. GetCommState(hComm, &dcb); // 取DCB </SPAN>
  471. dcb.BaudRate = nBaudRate;
  472. dcb.ByteSize = nByteSize;
  473. dcb.Parity = nParity;
  474. dcb.StopBits = nStopBits;
  475. ////////////////// </SPAN>
  476. //PurgeComm(hComm, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR); </SPAN>
  477. //SetCommMask(hComm,EV_ERR|EV_RXCHAR); </SPAN>
  478. ///////////////// </SPAN>
  479. SetCommState(hComm, &dcb); // 设置DCB </SPAN>
  480. SetupComm(hComm, 4096, 1024); // 设置输入输出缓冲区大小 </SPAN>
  481. SetCommTimeouts(hComm, &timeouts); // 设置超时 </SPAN>
  482. //printf("OpenComm/n"); </SPAN>
  483. return TRUE; </SPAN>
  484. }
  485. // 关闭串口 </SPAN>
  486. BOOL SendMsg::CloseComm() </SPAN>
  487. {
  488. return CloseHandle(hComm); </SPAN>
  489. }
  490. // 写串口 </SPAN>
  491. // pData: 待写的数据缓冲区指针 </SPAN>
  492. // nLength: 待写的数据长度 </SPAN>
  493. void SendMsg::WriteComm(void* pData, int nLength) </SPAN>
  494. {
  495. DWORD dwNumWrite; // 串口发出的数据长度 </SPAN>
  496. WriteFile(hComm, pData, (DWORD)nLength, &dwNumWrite, NULL); </SPAN>
  497. }
  498. // 读串口 </SPAN>
  499. // pData: 待读的数据缓冲区指针 </SPAN>
  500. // nLength: 待读的最大数据长度 </SPAN>
  501. // 返回: 实际读入的数据长度 </SPAN>
  502. int SendMsg::ReadComm(void* pData, int nLength) </SPAN>
  503. {
  504. DWORD dwNumRead; // 串口收到的数据长度 </SPAN>
  505. ReadFile(hComm, pData, (DWORD)nLength, &dwNumRead, NULL); </SPAN>
  506. return (int)dwNumRead; </SPAN>
  507. }
  508. // 读取短消息,仅发送命令,不读取应答 </SPAN>
  509. // 用+CMGL代替+CMGR,可一次性读出全部短消息 </SPAN>
  510. void SendMsg::gsmReadMessageList() </SPAN>
  511. {
  512. WriteComm("AT+CMGL/r",8); </SPAN>
  513. }
  514. // 初始化GSM状态 </SPAN>
  515. BOOL SendMsg::gsmInit() </SPAN>
  516. {
  517. char ans[128]; // 应答串 </SPAN>
  518. // 测试GSM-MODEM的存在性 </SPAN>
  519. WriteComm("AT/r", 3); </SPAN>
  520. Sleep(100);
  521. ReadComm(ans, 128);
  522. if (strstr(ans, "OK") == NULL) //给两次机会 </SPAN>
  523. {
  524. Sleep(100);
  525. WriteComm("AT/r", 3); </SPAN>
  526. ReadComm(ans, 128);
  527. if(strstr(ans, "OK") == NULL) </SPAN>
  528. return FALSE; </SPAN>
  529. }
  530. // ECHO OFF </SPAN>
  531. WriteComm("ATE0/r", 5); </SPAN>
  532. ReadComm(ans, 128);
  533. // PDU模式 </SPAN>
  534. WriteComm("AT+CMGF=0/r", 10); </SPAN>
  535. ReadComm(ans, 128);
  536. ////////////////////////////////////// </SPAN>
  537. WriteComm("AT+CSMS=1/r", 10); </SPAN>
  538. ReadComm(ans, 128);
  539. WriteComm("AT+CNMI=2,1/r", 12); </SPAN>
  540. ReadComm(ans, 128);
  541. /////////////////////////////////////// </SPAN>
  542. // printf("InitCOMM/n"); </SPAN>
  543. return TRUE; </SPAN>
  544. }
  545. // 读取GSM MODEM的应答,可能是一部分 </SPAN>
  546. // 输出: pBuff - 接收应答缓冲区 </SPAN>
  547. // 返回: GSM MODEM的应答状态, GSM_WAIT/GSM_OK/GSM_ERR </SPAN>
  548. // 备注: 可能需要多次调用才能完成读取一次应答,首次调用时应将pBuff初始化 </SPAN>
  549. int SendMsg::gsmGetResponse(SM_BUFF* pBuff) </SPAN>
  550. {
  551. int nLength; // 串口收到的数据长度 </SPAN>
  552. int nState; </SPAN>
  553. // 从串口读数据,追加到缓冲区尾部 </SPAN>
  554. nLength = ReadComm(&pBuff->data[pBuff->len], 128);
  555. pBuff->len += nLength;
  556. //确定GSM MODEM的应答状态 </SPAN>
  557. nState = GSM_WAIT;
  558. if ((nLength > 0) && (pBuff->len >= 4)) </SPAN>
  559. {
  560. //if (strncmp(&pBuff->data[pBuff->len - 4], "OK/r/n", 4) == 0) </SPAN>
  561. if(strstr(pBuff->data, "OK/r/n")!=NULL) </SPAN>
  562. nState = GSM_OK;
  563. else if (strstr(pBuff->data, "+CMS ERROR") != NULL) </SPAN>
  564. nState = GSM_ERR;
  565. }
  566. return nState; </SPAN>
  567. }
  568. // 从列表中解析出全部短消息 </SPAN>
  569. // 输入: pBuff - 短消息列表缓冲区 </SPAN>
  570. // 输出: pMsg - 短消息缓冲区 </SPAN>
  571. // 返回: 短消息条数 </SPAN>
  572. int SendMsg::gsmParseMessageList(SM_PARAM* pMsg, SM_BUFF* pBuff) </SPAN>
  573. {
  574. int nMsg; // 短消息计数值 </SPAN>
  575. char* ptr; // 内部用的数据指针 </SPAN>
  576. nMsg = 0;
  577. ptr = pBuff->data;
  578. // 循环读取每一条短消息, 以"+CMGL:"开头 </SPAN>
  579. while((ptr = strstr(ptr, "+CMGL:")) != NULL) </SPAN>
  580. {
  581. ptr += 6; // 跳过"+CMGL:", 定位到序号// </SPAN>
  582. sscanf(ptr, "%d", &pMsg->index); // 读取序号 </SPAN>
  583. // TRACE(" index=%d/n",pMsg->index); </SPAN>
  584. //printf("index=%d/n",pMsg->index); </SPAN>
  585. ptr = strstr(ptr, "/r/n"); // 找下一行 </SPAN>
  586. if (ptr != NULL) </SPAN>
  587. {
  588. ptr += 2; // 跳过"/r/n", 定位到PDU </SPAN>
  589. gsmDecodePdu(ptr, pMsg); // PDU串解码 </SPAN>
  590. pMsg++; // 准备读下一条短消息 </SPAN>
  591. nMsg++; // 短消息计数加1 </SPAN>
  592. }
  593. }
  594. return nMsg; </SPAN>
  595. }
__________________

让世界倾听我们的笛声
admin 当前离线   回复时引用此帖
回复

书签


当前查看此主题的会员: 1 (0 位会员和 1 位游客)
 
主题工具
显示模式

发帖规则
不可以发表新主题
不可以发表回复
不可以上传附件
不可以编辑自己的帖子

启用 BB 代码
论坛启用 表情符号
论坛启用 [IMG] 代码
论坛禁用 HTML 代码
Trackbacks are 启用
Pingbacks are 启用
Refbacks are 启用



所有时间均为北京时间。现在的时间是 17:59


Powered by vBulletin® 版本 3.8.3
版权所有 ©2000 - 2024,Jelsoft Enterprises Ltd.