开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > GPS编程 > 查看源码
Do_M22.C
资源名称：GPRS.rar　[点击查看]
上传用户：zanguozi01
上传日期：2014-02-19
资源大小：155k
文件大小：79k
源码类别：

GPS编程

开发平台：

Others

Do_M22.C：源码内容
  2. /********************************************************
  3. * 文件名：  Do_GSM.C
  4. * 创建时间：2004年12月7日
  5. * 创建人：  
  6. * 版本号：  1.00
  7. * 功能：   针对GSM模块进行的一些操作，包括发送数据和接收数据
  8. * 文件属性：公共文件
  9. * 修改历史：（每条详述）
  10. ********************************************************/
  11. #include <msp430x14x.h>
  12. #include "Other_Define.h"
  13. #include "General.h"
  14. #include "SPI45DB041.h"
  15. #include "Define_Bit.h"
  16. #include "D_Buffer.h"
  17. #include "Uart01.h"
  18. #include "M22_AT.h"
  19. #include "Check_GSM.h"
  20. #include "Sub_C.h"
  21. #include "Do_Reset.h"
  22. #include "W_Protocol.h"
  23. #include "TA_Uart.h"
  24. #include "Handle_Protocol.h"
  25. #include "Do_Handle.h"
  26. #include "Do_SRAM.h"
  27. #include "Do_M22.h"
  28. /*
  29. #include "Do_Record.h"
  30. #include "Record_Protocol.h"
  31. #include "Main_Init.h"
  32. #include "Disp_Protocol.h"
  33. */
  34. #define Debug_GSM_COM1
  36. void Case1_GSM_PHONE(void);
  37. void Case1_PHONE_Out(void);
  40. void Case2_GSM_OTHER(void);
  41. void Case2_OTHER_Out(void);
  43. void Case3_GSM_SMS_IN(void);
  44. void Case3_SMSIN_Out(void);
  46. void Case4_GSM_SMS_OUT(void);
  47. void Case4_SMSOUT_Out(void);
  48. void Case4_OverTime_Out(unsigned char Clear_Flag);
  50. void Case5_LAND_GPRS_OPER(void);
  51. void Case6_GPRS_DATA_OPER(void);
  53. void Send_Type1_GSM_Data_One(unsigned char S_Address);
  54. void Send_Type1_GSM_Data_Two(unsigned char S_Address);
  56. void Send_Circle_GSM_TypeD(void);
  57. void Send_Circle_TCP_TypeD(void);
  58. void Send_Circle_GSM_TypeE(void);
  59. void Send_Circle_TCP_TypeE(void);
  60. void Case_OverTime_Return(void);
  62. //作为音量四个档位(起作用的也就是后面的四个数，前一个数的存在是为了使数组的下标和音量值想对应上)
  63. /********************************************************
  64. * 函数名：Do_G20_Out
  65. 作用域：外部文件调用
  66. * 功能：
  67. * 参数：
  68. * 返回值：
  69. * 创建人：
  70. *
  71. * 修改历史：（每条详述）
  72. A,表示GSM工作方式
  73. B,表示TCP挂起的工作方式
  74. C,表示TCP在线的工作方式
  76. 补充说明：因为根据M22模块的特性：几个CASE的功能
  77. 1，处理与电话相关的业务(AB)，
  78. 2，处理与CSQ方面的查询(AB)
  79. 3，SMS的接收(中断方式接收处理)(AB)
  80. 4，SMS的发送操作(A)
  81. 5，处理需要TCP登陆，TCP退出,TCP在线。
  82. 6，TCP在线状态下进行TCP的数据业务
  84. 根据M22的相关特性：则可以分为如下几种操作方式
  86. 正常的工作流程：
  87. 设备启动后：如果根据条件需要进行TCP登陆的话
  88. 1-2-3-4-5(登陆)--6(发送登陆信息)---等待登陆响应----(A)接收到响应(A01)6(循环处理)(A02)CSQ查询时间到(A03)+++挂起(A03)2---(A04)6(循环处理)
  89.     ---
  90.                             ---(A011)判断有电话相关的业务(拨出号码和电话打入)--(A012)+++挂起---1()
  92.    ----(B)未接收到响应(B01)6(发送登陆信息)--等待登陆响应
  93. 具体的的工作方式：
  94. 1，设备上电，启动M22，进入GSM的工作方式：
  95. 2，如果判断设备判断有报警信息(报警信息默认为30秒的周期发送)，
  96. 同时IP地址有效，TCP处于开启状态，则需要在启动M22工作后，
  97. 进行TCP登陆操作，此时需要TCP一直在线，进行发送报警信息
  98. 3，如果判断设备有需要发送行车轨迹数据，同时IP地址有效，TCP处于开启状态，
  99. 则也需要在启动M22工作后，进行TCP登陆操作，此时又分两重情况
  100. 如果发送轨迹数据的周期如果小于3分钟，则属于一直在线状态)，而如何
  101. 发送行车轨迹数据的周期大于等于3分钟，则在需要发送轨迹数据的时刻
  102. 才进行登陆操作，然后进行发送数据。发送完数据后，则立即退出TCP在线。
  103. 4，如果属于TCP一直在线的状态，则每间隔一定时间将TCP挂起，进行CSQ的查询
  105. 登陆TCP的工作流程：如果登陆上TCP，并且通过TCP发送登陆信息后，等待返回登陆响应
  106. 如果超过一定时间未返回登陆响应，则继续发送登陆信息。如果连续5次均为发送登陆信息后
  107. 仍无登陆响应，则退出TCPZ状态，重新进行TCP登陆
  108. ********************************************************/
  109. void Do_G20_Out(void)
  110. {
  111. switch(gGSM_Oper_Type)
  112. {
  113. /*
  114. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  115. 1，GSM_PHONE:主要是针对电话语音方面的处理，拨号，接听，挂机，DTMF，音量调节。根据M22的特殊性，如果TCP
  116. 在线的状态下，必须要先退出TCP在线，然后才能进行相关电话业务的处理
  117. 只有在GSM的工作方式下执行这个指令
  118. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  119. */
  120. case GSM_PHONE:
  121. {
  122. Case1_GSM_PHONE();
  123. break;
  124. }
  125. /*
  126. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  127. 2，GSM_OTHER：没电话的时候CSQ的查询,根据M22的方式，则可以不通过查询CLCC来确定电话业务的状态
  128.    在GSM和TCP挂起的状态下执行
  129. +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  130. */
  131. case GSM_OTHER:
  132. {
  133. Case2_GSM_OTHER();
  134. break;
  135. }
  136. /*
  137. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  138. 3，GSM_SMS_IN：因为M22的接收SMS的方式采用的是中断方式，则直接在中断处理中处理，则可以不处理这个模块
  139. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  140. */
  141. case GSM_SMS_IN:
  142. {
  143. Case3_GSM_SMS_IN();
  144. break;
  145. }
  146. /*
  147. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  148. 4，GSM_SMS_OUT：主要处理M22通过GSM方式发送数据包，只有在GSM工作方式下
  149. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  150. */
  151. case GSM_SMS_OUT:
  152. {
  153. Case4_GSM_SMS_OUT();
  154. break;
  155. }
  156. /*
  157. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  158. 5，CHECK_GPRS_LINK：专门用于进行退出TCP和登陆TCP的操作流程，或者重新执行进入TCP的操作
  159. 在GSM工作方式和TCP挂起的方式下
  160. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  161. */
  162. case LAND_TCP_OPER:
  163. {
  164. Case5_LAND_GPRS_OPER();
  165. break;
  166. }
  167. /*
  168. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  169. 6，GPRS_DATA_OPER：M22的TCP方式发送和接收数据(),如果需要退出的时候进行AT指令的其他操作的时候，则需要
  170. 先将TCP挂起，可以进行接收SMS，或者发送SMS。如果是电话业务，则需要挂起后，然后退出TCP登陆，才可以进行
  171. 电话方面的相关业务
  172. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  173. */
  174. case GPRS_DATA_OPER:
  175. {
  176. Case6_GPRS_DATA_OPER();
  177. break;
  178. }
  179. default:
  180. break;
  181. }
  183. }
  184. /********************************************************
  185. * 函数名：Case1_GSM_PHONE
  186. 作用域：本地文件调用
  187. * 功能：Do_G20_Out模块中的一个case执行模块，主要是针对电话语音方面的处理，拨号，接听，挂机，DTMF，音量调节方面的处理。
  188. *
  189. 参数： 只有在满足能进入这个case的条件时候，才能进入执行这个模块，
  190. * 返回值：不同的情形是需要对不同的全局变量进行重新附值
  191. * 创建人：
  192. *
  193. * 修改历史：（每条详述）
  194. 补充说明： 手柄相关的AT指令存储在buffer1中的0x5D----0x7A区域。第一个字节0x5D存储0或者1，为0则表示
  195. 后面的数据已经处理，为1则表示后面的数据未处理。0x5E存储相关的AT指令的类型，如挂机，拨号等
  196. 后面如果还有数据（电话号码等）最后数据结束以0X00作为结束标志处理。
  198. 改为M22模块后，因为其特性，在这个CASE中需要增加一些处理：
  199. 1,如果有手柄或者监听对外拨号的信令，同时如果M22处于TCP在线且被挂起的状态，则需要先执行ATH指令，退出TCP
  200. 状态，然后才能进行拨号处理
  201. ********************************************************/
  202. void Case1_GSM_PHONE(void)
  203. {
  204. unsigned int i=0,j=0,k=0,n=0;
  205. unsigned char Phone_s=0;
  206. unsigned char Phone_e=0;
  207. OperateSPIEnd();
  208. //判断监听完后，是否需要恢复语音通道的处理
  209. if( ( (gGeneral_Flag&TCP_PHONE_F_1)==0)&&(gGeneral_Flag&MONITOR_RESUME_F_1) )
  210. {
  211. gTimer=0;
  212. while(gTimer<200){Check_GSM();}
  213. Send_COM0_String((unsigned char *)AT_AUGAIN,sizeof(AT_AUGAIN));
  214. Send_COM0_Byte('1');Send_COM0_Byte(',');
  215. Send_COM0_Byte('5');Send_COM0_Byte(0x0d);
  216. gInternal_Flag&=~M22_RETURN_OK_1;
  217. Wait_OK();
  218. if( (gInternal_Flag&M22_RETURN_OK_1)==0 );
  219. else
  220. {
  221. //2,固定调节SPEKER的接收增益
  222. gTimer=0;
  223. while(gTimer<200){Check_GSM();}
  224. Send_COM0_String((unsigned char *)AT_AUGAIN,sizeof(AT_AUGAIN));
  225. Send_COM0_Byte('2');Send_COM0_Byte(',');Send_COM0_Byte(Handle_VOL[TWO]);Send_COM0_Byte(0x0d);
  226. gInternal_Flag&=~M22_RETURN_OK_1;
  227. Wait_OK();
  228. if( (gInternal_Flag&M22_RETURN_OK_1)==0 );
  229. else
  230. {
  231. //3,调节AT$AUVOL的接收增益
  232. gTimer=0;
  233. while(gTimer<200){Check_GSM();}
  234. Send_COM0_String((unsigned char *)AT_AUVOL,sizeof(AT_AUVOL));
  235. Send_COM0_Byte('5');Send_COM0_Byte(0x0d);
  236. gInternal_Flag&=~M22_RETURN_OK_1;
  237. Wait_OK();
  238. if( (gInternal_Flag&M22_RETURN_OK_1)==0 );
  239. else
  240. {
  241. gGeneral_Flag&=~MONITOR_RESUME_F_1;
  242. P6OUT&=~SEL_MIC;
  243.       Send_COM3_Load(4,MAIN_HANG_UP,0);
  244.       gSys_Handle=MAIN_HANG_UP;
  245. }
  246. }
  247. }
  248. }
  249. OperateSPIEnd();
  251. //返回退出电话相关业务的CASE结构的满足条件:唯一正常的跳出此
  252. if( (SRAM_Read(PHONE_AT_2)!=VAILD_2)
  253.  &&( (gPhone_Status==ACTIVE_HANDLE)||(gPhone_Status==ACTIVE_MONITOR)||(gPhone_Status==READY) )   )
  254. {
  255. if( (gGeneral_Flag&RING_F_1)==0 )
  256. {
  257. gGSM_Oper_Type=GSM_OTHER;
  258. gGSM_OTHER_Step=0;gPhone_Step=0;
  259. gTimer_GSM_AT=0;
  260. Check_GSM();
  261. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  262. OperateSPIEnd();
  263. return;
  264. }
  265. }
  266. //如果buffer1中有相应的处理数据
  267. if( (gInternal_Flag&GSM_ONEAT_SUCCESS_1)==0 )
  268. {
  269. if( gTimer_GSM_AT>600)
  270. {
  271. gTimer_GSM_AT=0;
  272. SRAM_Init();
  273. j=SRAM_Read(PHONE_AT_2);
  274. if(j==VAILD_2)
  275. {
  276. i=SRAM_Read(PHONE_AT_2+1);
  277. if    (i==H_DIAL)     gPhone_Step=1; //手柄拨号
  278. else if(i==M_DIAL) gPhone_Step=5; //监听拨号
  279. else if(i==H_ANSWER) gPhone_Step=10; //手柄接听
  280. else if(i==H_DTMF) gPhone_Step=11; //手柄DTMF拨号
  281. else if(i==H_VOLADJ) gPhone_Step=12; //手柄调节音量
  282. else if(i==H_HUNGUP) gPhone_Step=13; //手柄挂机
  283. else
  284. {
  285. Check_GSM();
  286. SRAM_Init();
  287. SRAM_Write(PHONE_AT_2,NULL_2);
  288. SRAM_Write(PHONE_AT_2+1,0);
  289. }
  290. }
  291. }
  292. else if(gGeneral_Flag&RING_F_1)
  293. {
  294. //判断是否有来电显示
  295. //+CLIP: "13670155704",129,,,,0
  296. if( Check_GSM()!=0 )
  297. {
  298. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_CLIP,sizeof(String_CLIP))!=0)
  299. {
  300. gStatus1_Flag|=PHONE_ONLINE_F_1;
  301. j=SRAM_Read(PHONE_AT_2+0);
  302. i=SRAM_Read(PHONE_AT_2+1);
  303. if((i==H_HUNGUP)&&(j==VAILD_2));
  304. else
  305. {
  306. i=5;
  307. gPublic_Flag&=~ALLOW_PHONE_IN_F_1;
  308. while(1)
  309. {
  310. if(gGeneral_Buffer[i]=='"') break;
  311. i++;if(i>15) return;
  312. }
  313. i++;
  314. Phone_s=i; //第一个号码的位置序号
  315. SRAM_Init();
  316. SRAM_Write(SHANDLE_DATA_VAILD+0,VAILD_2);
  317. SRAM_Write(SHANDLE_DATA_VAILD+1,0x24);
  318. SRAM_Write(SHANDLE_DATA_VAILD+2,0x14);
  319. SRAM_Write(SHANDLE_DATA_VAILD+3,MAIN_PHONE_IN);
  320. j=i+16;
  321. k=0;
  322. while(1)
  323. {
  324. if(gGeneral_Buffer[i]!='"')
  325. {
  326. SRAM_Write(SHANDLE_DATA_VAILD+4+k,gGeneral_Buffer[i]);
  327. i++;k++;
  328. if(i>j)
  329. {
  330. n=0;
  331. break;
  332. }
  333. }
  334. else
  335. {
  336. n=k;
  337. break;
  338. }
  339. }
  340. Phone_e=i-1; //号码最后一个位的序号
  341. for(k=i;k<j;k++)
  342. {
  343. SRAM_Write(SHANDLE_DATA_VAILD+4+n+(k-i),0x20);
  344. }
  345. SRAM_Write(SHANDLE_DATA_VAILD+4+n+j-i,0x0d);
  346. gPhone_Status=INCOMING;
  347. //判断比较是否与Flash中存储的中心服务号码相同
  348. if(   ((gON_OFF_Temp0&PHONE_IN_ON)==0)
  349. &&((gCommon_Flag&CHECK_RINGPHONE_F_1)==0 ) )
  350. {
  351. for(i=0;i<Phone_e-Phone_s;i++)
  352. {
  353. gGeneral_Buffer[i]=gGeneral_Buffer[Phone_s+i];
  354. }
  355. i=1;
  356. i=Check_Allow_Phone(Phone_e-Phone_s);
  357. //与匹配的号码不一样
  358. if(i==1) gPublic_Flag&=~ALLOW_PHONE_IN_F_1;
  359. //与匹配的号码一样
  360. else gPublic_Flag|=ALLOW_PHONE_IN_F_1;
  361. gCommon_Flag|=CHECK_RINGPHONE_F_1;
  362. }
  363. }
  364. gPhone_Status=INCOMING;
  365. }
  366. }
  367. }
  368. }
  369. /********************************************************
  370. ********************************************************/
  371. //1，手柄拨号处理
  372. if(gPhone_Step==1)
  373. {
  374. gPhone_Step=4;gTimer_GSM_AT=0;
  375. }
  376. else if(gPhone_Step==4)
  377. {
  378. if( gTimer_GSM_AT>400 )
  379. {
  380. if(gPhone_Status==READY)
  381. {
  382. Send_COM0_String((unsigned char *)ATD,sizeof(ATD));
  383. //电话号码的长度
  384. k=SRAM_Read(PHONE_AT_2+2);
  385. for(j=0;j<k;j++)
  386. {
  387. Send_COM0_Byte(SRAM_Read(PHONE_AT_2+3+j));
  388. }
  389. OperateSPIEnd();
  390. Send_COM0_Byte(';');
  391. Send_COM0_Byte(0x0d);
  392. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  393. gPhone_Step=14;
  394. gTimer_GSM_AT=0;
  395. gGeneral_Flag|=DAILING_UP_F_1;
  396. gGeneral_Flag|=TCP_PHONE_F_1;
  397. gHangUp_Timer=0;
  398. gPhone_Status=DAILING;
  399. SRAM_Init();
  400. SRAM_Write(PHONE_AT_2+0,NULL_2);
  401. SRAM_Write(PHONE_AT_2+1,0);
  402. for(i=PHONE_AT_2+1;i<ECHO_SMS_2;i++)
  403. {
  404. SRAM_Write(i,0);
  405. }
  407. gStatus1_Flag|=PHONE_ONLINE_F_1;
  408. }
  409. else Case1_PHONE_Out();
  410. }
  411. else Check_GSM();
  412. }
  413. /********************************************************
  414. 2，监听拨号处理()如果属于是监听处理，则先处理将麦克的增益调节最大
  415. 将,然后将SPEAKER的接收增益调节为关闭状态，然后控制模拟开关的通道转换
  416. ********************************************************/
  417. else if(gPhone_Step==5)
  418. {
  419. if( gTimer_GSM_AT>400 )
  420. {
  421. if(gPhone_Status==READY)
  422. {
  423. gTimer=0;
  424. while(gTimer<200){Check_GSM();}
  425. Send_COM0_String((unsigned char *)AT_AUGAIN,sizeof(AT_AUGAIN));
  426. Send_COM0_Byte('1');Send_COM0_Byte(',');
  427. Send_COM0_Byte('9');Send_COM0_Byte(0x0d);
  428. gInternal_Flag&=~M22_RETURN_OK_1;
  429. Wait_OK();
  430. if( (gInternal_Flag&M22_RETURN_OK_1)==0 )
  431. {
  432. gPhone_Step=5;gTimer_GSM_AT=0;
  433. }
  434. else
  435. {
  436. //2,固定调节SPEKER的接收增益为1
  437. gTimer=0;
  438. while(gTimer<200){Check_GSM();}
  439. Send_COM0_String((unsigned char *)AT_AUGAIN,sizeof(AT_AUGAIN));
  440. Send_COM0_Byte('2');Send_COM0_Byte(',');Send_COM0_Byte('1');Send_COM0_Byte(0x0d);
  441. gInternal_Flag&=~M22_RETURN_OK_1;
  442. Wait_OK();
  443. if( (gInternal_Flag&M22_RETURN_OK_1)==0 )
  444. {
  445. gPhone_Step=5;gTimer_GSM_AT=0;
  446. }
  447. else
  448. {
  449. //3,固定调节AUVOL的接收增益为1
  450. gTimer=0;
  451. while(gTimer<200){Check_GSM();}
  452. Send_COM0_String((unsigned char *)AT_AUVOL,sizeof(AT_AUVOL));
  453. Send_COM0_Byte('0');Send_COM0_Byte(0x0d);
  454. gInternal_Flag&=~M22_RETURN_OK_1;
  455. Wait_OK();
  456. if( (gInternal_Flag&M22_RETURN_OK_1)==0 )
  457. {
  458. gPhone_Step=5;gTimer_GSM_AT=0;
  459. }
  460. else
  461. {
  462. gPhone_Step=9;gTimer_GSM_AT=0;
  463. }
  464. }
  465. }
  466. }
  467. else
  468. {
  469. Case1_PHONE_Out();
  470. }
  471. }
  472. else  Check_GSM();
  473. }
  474. else if(gPhone_Step==9)
  475. {
  476. if( gTimer_GSM_AT>400 )
  477. {
  478. if(gPhone_Status==READY)
  479. {
  480. Send_COM0_String((unsigned char *)ATD,sizeof(ATD));
  481. //电话号码的长度
  482. k=SRAM_Read(PHONE_AT_2+2);
  483. for(j=0;j<k;j++)
  484. {
  485. Send_COM0_Byte(SRAM_Read(PHONE_AT_2+3+j));
  486. }
  487. Send_COM0_Byte(';');
  488. Send_COM0_Byte(0x0d);
  489. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  490. gPhone_Step=14;
  491. gGeneral_Flag|=MONITOR_ON_F_1;
  492. gGeneral_Flag|=TCP_PHONE_F_1;
  493. gStatus1_Flag|=PHONE_ONLINE_F_1;
  494. gHangUp_Timer=0;
  495. gPhone_Status=DAILING;
  496. gTimer_GSM_AT=0;
  497. P6OUT|=SEL_MIC;
  498. }
  499. else
  500. {
  501. Case1_PHONE_Out();
  502. }
  503. }
  504. else Check_GSM();
  505. }
  506. /********************************************************
  507. 3，手柄接听处理
  508. ********************************************************/
  509. else if(gPhone_Step==10)
  510. {
  511. if( gTimer_GSM_AT>400  )
  512. {
  513. Send_COM0_String((unsigned char *)ATA,sizeof(ATA));
  514. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  515. gPhone_Step=15;
  516. gTimer_GSM_AT=0;
  517. OperateSPIEnd();
  518. }
  519. else Check_GSM();
  520. }
  521. /********************************************************
  522. 4，手柄DTMF处理
  523. ********************************************************/
  524. else if(gPhone_Step==11)
  525. {
  526. OperateSPIEnd();
  527. if( gTimer_GSM_AT>400  )
  528. {
  529. if(gPhone_Status==ACTIVE_HANDLE)
  530. {
  531. //检测DTMF中的数据
  532. #ifdef Debug_GSM_COM1
  533. Send_COM1_Byte('[');
  534. Send_COM1_Byte(ASCII(gDTMF_SAVE[0]/10));
  535. Send_COM1_Byte(ASCII(gDTMF_SAVE[0]%10));
  536. Send_COM1_Byte(']');
  537. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  538. #endif
  539. ////////////////////////////////////////////
  540. Send_COM0_String((unsigned char *)AT_VTS,sizeof(AT_VTS));
  541. //需要发送的音频数据
  542. k=SRAM_Read(PHONE_AT_2+3);
  543. //直接存储的是数字ASCII形式
  544. Send_COM0_Byte(k);
  545. Send_COM0_Byte(0x0d);
  546. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  547. gPhone_Step=15;
  548. gTimer_GSM_AT=0;
  549. OperateSPIEnd();
  550. }
  551. else Case1_PHONE_Out();
  552. }
  553. else Check_GSM();
  554. }
  555. /********************************************************
  556. 5，手柄音量调节处理
  557. ********************************************************/
  558. else if(gPhone_Step==12)
  559. {
  560. OperateSPIEnd();
  561. if( gTimer_GSM_AT>400  )
  562. {
  563. if( gM22_Status!=TCP_ONLINE_WORK )
  564. {
  565. Send_COM0_String((unsigned char *)AT_AUGAIN,sizeof(AT_AUGAIN));
  566. k=SRAM_Read(PHONE_AT_2+3);
  567. //直接存储的是数字ASCII形式
  568. if( (k<1)||(k>4) ) k=2;
  569. Send_COM0_Byte('2');Send_COM0_Byte(',');
  570. Send_COM0_Byte(Handle_VOL[k]);
  571. Send_COM0_Byte(0x0d);
  572. gVolume=k;
  573. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  574. gPhone_Step=15;
  575. gTimer_GSM_AT=0;
  576. OperateSPIEnd();
  577. }
  578. else Case1_PHONE_Out();
  579. }
  580. else Check_GSM();
  581. }
  582. /********************************************************
  583. 6，手柄挂机处理
  584. ********************************************************/
  585. else if(gPhone_Step==13)
  586. {
  587. if( gTimer_GSM_AT>400)
  588. {
  589. if( gPhone_Status==ACTIVE_MONITOR)
  590. {
  591. Case1_PHONE_Out();
  592. }
  593. else
  594. {
  595. Send_COM0_String((unsigned char *)ATH,sizeof(ATH));
  596. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  597. gPhone_Step=16;
  598. gTimer_GSM_AT=0;
  599. OperateSPIEnd();
  600. }
  601. }
  602. else Check_GSM();
  603. }
  604. /********************************************************
  605. 手柄拨号，监听拨号的返回状态处理
  606. ********************************************************/
  607. else if(gPhone_Step==14)
  608. {
  609. if( Check_GSM()!=0 )
  610. {
  611. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;gTimer_GSM_AT=0;
  612. //接通
  613. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_COLP,sizeof(String_COLP)))
  614. {
  615. if(gGeneral_Flag&DAILING_UP_F_1)
  616. {
  617. gGeneral_Flag&=~DAILING_UP_F_1;
  618. gPhone_Status=ACTIVE_HANDLE;
  619.     Send_COM3_Load(4,MAIN_TALKING,0);
  620.     gSys_Handle=MAIN_TALKING;
  621. //返回手柄一个接通命令
  622. }
  623. else if(gGeneral_Flag&MONITOR_ON_F_1)
  624. {
  625. gGeneral_Flag&=~MONITOR_ON_F_1;
  626. gPhone_Status=ACTIVE_MONITOR;
  627. }
  628. Case1_PHONE_Out();
  629. }
  630. //未接通，则自己主动挂断
  631. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_OK,sizeof(String_OK)))
  632. {
  634. if(gM22_Status==TCP_HANG_WORK) gGeneral_Flag|=TCP_STATUS_F_1;
  635. if(gGeneral_Flag&DAILING_UP_F_1)
  636. {
  637. gGeneral_Flag&=~DAILING_UP_F_1;
  638. gPhone_Status=READY;
  639. gGeneral_Flag&=~TCP_PHONE_F_1;
  640. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  641. }
  642. else if(gGeneral_Flag&MONITOR_ON_F_1)
  643. {
  644. gGeneral_Flag&=~MONITOR_ON_F_1;
  645. gPhone_Status=READY;
  646. P6OUT&=~SEL_MIC;
  647. }
  648. Case1_PHONE_Out();
  649. }
  650. //未接通，返回手柄挂机
  651. else if( Compare_String(gGeneral_Buffer,(unsigned char *)String_ER,sizeof(String_ER)) )
  652. {
  653. if(gM22_Status==TCP_HANG_WORK) gGeneral_Flag|=TCP_STATUS_F_1;
  654. if(gGeneral_Flag&DAILING_UP_F_1)
  655. {
  656. gGeneral_Flag&=~DAILING_UP_F_1;
  657. gPhone_Status=READY;
  658. gGeneral_Flag&=~TCP_PHONE_F_1;
  659. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  660.     Send_COM3_Load(4,MAIN_HANG_UP,0);
  661.     gSys_Handle=MAIN_HANG_UP;
  662. //返回手柄挂机命令
  663. }
  664. else if(gGeneral_Flag&MONITOR_ON_F_1)
  665. {
  666. gGeneral_Flag&=~MONITOR_ON_F_1;
  667. gPhone_Status=READY;
  668. gGeneral_Flag&=~TCP_PHONE_F_1;
  669. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  670. P6OUT&=~SEL_MIC;
  671. }
  672. Case1_PHONE_Out();
  673. }
  674. //未接通，对方主动挂机，返回手柄挂机
  675. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_BUSY,sizeof(String_BUSY)))
  676. {
  677. if(gM22_Status==TCP_HANG_WORK) gGeneral_Flag|=TCP_STATUS_F_1;
  678. if(gGeneral_Flag&DAILING_UP_F_1)
  679. {
  680. gGeneral_Flag&=~DAILING_UP_F_1;
  681. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  682. gPhone_Status=READY;
  683. gGeneral_Flag&=~TCP_PHONE_F_1;
  684.     Send_COM3_Load(4,MAIN_HANG_UP,0);
  685.     gSys_Handle=MAIN_HANG_UP;
  686. //返回主动挂机命令
  687. }
  688. else if(gGeneral_Flag&MONITOR_ON_F_1)
  689. {
  690. gGeneral_Flag&=~MONITOR_ON_F_1;
  691. gPhone_Status=READY;
  692. gGeneral_Flag&=~TCP_PHONE_F_1;
  693. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  694. P6OUT&=~SEL_MIC;
  695. }
  696. Case1_PHONE_Out();
  697. }
  698. //未接通，对方无应答
  699. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_NOANSWER,sizeof(String_NOANSWER)))
  700. {
  701. if(gM22_Status==TCP_HANG_WORK) gGeneral_Flag|=TCP_STATUS_F_1;
  702. if(gGeneral_Flag&DAILING_UP_F_1)
  703. {
  704. gGeneral_Flag&=~DAILING_UP_F_1;
  705. gPhone_Status=READY;
  706. gGeneral_Flag&=~TCP_PHONE_F_1;
  707. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  708.     Send_COM3_Load(4,MAIN_HANG_UP,0);
  709.     gSys_Handle=MAIN_HANG_UP;
  710. //返回手柄挂机命令
  711. }
  712. else if(gGeneral_Flag&MONITOR_ON_F_1)
  713. {
  714. gGeneral_Flag&=~MONITOR_ON_F_1;
  715. gPhone_Status=READY;
  716. gGeneral_Flag&=~TCP_PHONE_F_1;
  717. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  718. P6OUT&=~SEL_MIC;
  719. }
  720. Case1_PHONE_Out();
  721. }
  722. //未接通，对方占线
  723. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_NOCARRIER,sizeof(String_NOCARRIER)) )
  724. {
  725. if(gM22_Status==TCP_HANG_WORK) gGeneral_Flag|=TCP_STATUS_F_1;
  726. if(gGeneral_Flag&DAILING_UP_F_1)
  727. {
  728. gGeneral_Flag&=~DAILING_UP_F_1;
  729. gPhone_Status=READY;
  730. gGeneral_Flag&=~TCP_PHONE_F_1;
  731. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  732.     Send_COM3_Load(4,MAIN_BUSY,0);
  733. //返回手柄挂机命令
  734. }
  735. else if(gGeneral_Flag&MONITOR_ON_F_1)
  736. {
  737. gGeneral_Flag&=~MONITOR_ON_F_1;
  738. gPhone_Status=READY;
  739. gGeneral_Flag&=~TCP_PHONE_F_1;
  740. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  741. P6OUT&=~SEL_MIC;
  742. }
  743. Case1_PHONE_Out();
  744. }
  745. }
  746. else
  747. {
  748. if(gGeneral_Flag&DAILING_UP_F_1)
  749. {
  750. //手柄未接通主动挂机命令的操作
  751. SRAM_Init();
  752. i=SRAM_Read(PHONE_AT_2+1);
  753. if( i==H_HUNGUP )
  754. {
  755. Send_COM0_String((unsigned char *)ATH,sizeof(ATH));
  756. gGeneral_Flag&=~MONITOR_ON_F_1;
  757. gPhone_Status=READY;
  758. gGeneral_Flag&=~TCP_PHONE_F_1;
  759. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  760. }
  761. }
  762. if(gTimer_GSM_AT>65000)
  763. {
  764. gGeneral_Flag&=~MONITOR_ON_F_1;
  765. gPhone_Status=READY;
  766. gGeneral_Flag&=~TCP_PHONE_F_1;
  767. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  768. Case1_PHONE_Out();
  769. SRAM_Init();
  770. SRAM_Write(PHONE_AT_2+0,VAILD_2);
  771. SRAM_Write(PHONE_AT_2+1,H_HUNGUP);
  772. SRAM_Write(PHONE_AT_2+2,0);
  773. }
  774. }
  775. }
  776. /********************************************************
  777. 手柄接听，DTMF拨号，音量调节的返回状态处理
  778. ********************************************************/
  779. else if(gPhone_Step==15)
  780. {
  781. if( Check_GSM()!=0 )
  782. {
  783. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_OK,sizeof(String_OK)))
  784. {
  785. if(gPhone_Status==INCOMING)
  786. {
  787. gPhone_Status=ACTIVE_HANDLE;
  788. gGeneral_Flag&=~RING_F_1;
  789. gPhone_Step=0;
  790.     Send_COM3_Load(4,MAIN_TALKING,0);
  791.     gSys_Handle=MAIN_TALKING;
  792. Case1_PHONE_Out();
  793. }
  794. else
  795. {
  796. Case1_PHONE_Out();
  797. }
  798. }
  799. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_ER,sizeof(String_ER)))
  800. {
  801. Case1_PHONE_Out();
  802. }
  803. }
  804. else
  805. {
  806. if(gTimer_GSM_AT>10000) Case1_PHONE_Out();
  807. }
  808. }
  809. /********************************************************
  810. 手柄挂机的返回状态处理
  811. ********************************************************/
  812. else if(gPhone_Step==16)
  813. {
  814. if( Check_GSM()!=0 )
  815. {
  816. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_OK,sizeof(String_OK)))
  817. {
  818. gGeneral_Flag&=~DAILING_UP_F_1;
  819. gGeneral_Flag&=~MONITOR_ON_F_1;
  820. gPhone_Status=READY;
  821. gGeneral_Flag&=~TCP_PHONE_F_1;
  822. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  823. gGeneral_Flag&=~RING_F_1;
  824. if(gM22_Status==TCP_HANG_WORK) gGeneral_Flag|=TCP_STATUS_F_1;
  825. Case1_PHONE_Out();
  826. }
  827. }
  828. else
  829. {
  830. if(gTimer_GSM_AT>6000) Case_OverTime_Return();
  831. }
  832. }
  833. OperateSPIEnd();
  834. }
  835. /********************************************************
  836. * 函数名：Case1_PHONE_Out
  837. 作用域：本地文件调用
  838. * 功能： 将CASE1中处理的出口,但这这个出口在下一个程序循环中，仍然会进入这个CASE中
  840. * 参数：
  841. * 返回值：
  842. * 创建人：
  843. *
  844. * 修改历史：（每条详述）
  845. ********************************************************/
  846. void Case1_PHONE_Out(void)
  847. {
  848. unsigned int i=0;
  849. gPhone_Step=0;
  850. gTimer_GSM_AT=0;
  851. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  852. SRAM_Init();
  853. SRAM_Write(PHONE_AT_2+0,NULL_2);
  854. for(i=PHONE_AT_2+1;i<ECHO_SMS_2;i++)
  855. {
  856. SRAM_Write(i,0);
  857. }
  858. }
  860. /********************************************************
  861. * 函数名：Case2_GSM_OTHER
  862. 作用域：本地文件调用
  863. * 功能： 主要是处理有电话方面的时候CLCC查询，没电话的时候CSQ的查询,还有如果收到参数设置的话，则
  864. 在需要进行短消息中心号码的设置，GPRS的IP改变，端口改变后的GPRS的重新登陆设置等
  865. * 参数：
  866. * 返回值：
  867. * 创建人：
  868. *
  869. * 修改历史：（每条详述）
  870. 补充说明：因为在这个case中有需要对短消息中心号码的设置，根据通过SMS接收到新的参数设置，需要将
  871. 短消息中心号码存储先存储在buffer1的0x4B----0x5C区域。第一个字节开始就存储短消息中心
  872. 号码的第一个字节，以0x00作为结束符号。在这个case中需要将存储在buffer1中的短消息中心
  873. 号码通过AT+CSCA指令进行SIM设置。
  874. ********************************************************/
  875. void Case2_GSM_OTHER(void)
  876. {
  877. unsigned int i=0,j=0,k=0;
  878. static unsigned char CSQ_Single_Error=0;
  880. if(gGSM_OTHER_Step==0) {gGSM_OTHER_Step=1;gTimer_GSM_AT=0;Check_GSM();}
  882. /********************************************************
  883. 1,gGSM_OTHER_Step=1的时候，判断是否在这个case中进行处理
  884. A：如果无电话方面的业务，满足一定时间间隔查询信号，则进行AT+CSQ的指令操作
  885. B：判断是否有需要进行短消息中心号码的设置，如果判断有gInternal_Flag&SET_CSCA_F_1置位，则进行
  886. AT+CSCA的指令操作
  887. C：如果满足需要恢复语音方面的设置(监听后的的模块语音方面的参数设置)
  888. ********************************************************/
  889. else if(gGSM_OTHER_Step==1)
  890. {
  891. if(  (gTimer_CSQ>5)
  892.   &&((gPhone_Status==ACTIVE_HANDLE)||(gPhone_Status==ACTIVE_MONITOR)) )
  893. {
  894. if( gTimer_GSM_AT>200 )
  895. {
  896. Send_COM0_String((unsigned char *)AT_CLCC,sizeof(AT_CLCC));
  897. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  898. gTimer_GSM_AT=0;
  899. gTimer_CSQ=0;
  900. gGSM_OTHER_Step=5;
  901. }
  902. else Check_GSM();
  903. }
  904. /********************************************************
  905. A,1,无电话业务，2，处于GSM工作方式下。3。GSM信号查询时间到
  906. ********************************************************/
  907.     else if((gPhone_Status==READY)&&(gM22_Status==GSM_WORK)&&(gTimer_CSQ>GSM_CHECKCSQ_TIME) )
  908. {
  909. if( gTimer_GSM_AT>200 )
  910. {
  911. Send_COM0_String((unsigned char *)AT_CSQ,sizeof(AT_CSQ));
  912. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  913. gTimer_GSM_AT=0;
  914. gTimer_CSQ=0;
  915. gGSM_OTHER_Step=2;
  916. }
  917. else Check_GSM();
  918. }
  919. /********************************************************
  920. B,1，无电话业务，2，处于TCP挂起的工作方式下。4，GSM信号查询时间到
  921. ********************************************************/
  922. else if((gPhone_Status==READY)&&(gM22_Status==TCP_HANG_WORK)&&(gTimer_CSQ>TCP_CHECKCSQ_TIME))
  923. {
  924. if( gTimer_GSM_AT>200 )
  925. {
  926. Send_COM0_String((unsigned char *)AT_CSQ,sizeof(AT_CSQ));
  927. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  928. gTimer_GSM_AT=0;
  929. gTimer_CSQ=0;
  930. gGSM_OTHER_Step=2;
  931. }
  932. else Check_GSM();
  933. }
  934. else Case2_OTHER_Out();
  935. }
  936. /********************************************************
  937. AB-1：查询信号的模块返回
  938. ********************************************************/
  939. else if(gGSM_OTHER_Step==2)
  940. {
  941. if(Check_GSM()!=0)
  942. {
  943. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  944. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_CSQ,sizeof(String_CSQ)))
  945. {
  946. if(gGeneral_Buffer[9]==',')
  947. {
  948. gSignal=(gGeneral_Buffer[7]-0x30)*10+(gGeneral_Buffer[8]-0x30);
  949. }
  950. else if(gGeneral_Buffer[7]==',')
  951. {
  952. gSignal=gGeneral_Buffer[6]-0x30;
  953. }
  954. else if(gGeneral_Buffer[8]==',')
  955. {
  956. gSignal=(gGeneral_Buffer[6]-0x30)*10+(gGeneral_Buffer[7]-0x30);
  957. }
  958. if(gSignal>31)
  959. {
  960. gSignal=0;
  961. CSQ_Single_Error++;
  962. if(CSQ_Single_Error>20)
  963. {
  964. CSQ_Single_Error=0;
  965. gGeneral_Flag|=OFF_M22_F_1;
  966. gOFF_Power_S=1;
  967. gPhone_Status=READY;
  968. gM22_ReturnER_SIM_Count=0;
  969. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  970. return;
  971. }
  972. }
  973. else
  974. {
  975. CSQ_Single_Error=0;
  976. }
  977. gGSM_OTHER_Step=3;
  978. gTimer_GSM_AT=0;
  979. gTimer_CSQ=0;
  980. }
  981. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_ER,sizeof(String_ER)))
  982. {
  983. gGSM_OTHER_Step=3;
  984. gTimer_GSM_AT=0;
  985. gTimer_CSQ=0;
  986. }
  987. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_OK,sizeof(String_OK)))
  988. {
  989. gGSM_OTHER_Step=3;
  990. gTimer_GSM_AT=0;
  991. gTimer_CSQ=0;
  992. }
  993. }
  994. else
  995. {
  996. if(gTimer_GSM_AT>10000)
  997. {
  998. Case_OverTime_Return();
  999. }
  1000. }
  1001. }
  1002. //查询SIM卡的状态是否正常
  1003. else if(gGSM_OTHER_Step==3)
  1004. {
  1005. if(gTimer_GSM_AT>200)
  1006. {
  1007. Send_COM0_String((unsigned char *)AT_CSCA_C,sizeof(AT_CSCA_C));
  1008. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  1009. gTimer_GSM_AT=0;
  1010. gGSM_OTHER_Step=4;
  1011. }
  1012. else Check_GSM();
  1013. }
  1014. else if(gGSM_OTHER_Step==4)
  1015. {
  1016. if(Check_GSM()!=0)
  1017. {
  1018. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;gTimer_GSM_AT=0;gTimer_CSQ=0;
  1019.     if(Compare_String(gGeneral_Buffer,(unsigned char *)String_CSCA,sizeof(String_CSCA))!=0)
  1020.     {
  1022.      if(  ((gInternal_Flag&CENTER_NUM_VAILD_F_1)==0)
  1023. &&(gInternal_Flag&SET_CSCA_F_1) )
  1024.      {
  1025.      if(gGeneral_Buffer[7]=='"')
  1026.      {
  1027.      i=8;
  1028. while(1)
  1029. {
  1030. if(gGeneral_Buffer[i]=='"') break;
  1031. i++;if(i>8+18) {gReset_M22_On_Setp=1;return;} //非法长度，则退出
  1032. }
  1033. if(i>8+1)
  1034. {
  1035. Load_SMS_CenterNum(i);
  1036. Send_COM1_String( (unsigned char *)CENTER_RELOAD,sizeof(CENTER_RELOAD) );
  1037. gInternal_Flag|=CENTER_NUM_VAILD_F_1;
  1038. gInternal_Flag&=~SET_CSCA_F_1;
  1039. }
  1040. else
  1041. {
  1042. gInternal_Flag&=~CENTER_NUM_VAILD_F_1;
  1043. gInternal_Flag|=SET_CSCA_F_1;
  1044. }
  1045. }
  1046.      }
  1047.      //表示已经找到SIM卡的网络
  1048.      gM22_ReturnER_SIM_Count=0;
  1049. if(gM22_Status==TCP_HANG_WORK)
  1050. {
  1051. //进入TCP的在线状态
  1052. gGSM_OTHER_Step=0;
  1053. gGSM_Oper_Type=LAND_TCP_OPER;
  1054. gLand_GPRS_Step=0;
  1055. gGeneral_Flag|=TCP_STATUS_F_1;
  1056. }
  1057. else
  1058. {
  1059. Case2_OTHER_Out();
  1060. }
  1061. SRAM_Init();
  1062. SRAM_Write(SHANDLE_DATA_VAILD+0,VAILD_2);
  1063. SRAM_Write(SHANDLE_DATA_VAILD+1,0x24);
  1064. SRAM_Write(SHANDLE_DATA_VAILD+2,0x06);
  1065. SRAM_Write(SHANDLE_DATA_VAILD+3,MAIN_SEND_STATUS);
  1066. SRAM_Write(SHANDLE_DATA_VAILD+4,gStatus1_Flag);
  1067. SRAM_Write(SHANDLE_DATA_VAILD+5,gStatus2_Flag);
  1068. SRAM_Write(SHANDLE_DATA_VAILD+6,0x0d);
  1069. }
  1070. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_ER,sizeof(String_ER))!=0)
  1071. {
  1072. //表示还没有找到SIM卡的网络
  1073.      gM22_ReturnER_SIM_Count++;
  1074.      if(gM22_ReturnER_SIM_Count>20)
  1075.      {
  1076. gGeneral_Flag|=OFF_M22_F_1;
  1077. gOFF_Power_S=1;
  1078. gPhone_Status=READY;
  1079. gM22_ReturnER_SIM_Count=0;
  1080. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  1081. return;
  1082.      }
  1083.      else
  1084.      {
  1085. if(gM22_Status==TCP_HANG_WORK)
  1086. {
  1087. //进入TCP的在线状态
  1088. gGSM_OTHER_Step=0;
  1089. gGSM_Oper_Type=LAND_TCP_OPER;
  1090. gLand_GPRS_Step=0;
  1091. gGeneral_Flag|=TCP_STATUS_F_1;
  1092. }
  1093. else
  1094. {
  1095. Case2_OTHER_Out();
  1096. }
  1097. gTimer_CSQ=0;
  1098.      }
  1099. }
  1100. }
  1101. else
  1102. {
  1103. if(gTimer_GSM_AT>10000)
  1104. {
  1105. Case_OverTime_Return();
  1106. }
  1107. }
  1108. }
  1109. /********************************************************
  1110. CLCC查询返回
  1111. ********************************************************/
  1112. else if(gGSM_OTHER_Step==5)
  1113. {
  1114. if(Check_GSM()!=0)
  1115. {
  1116. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;gTimer_GSM_AT=0;gTimer_CSQ=0;
  1117.     if(Compare_String(gGeneral_Buffer,(unsigned char *)String_CLCC,sizeof(String_CLCC))!=0)
  1118.     {
  1119.      Case2_OTHER_Out();
  1120.     }
  1121. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_OK,sizeof(String_OK)))
  1122. {
  1123. SRAM_Init();
  1124. SRAM_Write(PHONE_AT_2+0,VAILD_2);
  1125. SRAM_Write(PHONE_AT_2+1,H_HUNGUP);
  1126. SRAM_Write(PHONE_AT_2+2,0);
  1127. Send_COM3_Load(4,MAIN_HANG_UP,0);
  1128. gSys_Handle=MAIN_HANG_UP;
  1129. Case2_OTHER_Out();
  1130. }
  1131.     else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_ER,sizeof(String_ER))!=0)
  1132.     {
  1133.      Case2_OTHER_Out();
  1134.     }
  1135. }
  1136. else
  1137. {
  1138. if(gTimer_GSM_AT>10000)
  1139. {
  1140. Case2_OTHER_Out();
  1141. }
  1142. }
  1143. }
  1144. }
  1145. /********************************************************
  1146. * 函数名：Case2_OTHER_Out
  1147. 作用域：本地文件调用
  1148. * 功能： 将CASE2中处理的出口
  1149. * 参数：
  1150. * 返回值：
  1151. * 创建人：
  1152. *
  1153. * 修改历史：（每条详述）
  1154. ********************************************************/
  1155. void Case2_OTHER_Out(void)
  1156. {
  1157. gGSM_Oper_Type=GSM_SMS_IN;
  1158. gGSM_OTHER_Step=0;gPhone_Step=0;
  1159. gTimer_GSM_AT=0;
  1160. Check_GSM();
  1161. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  1162. OperateSPIEnd();
  1163. }
  1164. /********************************************************
  1165. * 函数名：Case3_GSM_SMS_IN
  1166. 作用域：本地文件调用
  1167. * 功能：
  1168. * 参数：
  1169. * 返回值：
  1170. * 创建人：
  1171. *
  1172. * 修改历史：（每条详述）
  1173. 补充说明：
  1175. ********************************************************/
  1176. void Case3_GSM_SMS_IN(void)
  1177. {
  1178. Check_GSM();
  1179. Case3_SMSIN_Out();
  1180. }
  1181. /********************************************************
  1182. * 函数名：Case3_SMSIN_Out
  1183. 作用域：本地文件调用
  1184. * 功能： 将CASE3中处理的出口
  1185. * 参数：
  1186. * 返回值：
  1187. * 创建人：
  1188. *
  1189. * 修改历史：（每条详述）
  1190. ********************************************************/
  1191. void Case3_SMSIN_Out(void)
  1192. {
  1193. gGSM_Oper_Type=GSM_SMS_OUT;
  1194. gSMS_OUT_Step=0;
  1195. gTimer_GSM_AT=0;
  1196. Check_GSM();
  1197. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  1198. OperateSPIEnd();
  1199. }
  1200. /********************************************************
  1201. * 函数名：Case4_GSM_SMS_OUT
  1202. 作用域：本地文件调用
  1203. * 功能：
  1204. * 参数：
  1205. * 返回值：
  1206. * 创建人：
  1207. *
  1208. * 修改历史：（每条详述）
  1209. 2004年12月15日
  1210. 补充说明：
  1211. ********************************************************/
  1212. void Case4_GSM_SMS_OUT(void)
  1213. {
  1214. unsigned int i=0,j=0,k=0,x=0,y=0;
  1215. unsigned char nTemp_Length=0;
  1216. unsigned int  iLength=0;
  1217. //1，手柄正在拨号，2，监听正在拨号，3有电话打入
  1218. if( (gGeneral_Flag&RING_F_1)||(gGeneral_Flag&DAILING_UP_F_1)||(gGeneral_Flag&MONITOR_ON_F_1) )
  1219. {
  1220. Case4_SMSOUT_Out();
  1221. return;
  1222. }
  1223. //2,如果目标号码无效，则不能进行SMS的发送操作
  1224. if( (gGeneral_Flag&NUM1_VAILD_F_1)==0 )
  1225. {
  1226. Case4_SMSOUT_Out();
  1227. return;
  1228. }
  1229. //3,如果短消息中心号码无效，则不能 SMS的发送操作
  1230. if( (gInternal_Flag&CENTER_NUM_VAILD_F_1)==0)
  1231. {
  1232. Case4_SMSOUT_Out();
  1233. return;
  1234. }
  1235. //4,否则的可以进行下面的操作
  1236. if(gSMS_OUT_Step==0)  gSMS_OUT_Step=1;
  1238. else if(gSMS_OUT_Step==1)
  1239. {
  1240. gSend_Type1=0;
  1241. SRAM_Init();
  1242. i=SRAM_Read(ECHO_SMS_2);
  1243. j=SRAM_Read(OTHER_SMS_2);
  1244. //第一类的数据发送
  1245. if( (i!=NULL_2)&&(gInternal_Flag&ALLOW_DATA_F_1) )
  1246. {
  1247. gSMS_OUT_Step=7;gTimer_GSM_AT=0;
  1248. #ifdef Debug_GSM_COM1
  1249.            Send_COM1_Byte('2');
  1250. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  1251. #endif
  1252. gSend_Type1=1;
  1253. }
  1254. else if( (j!=NULL_2)&&(gInternal_Flag&ALLOW_DATA_F_1) )
  1255. {
  1256. gSMS_OUT_Step=7;gTimer_GSM_AT=0;
  1257. #ifdef Debug_GSM_COM1
  1258.            Send_COM1_Byte('3');
  1259. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  1260. #endif
  1261. gSend_Type1=2;
  1262. }
  1263. //第二类数据的发送
  1264. else if( (gInternal_Flag&SEND_CIRCLE_F_1)&&(gInternal_Flag&ALLOW_DATA_F_1) )
  1265. {
  1266. gInternal_Flag&=~SEND_CIRCLE_F_1;
  1267. gInternal_Flag&=~ALLOW_DATA_F_1;
  1268. gGSM_Work_Count=0;gCheck_Data=0;
  1269. gSMS_OUT_Step=17;
  1270. gTimer_GSM_AT=0;
  1271. #ifdef Debug_GSM_COM1
  1272.            Send_COM1_Byte('4');
  1273. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  1274. #endif
  1275. if(gCycle_Send_Status==WATCH_DATA)
  1276. {
  1277. if(gWatch_Count>0) gWatch_Count--;
  1278. }
  1280. }
  1281. /**************************************************************************************
  1282. 第三类数据的TCP发送（外接部件的大量数据-存储在外部SRAM中）
  1283. **************************************************************************************/
  1284. else if( (gOther_Flag&ALLOW_SEND_RECORD_F_1)&&(gInternal_Flag&ALLOW_DATA_F_1) )
  1285. {
  1286. SRAM_Init();
  1287. if( SRAM_Read(SRAM_SEND_VAILD)==VAILD_2 )
  1288. {
  1289. //判断长度
  1290. j = SRAM_Read(SRAM_SEND_LENGTH_H);
  1291. j <<= 8;
  1292. j += SRAM_Read(SRAM_SEND_LENGTH_L);
  1293. if(j>120)
  1294. {
  1295. gOther_Flag&=~RECORD_DATA_F_1;
  1296. gOther_Flag&=~ALLOW_SEND_RECORD_F_1;
  1297. SRAM_Init();
  1298. SRAM_Write(SRAM_SEND_VAILD,NULL_2);
  1299. SRAM_Write(SRAM_SEND_LENGTH_H,0);
  1300. SRAM_Write(SRAM_SEND_LENGTH_L,0);
  1301. }
  1302. else
  1303. {
  1304. gSMS_OUT_Step=22;
  1305. gTimer_GSM_AT=0;
  1306. #ifdef Debug_GSM_COM1
  1307. Send_COM1_Byte('F');Send_COM1_String((unsigned char *)TYPE,sizeof(TYPE));
  1308. #endif
  1309. }
  1310. }
  1311. else
  1312. {
  1313. gOther_Flag&=~RECORD_DATA_F_1;
  1314. gOther_Flag&=~ALLOW_SEND_RECORD_F_1;
  1315. SRAM_Init();
  1316. SRAM_Write(SRAM_SEND_VAILD,NULL_2);
  1317. SRAM_Write(SRAM_SEND_LENGTH_H,0);
  1318. SRAM_Write(SRAM_SEND_LENGTH_L,0);
  1319. Case4_SMSOUT_Out();
  1320. }
  1321. }
  1322. else
  1323. {
  1324. Case4_SMSOUT_Out();
  1325. }
  1326. }
  1327. /********************************************************
  1328. 第一类GSM数据的发送：
  1329. 1-1:
  1330. 0x7B 存储表示这个区域的SMS是否处理，为1则表示后面还有未处理的SMS，为0则表示已经处理完了SMS
  1331. 0x7C 存储数据包的命令字在这里则为nCommand
  1332. 0x7D 存储数据包的ACK的值ACK
  1333. 0x7E 存储后面数据包的长度（但注意没有存储CHK(MSB),CHK(LSB),EOT,这三个字节）
  1334. 0x7F   从这开始存储数据包
  1336. 1-2:
  1337. 0xB1 存储表示这个区域的SMS是否处理，为1则表示后面还有未处理的SMS，为0则表示已经处理完了SMS
  1338. 0xB2 存储数据包的命令字在这里则为nCommand
  1339. 0xB3 存储数据包的ACK的值ACK
  1340. 0xB4 存储后面数据包的长度（但注意没有存储CHK(MSB),CHK(LSB),EOT,这三个字节）
  1341. 0xB5   从这开始存储数据包
  1342. ********************************************************/
  1343. else if(gSMS_OUT_Step==7)
  1344. {
  1345. if(gTimer_GSM_AT>300)
  1346. {
  1347. if(gSend_Type1==1) Send_Type1_GSM_Data_One(ECHO_SMS_2);
  1348. else if(gSend_Type1==2) Send_Type1_GSM_Data_One(OTHER_SMS_2);
  1349. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  1350. gSMS_OUT_Step=8;
  1351. gTimer_GSM_AT=0;
  1352. }
  1353. else Check_GSM();
  1354. }
  1355. else if(gSMS_OUT_Step==8)
  1356. {
  1357. if(Check_GSM()!=0)
  1358. {
  1359. gTimer_GSM_AT=0;
  1360. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_Input_Label,sizeof(String_Input_Label)))
  1361. {
  1362. gSMS_OUT_Step=9;
  1363. }
  1364.     else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_ER,sizeof(String_ER))!=0)
  1365.     {
  1366.      Case4_OverTime_Out(gSend_Type1);
  1367. Case4_SMSOUT_Out();
  1368.     }
  1369. }
  1370. else
  1371. {
  1372. if(gTimer_GSM_AT>10000) Case_OverTime_Return();
  1373. }
  1374. }
  1375. else if(gSMS_OUT_Step==9)
  1376. {
  1377. if(gTimer_GSM_AT>200)
  1378. {
  1379. if(gSend_Type1==1) Send_Type1_GSM_Data_Two(ECHO_SMS_2);
  1380. else if(gSend_Type1==2) Send_Type1_GSM_Data_Two(OTHER_SMS_2);
  1381. gSMS_OUT_Step=10;
  1382. gTimer_GSM_AT=0;
  1383. }
  1384. else Check_GSM();
  1385. }
  1386. else if(gSMS_OUT_Step==10)
  1387. {
  1388. if(Check_GSM()!=0)
  1389. {
  1390. gTimer_GSM_AT=0;
  1391.      Case4_OverTime_Out(gSend_Type1);
  1392. Case4_SMSOUT_Out();
  1393. }
  1394. else
  1395. {
  1396. if(gTimer_GSM_AT>60000)
  1397. {
  1398. Case4_OverTime_Out(gSend_Type1);
  1399. Case4_SMSOUT_Out();
  1400. }
  1401. }
  1402. }
  1403.   /********************************************************
  1404. 二，第二类GSM数据的发送
  1405. 存储在区域的数据Circle_Buffer[]
  1406. 1，行车轨迹数据 ；3，报警数据；4，监控数据，5，历史轨迹数据
  1407. 这类周期发送的数据因为不能同时存在发送的情形，则可以均用Circle_Buffer[]作为
  1408. 存储周期数据发送。
  1409. gCycle_Send_Status=0 表示无任何周期性的数据发送
  1410. gCycle_Send_Status=1 表示属于行车轨迹的周期数据正在发送
  1411. gCycle_Send_Status=2 表示报警的周期数据正在发送
  1412. gCycle_Send_Status=3 表示监控数据正在发送（另外还有标志位表示属于那一类型的监控数据）
  1413. gCycle_Send_Status=4 表示历史轨迹数据正在发送（另外还有标志位表示属于那一类型的历史轨迹数据）
  1414. gCycle_Send_Status=5 表示是盲区点补偿发送的数据
  1416. AT+CMGS=27
  1417. >
  1418. 0891683108705505F011000D91683167108230F70004000CFF4FB008000101000102090D
  1419. 27的长度为11000D91683167108230F70004000CFF4FB008000101000102090D
  1421. ********************************************************/
  1422. else if(gSMS_OUT_Step==17)
  1423. {
  1424. if( gTimer_GSM_AT>200)
  1425. {
  1426. nTemp_Length=SRAM_Read(TARGET_NUMBER1_2); //目标电话号码的长度
  1427. nTemp_Length=(nTemp_Length+1)/2+7+1+gCircle_Buffer_Point; //要发送的数据长度
  1428. Ask_SMS_Send(nTemp_Length); //发送AT指令AT+CMGS=(SMS长度)
  1429. gInternal_Flag|=GSM_ONEAT_SUCCESS_1; //发送AT指令的标志置1
  1430. gSMS_OUT_Step=18;
  1431. gTimer_GSM_AT=0;
  1432. }
  1433. else Check_GSM();
  1434. }
  1435. else if(gSMS_OUT_Step==18)
  1436. {
  1437. if(Check_GSM()!=0)
  1438. {
  1439. gTimer_GSM_AT=0;
  1440. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_Input_Label,sizeof(String_Input_Label)))
  1441. {
  1442. gSMS_OUT_Step=19;
  1443. }
  1444.     else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_ER,sizeof(String_ER))!=0)
  1445.     {
  1446. OperateSPIEnd();
  1447. for(i=0;i<sizeof(gCircle_Buffer);i++) gCircle_Buffer[i]=0;
  1448. gCircle_Buffer_Point=0;
  1449. Case4_SMSOUT_Out();
  1450.     }
  1451. }
  1452. else
  1453. {
  1454. if(gTimer_GSM_AT>10000) Case_OverTime_Return();
  1455. }
  1456. }
  1457. else if(gSMS_OUT_Step==19)
  1458. {
  1459. if(gTimer_GSM_AT>200)
  1460. {
  1461. //这个操作发送完000400
  1462. Send_SMS_Head();
  1463. OperateSPIEnd();
  1464. //发送gCircle_Buffer[]周期数据中的数据
  1465. Send_Circle_GSM_TypeD();
  1466. Send_COM0_Byte(0x1A);
  1467. gSMS_OUT_Step=20;
  1468. gTimer_GSM_AT=0;
  1469. }
  1470. }
  1471. else if(gSMS_OUT_Step==20)
  1472. {
  1473. if(Check_GSM()!=0)
  1474. {
  1475. gTimer_GSM_AT=0;
  1476. OperateSPIEnd();
  1477. for(i=0;i<sizeof(gCircle_Buffer);i++) gCircle_Buffer[i]=0;
  1478. gCircle_Buffer_Point=0;
  1479. Case4_SMSOUT_Out();
  1480. }
  1481. else
  1482. {
  1483. if(gTimer_GSM_AT>60000)
  1484. {
  1485. gTimer_GSM_AT=0;
  1486. for(i=0;i<sizeof(gCircle_Buffer);i++) gCircle_Buffer[i]=0;
  1487. gCircle_Buffer_Point=0;
  1488. Case4_SMSOUT_Out();
  1489. }
  1490. }
  1491. }
  1492. /********************************************************
  1493. 四，第四类GSM数据的发送，外部记录仪的数据发送。注意只能发送
  1494. 外部数据的长度有限制
  1495. ********************************************************/
  1496. else if( gSMS_OUT_Step==22 )
  1497. {
  1498. if( gTimer_GSM_AT>200)
  1499. {
  1500. SRAM_Init();
  1501. iLength = SRAM_Read(SRAM_SEND_LENGTH_H);
  1502. iLength <<= 8;
  1503. iLength += SRAM_Read(SRAM_SEND_LENGTH_L);
  1504. nTemp_Length=SRAM_Read(TARGET_NUMBER1_2); //目标电话号码的长度
  1505. nTemp_Length=(nTemp_Length+1)/2+7+1+(char)iLength+13; //要发送的数据长度
  1506. Ask_SMS_Send(nTemp_Length); //发送AT指令AT+CMGS=(SMS长度)
  1507. gInternal_Flag|=GSM_ONEAT_SUCCESS_1; //发送AT指令的标志置1
  1508. gSMS_OUT_Step=23;
  1509. gTimer_GSM_AT=0;
  1510. }
  1511. else Check_GSM();
  1512. }
  1513. else if( gSMS_OUT_Step==23 )
  1514. {
  1515. if(Check_GSM()!=0)
  1516. {
  1517. gTimer_GSM_AT=0;
  1518. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_Input_Label,sizeof(String_Input_Label)))
  1519. {
  1520. gSMS_OUT_Step=24;
  1521. }
  1522.     else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_ER,sizeof(String_ER))!=0)
  1523.     {
  1524. gOther_Flag&=~RECORD_DATA_F_1;
  1525. gOther_Flag&=~ALLOW_SEND_RECORD_F_1;
  1526. SRAM_Init();
  1527. SRAM_Write(SRAM_SEND_VAILD,NULL_2);
  1528. SRAM_Write(SRAM_SEND_LENGTH_H,0);
  1529. SRAM_Write(SRAM_SEND_LENGTH_L,0);
  1530. Case4_SMSOUT_Out();
  1531.     }
  1532. }
  1533. else
  1534. {
  1535. if(gTimer_GSM_AT>10000) Case_OverTime_Return();
  1536. }
  1537. }
  1538. else if( gSMS_OUT_Step==24 )
  1539. {
  1540. if(gTimer_GSM_AT>200)
  1541. {
  1542. //这个操作发送完000400
  1543. Send_SMS_Head();
  1544. OperateSPIEnd();
  1545. Send_Circle_GSM_TypeE();
  1546. Send_COM0_Byte(0x1A);
  1547. gSMS_OUT_Step=25;
  1548. gTimer_GSM_AT=0;
  1549. }
  1550. }
  1551. else if(gSMS_OUT_Step==25)
  1552. {
  1553. if(Check_GSM()!=0)
  1554. {
  1555. gOther_Flag&=~RECORD_DATA_F_1;
  1556. gOther_Flag&=~ALLOW_SEND_RECORD_F_1;
  1557. SRAM_Init();
  1558. SRAM_Write(SRAM_SEND_VAILD,NULL_2);
  1559. SRAM_Write(SRAM_SEND_LENGTH_H,0);
  1560. SRAM_Write(SRAM_SEND_LENGTH_L,0);
  1561. Case4_SMSOUT_Out();
  1562. }
  1563. else
  1564. {
  1565. if(gTimer_GSM_AT>60000)
  1566. {
  1567. gTimer_GSM_AT=0;
  1568. gOther_Flag&=~RECORD_DATA_F_1;
  1569. gOther_Flag&=~ALLOW_SEND_RECORD_F_1;
  1570. SRAM_Init();
  1571. SRAM_Write(SRAM_SEND_VAILD,NULL_2);
  1572. SRAM_Write(SRAM_SEND_LENGTH_H,0);
  1573. SRAM_Write(SRAM_SEND_LENGTH_L,0);
  1574. Case4_SMSOUT_Out();
  1575. }
  1576. }
  1577. }
  1578. }
  1579. /********************************************************
  1580. * 函数名：Case4_SMSOUT_Out
  1581. 作用域：本地文件调用
  1582. * 功能： 将CASE3中处理的出口
  1583. * 参数：
  1584. * 返回值：
  1585. * 创建人：
  1586. *
  1587. * 修改历史：（每条详述）
  1588. ********************************************************/
  1589. void Case4_SMSOUT_Out(void)
  1590. {
  1591. gGSM_Oper_Type=LAND_TCP_OPER;
  1592. gLand_GPRS_Step=0;
  1593. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  1594. gSMS_OUT_Step=0;gTimer_GSM_AT=0;
  1595. OperateSPIEnd();
  1596. }
  1597. /********************************************************
  1598. * 函数名：Case4_OverTime_Out
  1599. 作用域：本地文件调用
  1600. * 功能：
  1601. * 参数：
  1602. * 返回值：
  1603. * 创建人：
  1604. *
  1605. * 修改历史：（每条详述）
  1606. ********************************************************/
  1607. void Case4_OverTime_Out(unsigned char Clear_Flag)
  1608. {
  1609. unsigned int i=0;
  1610. OperateSPIEnd();
  1611. SRAM_Init();
  1612. if(Clear_Flag==1)
  1613. {
  1614. SRAM_Write(ECHO_SMS_2+0,NULL_2);
  1615. for(i=ECHO_SMS_2+1;i<OTHER_SMS_2;i++)
  1616. {
  1617. SRAM_Write(i,0);
  1618. }
  1619. }
  1620. else if(Clear_Flag==2)
  1621. {
  1622. SRAM_Write(OTHER_SMS_2+0,NULL_2);
  1623. for(i=OTHER_SMS_2+1;i<END_SRAM_2;i++)
  1624. {
  1625. SRAM_Write(i,0);
  1626. }
  1627. }
  1628. gSend_Type1=0;
  1629. }
  1630. /********************************************************
  1631. * 函数名：Case5_CHECK_GPRS_LINK
  1632. 作用域：本地文件调用
  1633. * 功能：1，进行TCP登陆 2，退出TCP
  1634. * 参数：
  1635. * 返回值：
  1636. * 创建人：
  1637. *
  1638. * 修改历史：（每条详述）
  1639. ********************************************************/
  1640. void Case5_LAND_GPRS_OPER(void)
  1641. {
  1642. unsigned int i=0,j=0,k=0;
  1644. if(gLand_GPRS_Step==0) {gLand_GPRS_Step=1;gTimer_GSM_AT=0;Check_GSM();}
  1646. else if(gLand_GPRS_Step==1)
  1647. {
  1648. /********************************************************
  1649. A 1,如果处于GSM的工作方式下，2，有需要进行TCP登陆的标志
  1650. 首先执行一个ATH指令
  1651. ********************************************************/
  1652. if( (gM22_Status==GSM_WORK)&&(gGeneral_Flag&LAND_TCP_F_1)
  1653. &&((gGeneral_Flag&LAND_TCP_ERROR_F_1)==0)
  1654. &&((gGeneral_Flag&TCP_PHONE_F_1)==0) )
  1655. {
  1656. if( gTimer_GSM_AT>500 )
  1657. {
  1658. Send_COM0_String((unsigned char *)ATH,sizeof(ATH));
  1659. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  1660. gTimer_GSM_AT=0;
  1661. gLand_GPRS_Step=2;
  1662. }
  1663. else Check_GSM();
  1664. }
  1665. /********************************************************
  1666. B 1,如果处于TCP在线挂起状态下，2，有需要进行TCP准备好退出登陆的标志||
  1667. ********************************************************/
  1668. else if( (gM22_Status==TCP_HANG_WORK)&&(gOther_Flag&QUIT_TCP_F_1) )
  1669. {
  1670. if( gTimer_GSM_AT>500 )
  1671. {
  1672. Send_COM0_String((unsigned char *)ATH,sizeof(ATH));
  1673. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  1674. gTimer_GSM_AT=0;
  1675. gLand_GPRS_Step=12;
  1676. }
  1677. else Check_GSM();
  1678. }
  1679. /********************************************************
  1680. C 1,TCP在线挂起状态 ，2，判断有需要需要发送ATO操作的标志
  1681. ********************************************************/
  1682. else if( (gM22_Status==TCP_HANG_WORK)
  1683. &&(gGeneral_Flag&TCP_STATUS_F_1)
  1684. &&((gGeneral_Flag&TCP_PHONE_F_1)==0)  )
  1685. {
  1686. if( gTimer_GSM_AT>500 )
  1687. {
  1688. Send_COM0_String((unsigned char *)ATO,sizeof(ATO));
  1689. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  1690. gTimer_GSM_AT=0;
  1691. gLand_GPRS_Step=14;
  1692. }
  1693. else Check_GSM();
  1694. }
  1695. /********************************************************
  1696. 如果上面条件均不满足，则退出这个CASE
  1697. ********************************************************/
  1698. else
  1699. {
  1700. if(gM22_Status==GSM_WORK) gOther_Flag&=~QUIT_TCP_F_1;
  1701. /********************************************************
  1702. 判断在GSM的状态下是否需要进行TCP登陆的操作
  1703. 1，IP地址有效，2，TCP开关量开启状态，3，GSM的工作方式，4，允许进行TCP登陆的操作
  1704. ********************************************************/
  1705. if(   (gGeneral_Flag&TCP_IP_VALID_1)
  1706. &&((gON_OFF_Temp0&TCP_LAND_ON_OFF_1)==0)
  1707. &&(gM22_Status==GSM_WORK)
  1708. &&((gGeneral_Flag&LAND_TCP_ERROR_F_1)==0) )
  1709. {
  1710. //1,如果有报警信息
  1711. if(   (gCycle_Send_Status==ALARM_DATA)
  1712. &&(gCycle_Alarm>0) )
  1713. {
  1714. gGeneral_Flag|=LAND_TCP_F_1;
  1715. gGSM_Oper_Type=LAND_TCP_OPER;
  1716. gLand_GPRS_Step=0;
  1717. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  1718. }
  1719. //2,如果有行车轨迹，且行车轨迹的周期小于20分钟，则允许长期在线，则进行登陆TCP的操作
  1720. else if(   (gCycle_Send_Status==TRACK_DATA_TIME)
  1721.  &&(gCycle_TCP<TCP_TRACK_MINTIME)
  1722.  &&(gCycle_TCP>0) )
  1723. {
  1724. gGeneral_Flag|=LAND_TCP_F_1;
  1725. gGSM_Oper_Type=LAND_TCP_OPER;
  1726. gLand_GPRS_Step=0;
  1727. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  1728. }
  1729. //3,如果是行车轨迹周期大于20分钟，且已经到有需要发送的数据包，则需要进行登陆
  1730. else if(  (gCycle_Send_Status==TRACK_DATA_TIME)
  1731. &&(gCycle_TCP>=TCP_TRACK_MINTIME)
  1732. &&(gInternal_Flag&SEND_CIRCLE_F_1) )
  1733. {
  1734. gGeneral_Flag|=LAND_TCP_F_1;
  1735. gGSM_Oper_Type=LAND_TCP_OPER;
  1736. gLand_GPRS_Step=0;
  1737. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  1738. }
  1739. //4,如果属于历史轨迹查询或者重点监控状态
  1740. else if(   (gCycle_Send_Status==PASS_DATA)
  1741.  ||(gCycle_Send_Status==WATCH_DATA)  )
  1742. {
  1743. gGeneral_Flag|=LAND_TCP_F_1;
  1744. gGSM_Oper_Type=LAND_TCP_OPER;
  1745. gLand_GPRS_Step=0;
  1746. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  1747. }
  1748. //5,如果属于间隔距离传输数据点，并且TCP属于常开状态,则需要登陆TCP
  1749. else if(   (gCycle_Send_Status==TRACK_DATA_DISTANCE)
  1750.  &&((gON_OFF_Temp1&DISTANCE_TCP_ON_1)==0) )
  1751. {
  1752. gGeneral_Flag|=LAND_TCP_F_1;
  1753. gGSM_Oper_Type=LAND_TCP_OPER;
  1754. gLand_GPRS_Step=0;
  1755. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  1756. }
  1757. //6,如果属于间隔距离传输数据点，并且TCP属于不常在线状态，但有数据点需要发送，则需要进行登陆
  1758. else if(   (gCycle_Send_Status==TRACK_DATA_DISTANCE)
  1759.  &&(gON_OFF_Temp1&DISTANCE_TCP_ON_1)
  1760.  &&(gInternal_Flag&SEND_CIRCLE_F_1) )
  1761. {
  1762. gGeneral_Flag|=LAND_TCP_F_1;
  1763. gGSM_Oper_Type=LAND_TCP_OPER;
  1764. gLand_GPRS_Step=0;
  1765. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  1766. }
  1767. //7, 如果有记录仪的数据需要上行给数据中心的，则先进行登陆TCP的操作
  1768. else if( gOther_Flag&RECORD_DATA_F_1)
  1769. {
  1770. gGeneral_Flag|=LAND_TCP_F_1;
  1771. gGSM_Oper_Type=LAND_TCP_OPER;
  1772. gLand_GPRS_Step=0;
  1773. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  1774. }
  1775. //8,如果其他要发送的数据，则需要先登陆TCP
  1776. else if( gOther_Flag&NEED_LADN_TCP_F_1 )
  1777. {
  1778. gOther_Flag&=~NEED_LADN_TCP_F_1;
  1779. gGeneral_Flag|=LAND_TCP_F_1;
  1780. gGSM_Oper_Type=LAND_TCP_OPER;
  1781. gLand_GPRS_Step=0;
  1782. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  1783. }
  1784. //如果其他
  1785. else
  1786. {
  1787. gGSM_Oper_Type=GSM_PHONE;gPhone_Step=0;
  1788. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  1789. gLand_GPRS_Step=0;
  1790. }
  1791. }
  1792. else
  1793. {
  1794. gGSM_Oper_Type=GSM_PHONE;gPhone_Step=0;
  1795. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  1796. gLand_GPRS_Step=0;
  1797. }
  1798. gTimer_GSM_AT=0;
  1799. OperateSPIEnd();
  1800. }
  1801. }
  1802. else if(gLand_GPRS_Step==2)
  1803. {
  1804. if( Check_GSM()!=0 )
  1805. {
  1806. gLand_GPRS_Step=3;
  1807. }
  1808. else
  1809. {
  1810. if(gTimer_GSM_AT>10000) Case_OverTime_Return();
  1811. }
  1812. }
  1813. else if(gLand_GPRS_Step==3)
  1814. {
  1815. if( gTimer_GSM_AT>500 )
  1816. {
  1817. Send_COM0_String((unsigned char *)AT_CGDCONT,sizeof(AT_CGDCONT));
  1818. j=SRAM_Read(GPRS_APN_ADDRESS2_2);
  1819. for(i=0;i<j;i++)
  1820. {
  1821. Send_COM0_Byte(SRAM_Read(GPRS_APN_ADDRESS2_2+1+i));
  1822. }
  1823. Send_COM0_Byte(0x0d);
  1824. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  1825. gTimer_GSM_AT=0;
  1826. gLand_GPRS_Step=4;
  1827. }
  1828. else Check_GSM();
  1829. }
  1830. //A-1
  1831. else if(gLand_GPRS_Step==4)
  1832. {
  1833. if( Check_GSM()!=0 )
  1834. {
  1835. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;gTimer_GSM_AT=0;
  1836. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_OK,sizeof(String_OK)))
  1837. {
  1838. gLand_GPRS_Step=5;
  1839. }
  1840. }
  1841. else
  1842. {
  1843. if(gTimer_GSM_AT>10000)
  1844. {
  1845. TCP_Land_Error_Return();
  1846. }
  1847. }
  1848. }
  1849. //A-2
  1850. else if(gLand_GPRS_Step==5)
  1851. {
  1852. if( gTimer_GSM_AT>500 )
  1853. {
  1854. Send_COM0_String((unsigned char *)AT_CGPCO,sizeof(AT_CGPCO));
  1855. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  1856. gTimer_GSM_AT=0;
  1857. gLand_GPRS_Step=6;
  1858. }
  1859. else Check_GSM();
  1860. }
  1861. //A-3
  1862. else if(gLand_GPRS_Step==6)
  1863. {
  1864. if( Check_GSM()!=0 )
  1865. {
  1866. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;gTimer_GSM_AT=0;
  1867. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_OK,sizeof(String_OK)))
  1868. {
  1869. gLand_GPRS_Step=7;
  1870. }
  1871. }
  1872. else
  1873. {
  1874. if(gTimer_GSM_AT>10000)
  1875. {
  1876. //表示登陆TCP失败的处理
  1877. TCP_Land_Error_Return();
  1878. }
  1879. }
  1880. }
  1881. //A-4
  1882. else if(gLand_GPRS_Step==7)
  1883. {
  1884. if( gTimer_GSM_AT>500 )
  1885. {
  1886. Send_COM0_String((unsigned char *)AT_DESTINFO,sizeof(AT_DESTINFO));
  1887. //1,从buffer1中取出IP地址
  1888. Send_COM0_Byte('"');
  1889. j=SRAM_Read(GPRS_IP_ADDRESS1_2);
  1890. for(i=0;i<j;i++)
  1891. {
  1892. Send_COM0_Byte(SRAM_Read(GPRS_IP_ADDRESS1_2+1+i));
  1893. }
  1894. Send_COM0_Byte('"');
  1895. Send_COM0_Byte(',');
  1896. Send_COM0_Byte('1');
  1897. Send_COM0_Byte(',');
  1898. //2，从buffer中取出端口号，在buffer1中端口号是以5位ASCII形式存储的，如果实际有效数据不够5位，则以前面填0
  1899. //例如：端口号为9988，在buffer1中相应的区域存储为30 39 39 38 38
  1900. gGeneral_Buffer[0]=SRAM_Read(GPRS_SOCKET1_2);
  1901. gGeneral_Buffer[1]=SRAM_Read(GPRS_SOCKET1_2+1);
  1902. gGeneral_Buffer[2]=SRAM_Read(GPRS_SOCKET1_2+2);
  1903. gGeneral_Buffer[3]=SRAM_Read(GPRS_SOCKET1_2+3);
  1904. gGeneral_Buffer[4]=SRAM_Read(GPRS_SOCKET1_2+4);
  1905. OperateSPIEnd();
  1906. i=0;
  1907. while(1)
  1908. {
  1909. //从最高位开始判断，如果不为0，则后面的均为有效数据
  1910. if(gGeneral_Buffer[i]!=0x30) break;
  1911. i++;
  1912. if(i==5) break;
  1913. }
  1914. if(i<5)
  1915. {
  1916. for(j=i;j<5;j++)
  1917. {
  1918. Send_COM0_Byte(gGeneral_Buffer[j]);
  1919. }
  1920. }
  1921. else
  1922. {
  1923. gLand_GPRS_Step=0;
  1924. return;
  1925. }
  1926. Send_COM0_Byte(0x0d);
  1927. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  1928. gLand_GPRS_Step=8;
  1929. gTimer_GSM_AT=0;
  1930. }
  1931. else  Check_GSM();
  1932. }
  1933. //A-5
  1934. else if(gLand_GPRS_Step==8)
  1935. {
  1936. if( Check_GSM()!=0 )
  1937. {
  1938. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;gTimer_GSM_AT=0;
  1939. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_DESTINFO,sizeof(String_DESTINFO)))
  1940. {
  1941. gLand_GPRS_Step=9;
  1942. }
  1943. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_ER,sizeof(String_ER)))
  1944. {
  1945. TCP_Land_Error_Return();
  1946. }
  1947. }
  1948. else
  1949. {
  1950. if(gTimer_GSM_AT>10000)
  1951. {
  1952. //表示登陆TCP失败的处理
  1953. TCP_Land_Error_Return();
  1954. }
  1955. }
  1956. }
  1957. //A-6
  1958. else if(gLand_GPRS_Step==9)
  1959. {
  1960. if(gTimer_GSM_AT>1500)
  1961. {
  1962. Send_COM0_String((unsigned char *)ATD_97,sizeof(ATD_97));
  1963. gInternal_Flag|=GSM_ONEAT_SUCCESS_1;
  1964. gLand_GPRS_Step=10;
  1965. gTimer_GSM_AT=0;
  1966. }
  1967. else Check_GSM();
  1968. }
  1969. //A-7
  1970. else if(gLand_GPRS_Step==10)
  1971. {
  1972. if( Check_GSM()!=0 )
  1973. {
  1974. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;gTimer_GSM_AT=0;
  1975. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_L_TCP,sizeof(String_L_TCP)))
  1976. {
  1977. gLand_GPRS_Step=11;
  1978. }
  1979. //返回ERROR，说明SIM卡不支持TCP的工作方式或者说任何场强信号很弱的时候
  1980. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_ER,sizeof(String_ER)))
  1981. {
  1982. TCP_Land_Error_Return();
  1983. }
  1984. }
  1985. else
  1986. {
  1987. if(gTimer_GSM_AT>65000)
  1988. {
  1989. TCP_Land_Error_Return();
  1990. }
  1991. }
  1992. }
  1993. //A-8
  1994. else if(gLand_GPRS_Step==11)
  1995. {
  1996. if( Check_GSM()!=0 )
  1997. {
  1998. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;gTimer_GSM_AT=0;
  1999. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_OK,sizeof(String_OK)))
  2000. {
  2001. //说明登陆成功,此时不能进行AT指令的任何操作，直接进入CASE6中
  2002. gGeneral_Flag&=~LAND_TCP_F_1;
  2003. gLand_TCP_ERROR_Count=0;
  2004. gGSM_Oper_Type=GPRS_DATA_OPER;
  2005. gM22_Status=TCP_ONLINE_WORK;
  2006. gLand_GPRS_Step=0;
  2007. gTimer_CSQ=0;
  2008. for(i=0;i<sizeof(gReceive0_GSM_Buffer);i++) gReceive0_GSM_Buffer[i]=0;
  2009. gReceive0_GSM_Buffer_End=sizeof(gReceive0_GSM_Buffer)-1;
  2010. gReceive0_GSM_Buffer_Point=0;
  2011. gReceive0_GSM_Buffer_Move=0;
  2012. gGSM_Work_Count=0;gCheck_Data=0;
  2013. gInternal_Flag&=~ALLOW_DATA_F_1;
  2014. //发送登陆TCP的数据
  2015. gOther_Flag|=ALLOW_SENDLAND_F_1;
  2016. gGeneral_Flag&=~LAND_TCP_SUCCESS_F_1;
  2017. }
  2018. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_ER,sizeof(String_ER)))
  2019. {
  2020. gLand_GPRS_Step=111;
  2021. }
  2022. }
  2023. else
  2024. {
  2025. if(gTimer_GSM_AT>65000)
  2026. {
  2027. TCP_Land_Error_Return();
  2028. }
  2029. }
  2030. }
  2031. else if(gLand_GPRS_Step==111)
  2032. {
  2033. if( Check_GSM()!=0 )
  2034. {
  2035. TCP_Land_Error_Return();
  2036. }
  2037. else
  2038. {
  2039. if(gTimer_GSM_AT>40000)
  2040. {
  2041. TCP_Land_Error_Return();
  2042. }
  2043. }
  2044. }
  2045. //B-1
  2046. else if(gLand_GPRS_Step==12)
  2047. {
  2048. if( Check_GSM()!=0 )
  2049. {
  2050. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;gTimer_GSM_AT=0;
  2051. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_OK,sizeof(String_OK)))
  2052. {
  2053. gLand_GPRS_Step=13;
  2054. gOther_Flag&=~QUIT_TCP_F_1;
  2055. }
  2056. }
  2057. else
  2058. {
  2059. if(gTimer_GSM_AT>20000)
  2060. {
  2061. Case_OverTime_Return();
  2062. }
  2063. }
  2064. }
  2065. //B-2
  2066. else if(gLand_GPRS_Step==13)
  2067. {
  2068. if( Check_GSM()!=0 )
  2069. {
  2070. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;gTimer_GSM_AT=0;
  2071. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_NOCARRIER,sizeof(String_NOCARRIER)))
  2072. {
  2073. gM22_Status=GSM_WORK;
  2074. gGeneral_Flag&=~LAND_TCP_SUCCESS_F_1;
  2075. gGSM_Oper_Type=GSM_PHONE;
  2076. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  2077. gPhone_Step=0;gTimer_GSM_AT=0;
  2078. gOther_Flag&=~QUIT_TCP_F_1;
  2079. }
  2080. }
  2081. else
  2082. {
  2083. if(gTimer_GSM_AT>20000)
  2084. {
  2085. Case_OverTime_Return();
  2086. }
  2087. }
  2088. }
  2089. //C-1
  2090. else if(gLand_GPRS_Step==14)
  2091. {
  2092. if( Check_GSM()!=0 )
  2093. {
  2094. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;gTimer_GSM_AT=0;
  2095. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_CONNECT,sizeof(String_CONNECT)))
  2096. {
  2097. //进入TCP在线状态
  2098. gM22_Status=TCP_ONLINE_WORK;
  2099. gLand_GPRS_Step=0;
  2100. gGeneral_Flag&=~TCP_STATUS_F_1;
  2101. gReceive0_GSM_Buffer_Move=gReceive0_GSM_Buffer_Point;
  2102. if(gReceive0_GSM_Buffer_Point==0)  gReceive0_GSM_Buffer_End=sizeof(gReceive0_GSM_Buffer)-1;
  2103. else      gReceive0_GSM_Buffer_End=gReceive0_GSM_Buffer_Point-1;
  2104. gGSM_Oper_Type=GPRS_DATA_OPER;
  2105. gGPRS_Data_Step=0;
  2106. gTimer_CSQ=0;
  2107. //登陆成功，如果有报警，
  2108. if(gCycle_Send_Status==ALARM_DATA)
  2109. {
  2110. gCycle_Alarm=ALARM_CIRCLE_TIME;
  2111. gAlarm_Count=0;
  2112. }
  2113. }
  2114. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_ER,sizeof(String_ER)))
  2115. {
  2116. //进入GSM的工作方式下
  2117. gReset_M22_On_Setp=0;
  2118. gGeneral_Flag&=~RESET_GSM_ON_F_1;
  2119. gM22_Status=GSM_WORK;
  2120. gGeneral_Flag&=~LAND_TCP_SUCCESS_F_1;
  2121. gGSM_Oper_Type=GSM_PHONE;
  2122. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  2123. gPhone_Step=0;gTimer_GSM_AT=0;
  2124. }
  2125. }
  2126. else
  2127. {
  2128. if(gTimer_GSM_AT>65000) Case_OverTime_Return();
  2129. }
  2130. }
  2131. }
  2132. /********************************************************
  2133. * 函数名：TCP_Land_Error_Return
  2134. 作用域：本地文件调用
  2135. * 功能：
  2136. * 参数：
  2137. * 返回值：
  2138. * 创建人：
  2139. *
  2140. * 修改历史：（每条详述）
  2141. 现在如果TCP登陆失败，则重新初始化M22模块，不采用掉电的方式，,如果连续登陆失败5次，则需要进行
  2142. 模块掉电处理。
  2143. ********************************************************/
  2144. void TCP_Land_Error_Return(void)
  2145. {
  2146. Send_COM1_String((unsigned char *)TCP_LAND_ERROR,sizeof(TCP_LAND_ERROR));
  2147. gGeneral_Flag|=RESET_GSM_ON_F_1;
  2148. gReset_M22_On_Setp=1;
  2149. gM22_Status=GSM_WORK;
  2150. gM22_GSM_ECHO_Timer=0;
  2151. gLand_Interval_Timer=0;
  2152. gTCP_FF0D_Send_Timer=0;
  2153. gGPS_No_Output_Timer=0;
  2154. gTimer_GSM_AT=0;
  2155. gTimer_CSQ=0;
  2156. gGPS_Receive_Over=0;
  2158.     gPhone_Status=READY;
  2159. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  2160. gGeneral_Flag&=~DAILING_UP_F_1;
  2161. gGeneral_Flag&=~MONITOR_ON_F_1;
  2162. gGeneral_Flag&=~TCP_PHONE_F_1;
  2163. gGeneral_Flag&=~RING_F_1;
  2164. gGSM_Oper_Type=0;
  2165. gSMS_IN_Step=0;
  2166. gSMS_OUT_Step=0;
  2167. gLand_GPRS_Step=0;
  2168. gGPRS_Data_Step=0;
  2169. gGSM_OTHER_Step=0;
  2171. gGeneral_Flag|=LAND_TCP_ERROR_F_1;
  2172. gLand_TCP_ERROR_Count++;
  2173. if(gLand_TCP_ERROR_Count>5)
  2174. {
  2175. gLand_TCP_ERROR_Count=0;
  2176. gGeneral_Flag|=OFF_M22_F_1;
  2177. gOFF_Power_S=1;
  2178. gPhone_Status=READY;
  2179. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  2180. }
  2182. //如果属于周期数据的发送
  2183. if(gInternal_Flag&SEND_CIRCLE_F_1)
  2184. {
  2185. //1，按时间间隔上报数据，且间隔大于分界值
  2186. if( (gCycle_Send_Status==TRACK_DATA_TIME)&&(gCycle_TCP>TCP_TRACK_MINTIME) )
  2187. {
  2188. gInternal_Flag|=ALLOW_DATA_F_1;
  2189. }
  2190. else
  2191. {
  2192. gInternal_Flag&=~ALLOW_DATA_F_1;
  2193. gInternal_Flag&=~SEND_CIRCLE_F_1;
  2194. }
  2195. }
  2196. //如果属于外部行使记录仪数据的发送，
  2197. else if(gOther_Flag&RECORD_DATA_F_1)
  2198. {
  2199. gOther_Flag&=~RECORD_DATA_F_1;
  2200. gOther_Flag&=~ALLOW_SEND_RECORD_F_1;
  2201. SRAM_Init();
  2202. SRAM_Write(SRAM_SEND_VAILD,NULL_2);
  2203. SRAM_Write(SRAM_SEND_LENGTH_H,0);
  2204. SRAM_Write(SRAM_SEND_LENGTH_L,0);
  2205. gInternal_Flag&=~ALLOW_DATA_F_1;
  2206. }
  2207. else
  2208. {
  2209. gInternal_Flag|=ALLOW_DATA_F_1;
  2210. }
  2211. }
  2212. /********************************************************
  2213. * 函数名：Case6_GPRS_DATA_OPER
  2214. 作用域：本地文件调用
  2215. * 功能： 进行与GPRS相关的数据操作，以发送为主，接收数据则在Check_GSM()中直接处理
  2216. * 参数：
  2217. * 返回值：
  2218. * 创建人：
  2219. *
  2220. * 修改历史：（每条详述）
  2221. 2004年12月15日
  2222. 补充说明：
  2223. 1，如果在这个CASE外判断有数据要发送，同时TCP处于被挂起状态，则首先执行ATO指令后，然后进入这个
  2224. CASE中进行通过TCP方式发送数据：一旦数据发送完成，则执行+++，将TCP的状态挂起，但如果发送的数据
  2225. 属于握手信号FF 0D，则需要发送完数据后，执行一个等待的时间，判断是否接收到下行的握手数据
  2226. 不管是否接收到下行的握手数据，在等待时间过后，则执行+++，将TCP挂起！但会将这次握手失败的记数增加一
  2227. ********************************************************/
  2228. void Case6_GPRS_DATA_OPER(void)
  2229. {
  2230.   unsigned int i=0,j=0,k=0,x=0,y=0;
  2231. unsigned char nTemp_Length=0;
  2232. static unsigned char Hang_Error=0;
  2234. if(gM22_TCP_ECHO_Timer>200) gInternal_Flag|=TCPSEND_ALLOW_F_1;
  2235. else if(gM22_TCP_ECHO_Timer==0) gInternal_Flag&=~TCPSEND_ALLOW_F_1;
  2237.     if(gM22_Status!=TCP_ONLINE_WORK)
  2238.     {
  2239. gGSM_Oper_Type=GSM_PHONE;
  2240. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  2241. gPhone_Step=0;gTimer_GSM_AT=0;
  2242.      return;
  2243.     }
  2244. if(gGPRS_Data_Step==0)   gGPRS_Data_Step=1;
  2245. else if(gGPRS_Data_Step==1)
  2246. {
  2247. Check_TCP();
  2248. gSend_Type1=0;
  2249. SRAM_Init();
  2250. i=SRAM_Read(ECHO_SMS_2); //存储是否有第二类发送数据的标志
  2251. j=SRAM_Read(OTHER_SMS_2); //存储是否有第三类发送数据的标志
  2252. //发送登陆信息数据
  2253. if(gOther_Flag&ALLOW_SENDLAND_F_1)
  2254. {
  2255. gOther_Flag&=~ALLOW_SENDLAND_F_1;
  2256. gGPRS_Data_Step=12;gTimer_GSM_AT=0;
  2257. Send_COM1_String((unsigned char *)CONNCET_TCP,sizeof(CONNCET_TCP));
  2258. }
  2259. //第一类数据的TCP发送（存储在buffer1中的数据）
  2260. else if( (i!=NULL_2)&&(gGeneral_Flag&LAND_TCP_SUCCESS_F_1) )
  2261. {
  2262. gGPRS_Data_Step=2;gTimer_GSM_AT=0;
  2263. gSend_Type1=1;
  2264. #ifdef Debug_GSM_COM1
  2265. Send_COM1_Byte('B');Send_COM1_String((unsigned char *)TYPE,sizeof(TYPE));
  2266. #endif
  2267. }
  2268. else if( (j!=NULL_2)&&(gGeneral_Flag&LAND_TCP_SUCCESS_F_1)  )
  2269. {
  2270. gGPRS_Data_Step=2;gTimer_GSM_AT=0;
  2271. gSend_Type1=2;
  2272. #ifdef Debug_GSM_COM1
  2273. Send_COM1_Byte('C');Send_COM1_String((unsigned char *)TYPE,sizeof(TYPE));
  2274. #endif
  2275. }
  2276. //第二类数据的TCP发送（周期数据）
  2277. else if( (gInternal_Flag&SEND_CIRCLE_F_1)&&(gGeneral_Flag&LAND_TCP_SUCCESS_F_1) )
  2278. {
  2279. gInternal_Flag&=~SEND_CIRCLE_F_1;
  2280. gGPRS_Data_Step=3;gTimer_GSM_AT=0;
  2281. if(gCycle_Send_Status==TRACK_DATA_TIME) Send_COM1_String((unsigned char *)TRACK,sizeof(TRACK));
  2282. else if(gCycle_Send_Status==ALARM_DATA) Send_COM1_String((unsigned char *)ALARM,sizeof(ALARM));
  2283. else if(gCycle_Send_Status==TRACK_DATA_DISTANCE) Send_COM1_String((unsigned char *)DISTANCE,sizeof(DISTANCE));
  2284. else if(gCycle_Send_Status==WATCH_DATA)
  2285. {
  2286. Send_COM1_String((unsigned char *)WATCH,sizeof(WATCH));
  2287. if(gWatch_Count>0) gWatch_Count--;
  2288. }
  2289. Send_COM1_String((unsigned char *)TYPE,sizeof(TYPE));
  2290. }
  2291. //第三类数据的TCP发送（FF 0D ）
  2292. else if ( (gTCP_FF0D_Send_Timer>TCP_TEST_TIME) )
  2293. {
  2294. gTCP_FF0D_Send_Timer=0;
  2295. gGPRS_Data_Step=4;gTimer_GSM_AT=0;
  2296. #ifdef Debug_GSM_COM1
  2297. Send_COM1_Byte('E');Send_COM1_String((unsigned char *)TYPE,sizeof(TYPE));
  2298. #endif
  2299. gTimer_CSQ=0;
  2300. }
  2301. //第四类数据的发送（外部记录仪数据）
  2302. else if ( (gOther_Flag&ALLOW_SEND_RECORD_F_1)&&(gGeneral_Flag&LAND_TCP_SUCCESS_F_1) )
  2303. {
  2304. SRAM_Init();
  2305. if( SRAM_Read(SRAM_SEND_VAILD)==VAILD_2 )
  2306. {
  2307. gGPRS_Data_Step=5;gTimer_GSM_AT=0;
  2308. #ifdef Debug_GSM_COM1
  2309. Send_COM1_Byte('F');Send_COM1_String((unsigned char *)TYPE,sizeof(TYPE));
  2310. #endif
  2311. //显示可以发送的数据的长度
  2312. i=0;
  2313. i=SRAM_Read(SRAM_SEND_LENGTH_H);
  2314. i<<=8;
  2315. i=i+SRAM_Read(SRAM_SEND_LENGTH_L);
  2316. Send_COM1_Byte('[');
  2317.             Send_COM1_Byte(ASCII(i/0x100));
  2318.             Send_COM1_Byte(ASCII((i%0x100)/0x10));
  2319.             Send_COM1_Byte(ASCII(i%0x10));
  2320.             Send_COM1_Byte(']');
  2321.             gTCP_FF0D_Send_Timer=0;
  2322.             //////////////////////////
  2323.             /*
  2324.             #ifdef Debug_GSM_COM1
  2325. for(j=0;j<i;j++)
  2326. {
  2327. k=SRAM_Read(SRAM_SEND_S+j);
  2328. Send_COM1_Byte(ASCII(k/0x10));
  2329. Send_COM1_Byte(ASCII(k%0x10));
  2330. Clear_Exter_WatchDog();
  2331. }
  2332.             //////////////////////////
  2333.             Send_COM1_Byte(0x0d);Send_COM1_Byte(0xa);
  2334.             #endif
  2335.             */
  2336. }
  2337. else
  2338. {
  2339. gOther_Flag&=~RECORD_DATA_F_1;
  2340. gOther_Flag&=~ALLOW_SEND_RECORD_F_1;
  2341. SRAM_Init();
  2342. SRAM_Write(SRAM_SEND_VAILD,NULL_2);
  2343. SRAM_Write(SRAM_SEND_LENGTH_H,0);
  2344. SRAM_Write(SRAM_SEND_LENGTH_L,0);
  2345. gGPRS_Data_Step=0;
  2346. }
  2347. }
  2348. //8,如果没有判断到有发送的数据，如果到了需要查询CSQ的时间到，则发送挂起操作
  2349. else if(   (gTimer_CSQ>TCP_CHECKCSQ_TIME)
  2350.  &&(gGeneral_Flag&LAND_TCP_SUCCESS_F_1)
  2351.  &&((gOther_Flag&RECORD_DATA_F_1)==0) )
  2352. {
  2353. gGPRS_Data_Step=9;gTimer_GSM_AT=0;
  2354. }
  2355. //9,判断是否需要退出TCP在线
  2356. else if(gOther_Flag&QUIT_TCP_F_1)
  2357. {
  2358. gOther_Flag&=~NEED_LADN_TCP_F_1;
  2359. gGPRS_Data_Step=9;gTimer_GSM_AT=0;
  2360. }
  2361. //10,如果有电话相关的业务，则需要先挂起TCP
  2362. else if(gGeneral_Flag&TCP_PHONE_F_1)
  2363. {
  2364. gGPRS_Data_Step=9;gTimer_GSM_AT=0;
  2365. }
  2366. //11,如果没有上面的数据，则执行接收TCP数据的处理
  2367. else
  2368. {
  2369. Check_TCP();
  2370. gGPRS_Data_Step=0;gTimer_GSM_AT=0;
  2371. i=SRAM_Read(ECHO_SMS_2); //存储是否有第二类发送数据的标志
  2372. j=SRAM_Read(OTHER_SMS_2); //存储是否有第三类发送数据的标志
  2373. /********************************************************
  2374. 判断在TCP在线的状态下是否需要进行TCP退出的操作
  2375. ********************************************************/
  2376. //1,判断如果是属于行车轨迹状态，同时周期数据大于10分钟,并且无周期数据发送
  2377. if(     (gCycle_Send_Status==TRACK_DATA_TIME)
  2378. &&(gCycle_TCP>=TCP_TRACK_MINTIME)
  2379. &&(gGeneral_Flag&LAND_TCP_SUCCESS_F_1)
  2380. &&((gInternal_Flag&SEND_CIRCLE_F_1)==0)
  2381. &&((gOther_Flag&RECORD_DATA_F_1)==0)  )
  2382. {
  2383. gOther_Flag|=QUIT_TCP_F_1;
  2384. }
  2385. //2,    判断如果属于报警状态，同时发送的周期数据大于10分钟秒，并且无周期数据发送
  2386. else if(  (gCycle_Send_Status==ALARM_DATA)
  2387. &&(gCycle_Alarm>=TCP_TRACK_MINTIME)
  2388. &&(gGeneral_Flag&LAND_TCP_SUCCESS_F_1)
  2389. &&((gInternal_Flag&SEND_CIRCLE_F_1)==0)
  2390. &&((gOther_Flag&RECORD_DATA_F_1)==0)  )
  2391. {
  2392. gOther_Flag|=QUIT_TCP_F_1;
  2393. }
  2394. //3,如果属于按间隔发送，且不属于常在线方式，并且无周期数据发送
  2395. else if(  (gCycle_Send_Status==TRACK_DATA_DISTANCE)
  2396. &&(gON_OFF_Temp1&DISTANCE_TCP_ON_1)
  2397. &&(gGeneral_Flag&LAND_TCP_SUCCESS_F_1)
  2398. &&((gInternal_Flag&SEND_CIRCLE_F_1)==0)
  2399. &&((gOther_Flag&RECORD_DATA_F_1)==0)  )
  2400. {
  2401. gOther_Flag|=QUIT_TCP_F_1;
  2402. }
  2403. //3,无任何需要发送的数据，则需要退出TCP
  2404. else if(  (gCycle_Send_Status==NOP_DATA)
  2405. &&(gGeneral_Flag&LAND_TCP_SUCCESS_F_1)
  2406. &&(i==NULL_2)
  2407. &&(j==NULL_2)
  2408. &&( (gOther_Flag&RECORD_DATA_F_1)==0)  )
  2409. {
  2410. gOther_Flag|=QUIT_TCP_F_1;
  2411. }
  2412. else
  2413. {
  2414. j=SRAM_Read(PHONE_AT_2);
  2415. if(j==VAILD_2)
  2416. {
  2417. i=SRAM_Read(PHONE_AT_2+1);
  2418. if(i==H_DIAL) //手柄主动拨号
  2419. {
  2420. gGeneral_Flag|=TCP_PHONE_F_1;
  2421. gStatus1_Flag|=PHONE_ONLINE_F_1;
  2422. gGeneral_Flag|=DAILING_UP_F_1;
  2423. }
  2424. else if(i==M_DIAL) //监听主动拨号
  2425. {
  2426. gGeneral_Flag|=MONITOR_ON_F_1;
  2427. gGeneral_Flag|=TCP_PHONE_F_1;
  2428. gStatus1_Flag|=PHONE_ONLINE_F_1;
  2429. }
  2430. else if(i==H_HUNGUP)
  2431. {
  2432. SRAM_Init();
  2433. SRAM_Write(PHONE_AT_2,NULL_2);
  2434. }
  2435. }
  2437. }
  2438. }
  2439. }
  2440. /********************************************************
  2441. 一，第一类数据的发送
  2442. 1-1，
  2443. 0x7B 存储表示这个区域的SMS是否处理，为1则表示后面还有未处理的SMS，为0则表示已经处理完了SMS
  2444. 0x7C 存储数据包的命令字在这里则为nCommand
  2445. 0x7D 存储数据包的ACK的值ACK
  2446. 0x7E 存储后面数据包的长度（但注意没有存储CHK(MSB),CHK(LSB),EOT,这三个字节）
  2447. 0x7F   从这开始存储数据包
  2448. 1-2
  2449. 0xB1 存储表示这个区域的SMS是否处理，为1则表示后面还有未处理的SMS，为0则表示已经处理完了SMS
  2450. 0xB2 存储数据包的命令字在这里则为nCommand
  2451. 0xB3 存储数据包的ACK的值ACK
  2452. 0xB4 存储后面数据包的长度（但注意没有存储CHK(MSB),CHK(LSB),EOT,这三个字节）
  2453. 0xB5   从这开始存储数据包
  2454. ********************************************************/
  2455. else if(gGPRS_Data_Step==2)
  2456. {
  2457. if( (gTimer_GSM_AT>200)&&(gInternal_Flag&TCPSEND_ALLOW_F_1) )
  2458. {
  2459. OperateSPIEnd();
  2460. if(gSend_Type1==1)
  2461. {
  2462. i=SRAM_Read(ECHO_SMS_2+1);
  2463. j=SRAM_Read(ECHO_SMS_2+2); //ACK
  2464. k=SRAM_Read(ECHO_SMS_2+3); //长度
  2465. }
  2466. else if(gSend_Type1==2)
  2467. {
  2468. i=SRAM_Read(OTHER_SMS_2+1);
  2469. j=SRAM_Read(OTHER_SMS_2+2); //ACK
  2470. k=SRAM_Read(OTHER_SMS_2+3); //长度
  2471. }
  2472. OperateSPIEnd();
  2473. //一直发送到VID
  2474. x=Send_Echo_TCP_Head( (char)(k+12),(char)i,(char)j,(char)(k+12-4) );
  2475. //发送数据区ECHO_SMS_2为buffer1的起始地址，k为数据长度
  2476. if(gSend_Type1==1) y=Send_Buffer1_TCP_Data(x,ECHO_SMS_2+4,k);
  2477. else if(gSend_Type1==2) y=Send_Buffer1_TCP_Data(x,OTHER_SMS_2+4,k);
  2478. //发送校验核和结束符
  2479. Send_Echo_TCP_End(y);
  2480. Case4_OverTime_Out(gSend_Type1);
  2481. gGPRS_Data_Step=10;
  2482. }
  2483. else Check_TCP();
  2484. }
  2485.   /********************************************************
  2486. 二，
  2487. 存储在区域的数据Circle_Buffer[]
  2488. 1，行车轨迹数据 ；2，报警数据
  2489. 这5类周期发送的数据因为不能同时存在发送的情形，则可以均用Circle_Buffer[]作为
  2490. 存储周期数据发送。
  2491. gCycle_Send_Status=1 表示属于行车轨迹的周期数据正在发送
  2492. gCycle_Send_Status=2 表示报警的周期数据正在发送
  2493. gCycle_Send_Status=3 表示监控数据正在发送（另外还有标志位表示属于那一类型的监控数据）
  2494. ********************************************************/
  2495. else if(gGPRS_Data_Step==3)
  2496. {
  2497. if( (gTimer_GSM_AT>200)&&(gInternal_Flag&TCPSEND_ALLOW_F_1) )
  2498. {
  2499. Send_Circle_TCP_TypeD();
  2500. for(i=0;i<sizeof(gCircle_Buffer);i++) gCircle_Buffer[i]=0;
  2501. gCircle_Buffer_Point=0;
  2502. gGPRS_Data_Step=10;
  2503. }
  2504. else Check_TCP();
  2505. }
  2506.   /********************************************************
  2507. 三，发送TCP数据FF 0D
  2508. ********************************************************/
  2509. else if(gGPRS_Data_Step==4)
  2510. {
  2511. if( (gTimer_GSM_AT>500)&&(gInternal_Flag&TCPSEND_ALLOW_F_1) )
  2512. {
  2513. Send_COM1_String((unsigned char *)String_TestGPRS,sizeof(String_TestGPRS));
  2514. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  2515. Send_COM0_Byte(0xFF);
  2516. Send_COM0_Byte(0x0D);
  2517. gTimer_GSM_AT=0;
  2518. gGPRS_Data_Step=10;
  2519. }
  2520. else Check_TCP();
  2521. }
  2522. /********************************************************
  2523. 四，外接部件的TCP数据发送
  2524. ********************************************************/
  2525. else if(gGPRS_Data_Step==5)
  2526. {
  2527. if( (gTimer_GSM_AT>500)&&(gInternal_Flag&TCPSEND_ALLOW_F_1) )
  2528. {
  2529. Send_Circle_TCP_TypeE();
  2530. gTimer_GSM_AT=0;
  2531. gGPRS_Data_Step=10;
  2532. }
  2533. else Check_TCP();
  2534. }
  2535. /********************************************************
  2536. 五，TCP挂起的操作
  2537. ********************************************************/
  2538. else  if(gGPRS_Data_Step==9)
  2539. {
  2540. if( (gTimer_GSM_AT>500)&&(gInternal_Flag&TCPSEND_ALLOW_F_1) )
  2541. {
  2542. gReceive0_GSM_Buffer_Move=gReceive0_GSM_Buffer_Point;
  2543. if(gReceive0_GSM_Buffer_Point==0)  gReceive0_GSM_Buffer_End=sizeof(gReceive0_GSM_Buffer)-1;
  2544. else      gReceive0_GSM_Buffer_End=gReceive0_GSM_Buffer_Point-1;
  2546. Send_COM1_String((unsigned char *)HANG_TCP,sizeof(HANG_TCP));
  2547. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  2548. Send_COM0_String((unsigned char *)HANG_TCP,sizeof(HANG_TCP));
  2549. gTimer_GSM_AT=0;
  2550. gGPRS_Data_Step=11;
  2551. }
  2552. else Check_TCP();
  2553. }
  2554. /********************************************************
  2555. 六，数据已经送给M22，则等待延迟时间后发送
  2556. ********************************************************/
  2557. else if(gGPRS_Data_Step==10)
  2558. {
  2559. if(gTimer_GSM_AT>1500)
  2560. {
  2561. gTimer_GSM_AT=0;
  2562. gGPRS_Data_Step=0;
  2563. }
  2564. else Check_TCP();
  2565. }
  2566. /********************************************************
  2567. 十，发送+++后，等待模块响应的部分
  2568. ********************************************************/
  2569. else if(gGPRS_Data_Step==11)
  2570. {
  2571. if(Check_GSM()!=0)
  2572. {
  2573. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_OK,sizeof(String_OK)))
  2574. {
  2575. //表示TCP已经挂起,则可以进行AT指令的操作
  2576. Hang_Error=0;
  2577. gGPRS_Data_Step=0;
  2578. gM22_Status=TCP_HANG_WORK;
  2579. gGeneral_Flag&=~HANG_M22_TCP_F_1;
  2580. gGSM_Oper_Type=GSM_PHONE;
  2581. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  2582. gPhone_Step=0;gTimer_GSM_AT=0;
  2583. }
  2584. }
  2585. else
  2586. {
  2587. if(gTimer_GSM_AT>10000)
  2588. {
  2589. gTimer_GSM_AT=0;
  2590. Hang_Error++;
  2591. if(Hang_Error>4)
  2592. {
  2593. //直接掉电处理
  2594. Hang_Error=0;
  2595. gGeneral_Flag|=OFF_M22_F_1;
  2596. gOFF_Power_S=1;
  2597. gPhone_Status=READY;
  2598. gGSM_Oper_Type=GSM_PHONE;
  2599. gGPRS_Data_Step=0;
  2600. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  2601. gPhone_Step=0;
  2602. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  2603. return;
  2604. }
  2605. else
  2606. {
  2607. gGPRS_Data_Step=9;
  2608. }
  2609. }
  2610. }
  2611. }
  2612. /********************************************************
  2613. 十一，发送登陆信息后，等待登陆响应
  2614. ********************************************************/
  2615. else if(gGPRS_Data_Step==12)
  2616. {
  2617. if( (gTimer_GSM_AT>500)&&(gInternal_Flag&TCPSEND_ALLOW_F_1) )
  2618. {
  2619. i=Send_Echo_TCP_Head(12,(char)VEHICLE_ENTRY_UP,0,12-4);
  2620. Send_Echo_TCP_End(i);
  2621. gGPRS_Data_Step=10;
  2622. }
  2623. else Check_TCP();
  2624. }
  2625. }
  2626. /********************************************************
  2627. * 函数名：Case_OverTime_Return
  2628. 作用域：本地文件调用
  2629. * 功能：
  2630. * 参数：
  2631. * 返回值：
  2632. * 创建人：
  2633. *
  2634. * 修改历史：（每条详述）
  2635. ********************************************************/
  2636. void Case_OverTime_Return(void)
  2637. {
  2638. Reset_Variable();
  2639. }
  2640. /********************************************************
  2641. * 函数名：Send_Circle_GSM_TypeD
  2642. 作用域：本地文件调用
  2643. * 功能：  在GSM方式下D类发送信息数据部分的打包（定时发送的行驶数据包）
  2644. 具体是发送存储在gCircle_Buffer[]缓冲中的数据
  2645. * 参数：
  2646. * 返回值：
  2647. * 创建人：
  2648. *
  2649. * 修改历史：（每条详述）
  2650. ********************************************************/
  2651. void Send_Circle_GSM_TypeD(void)
  2652. {
  2653. unsigned int i=0;
  2654. Send_COM0_Byte(ASCII( gCircle_Buffer_Point/0x10) );
  2655. Send_COM0_Byte(ASCII( gCircle_Buffer_Point%0x10) );
  2656. for(i=0;i<gCircle_Buffer_Point;i++)
  2657. {
  2658. Send_COM0_Byte(ASCII( (gCircle_Buffer[i])/0x10) );
  2659. Send_COM0_Byte(ASCII( (gCircle_Buffer[i])%0x10) );
  2660. }
  2661. }
  2662. /********************************************************
  2663. * 函数名：Send_Circle_TCP_TypeD
  2664. 作用域：本地文件调用
  2665. * 功能：  在TCP方式下D类发送信息数据部分的打包（定时发送的行驶数据包）
  2666. 具体是发送存储在gCircle_Buffer[]缓冲中的数据
  2667. * 参数：
  2668. * 返回值：
  2669. * 创建人：
  2670. *
  2671. * 修改历史：（每条详述）
  2672. ********************************************************/
  2674. void Send_Circle_TCP_TypeD(void)
  2675. {
  2676. unsigned int i=0;
  2677. for(i=0;i<gCircle_Buffer_Point;i++)
  2678. {
  2679. Send_COM0_Byte(gCircle_Buffer[i]);
  2680. }
  2681. }
  2682. /********************************************************
  2683. * 函数名：Send_Circle_GSM_TypeE
  2684. 作用域：本地文件调用
  2685. * 功能：  在GSM方式下E类发送信息数据部分的打包(发送接收到的外接部件的数据)
  2686. 具体是发送存储在gCom4_Buffer[]缓冲中的数据
  2687. * 参数：
  2688. * 返回值：
  2689. * 创建人：
  2690. *
  2691. * 修改历史：（每条详述）
  2692. ********************************************************/
  2693. void Send_Circle_GSM_TypeE(void)
  2694. {
  2695. unsigned int i=0;
  2696. unsigned int iLength=0;
  2697. unsigned char nData=0;
  2698. SRAM_Init();
  2699. iLength = SRAM_Read(SRAM_SEND_LENGTH_H);
  2700. iLength <<= 8;
  2701. iLength += SRAM_Read(SRAM_SEND_LENGTH_L);
  2702. Send_COM0_Byte(ASCII( (iLength+13)/0x10) );
  2703. Send_COM0_Byte(ASCII( (iLength+13)%0x10) );
  2705. Send_COM0_Byte(ASCII( SOH/0x10) );
  2706. Send_COM0_Byte(ASCII( SOH%0x10) );
  2708. Send_COM0_Byte(ASCII( EXTER_EQUIPMENT_UP/0x10) );
  2709. Send_COM0_Byte(ASCII( EXTER_EQUIPMENT_UP%0x10) );
  2711. Send_COM0_Byte(ASCII( (char)(~EXTER_EQUIPMENT_UP)/0x10) );
  2712. Send_COM0_Byte(ASCII( (char)(~EXTER_EQUIPMENT_UP)%0x10) );
  2714. Send_COM0_Byte(ASCII( (iLength+13-4)/0x10) );
  2715. Send_COM0_Byte(ASCII( (iLength+13-4)%0x10) );
  2717. Send_COM0_Byte(ASCII( gSMS_ACK[RECORD_EQUIPMENT_ACK]/0x10) );
  2718. Send_COM0_Byte(ASCII( gSMS_ACK[RECORD_EQUIPMENT_ACK]%0x10) );
  2720. Send_COM0_Byte(ASCII( gKind/0x10) );
  2721. Send_COM0_Byte(ASCII( gKind%0x10) );
  2723. Send_COM0_Byte(ASCII( gGroup/0x10) );
  2724. Send_COM0_Byte(ASCII( gGroup%0x10) );
  2726. Send_COM0_Byte(ASCII( (gVID/0x100)/0x10) );
  2727. Send_COM0_Byte(ASCII( (gVID/0x100)%0x10) );
  2729. Send_COM0_Byte(ASCII( (gVID%0x100)/0x10) );
  2730. Send_COM0_Byte(ASCII( (gVID%0x100)%0x10) );
  2732. //================================
  2733. //外接部件的类型
  2734. Send_COM0_Byte(ASCII( 1/0x10) );
  2735. Send_COM0_Byte(ASCII( 1%0x10) );
  2736. //外接部件的数据内容
  2737. if( (iLength>0)&&(iLength<144) )
  2738. {
  2739. for(i=0;i<iLength;i++)
  2740. {
  2741. nData=SRAM_Read(SRAM_SEND_S+i);
  2742. Send_COM0_Byte(ASCII( nData/0x10 ) );
  2743. Send_COM0_Byte(ASCII( nData%0x10 ) );
  2744. }
  2745. }
  2746. Send_COM0_Byte(ASCII( 0/0x10) );
  2747. Send_COM0_Byte(ASCII( 0%0x10) ); //校验核H
  2749. Send_COM0_Byte(ASCII( 0/0x10) );
  2750. Send_COM0_Byte(ASCII( 0%0x10) ); //校验核L
  2752. Send_COM0_Byte(ASCII( EOT/0x10) );
  2753. Send_COM0_Byte(ASCII( EOT%0x10) );
  2754. }
  2756. /********************************************************
  2757. * 函数名：Send_Circle_TCP_TypeE
  2758. 作用域：本地文件调用
  2759. * 功能：  在TCP方式下E类发送信息数据部分的打包(发送接收到的外接部件的数据)
  2760. 具体是发送存储在gCom4_Buffer[]缓冲中的数据
  2761. * 参数：
  2762. * 返回值：
  2763. * 创建人：
  2764. *
  2765. * 修改历史：（每条详述）
  2766. ********************************************************/
  2768. void Send_Circle_TCP_TypeE(void)
  2769. {
  2770.    unsigned int i=0,j=0;
  2771.    unsigned int iLength=0;
  2772.    unsigned int Length_Temp=0;
  2773.    unsigned char nData_Temp=0;
  2774. j=0;
  2775. //读数据区的长度
  2776. SRAM_Init();
  2777. iLength = SRAM_Read(SRAM_SEND_LENGTH_H);
  2778. iLength <<= 8;
  2779. iLength += SRAM_Read(SRAM_SEND_LENGTH_L);
  2780. //如果发送数据的长度超过M22一次TCP发送的长度，则需要多次组包发送
  2781. if(iLength>=MAX_TCP_DATA_LENGHT)
  2782. {
  2783. Length_Temp=iLength-MAX_TCP_DATA_LENGHT;
  2784. iLength=MAX_TCP_DATA_LENGHT;
  2785. if(Length_Temp>0) j=1;
  2786. //j=1，说明存储的数据长度超过M22能一次发送的数据长度
  2787. }
  2788. Send_COM0_Byte( SOH );
  2789. Send_COM0_Byte( EXTER_EQUIPMENT_UP );
  2790. Send_COM0_Byte( (char)(~EXTER_EQUIPMENT_UP) );
  2791. Send_COM0_Byte( iLength+9 );
  2792. Send_COM0_Byte( gSMS_ACK[RECORD_EQUIPMENT_ACK] );
  2794. Send_COM0_Byte( gKind );
  2795. Send_COM0_Byte( gGroup );
  2796. Send_COM0_Byte( gVID/0x100 );
  2797. Send_COM0_Byte( gVID%0x100 );
  2798. Send_COM0_Byte( 1 );
  2799. //================================
  2800. for( i=0;i<iLength;i++ )
  2801. {
  2802. Send_COM0_Byte( SRAM_Read(SRAM_SEND_S+i) );
  2803. }
  2804. Send_COM0_Byte( 0 );
  2805. Send_COM0_Byte( 0 );
  2806. Send_COM0_Byte( EOT );
  2807. if(j==1)
  2808. {
  2809. SRAM_Init();
  2810. SRAM_Write(SRAM_SEND_VAILD,VAILD_2);
  2811. SRAM_Write(SRAM_SEND_LENGTH_H,Length_Temp/0x100);
  2812. SRAM_Write(SRAM_SEND_LENGTH_L,Length_Temp%0x100);
  2813. for(i=0;i<Length_Temp;i++)
  2814. {
  2815. nData_Temp=SRAM_Read(SRAM_SEND_S+iLength+i);
  2816. SRAM_Write((SRAM_SEND_S+i),nData_Temp);
  2817. }
  2818. gSend_RecordData_Timer=0;
  2819. gOther_Flag|=RECORD_DATA_F_1;
  2820. gOther_Flag&=~ALLOW_SEND_RECORD_F_1;
  2821. }
  2822. else
  2823. {
  2824. gOther_Flag&=~RECORD_DATA_F_1;
  2825. gOther_Flag&=~ALLOW_SEND_RECORD_F_1;
  2826. SRAM_Init();
  2827. SRAM_Write(SRAM_SEND_VAILD,NULL_2);
  2828. SRAM_Write(SRAM_SEND_LENGTH_H,0);
  2829. SRAM_Write(SRAM_SEND_LENGTH_L,0);
  2830. }
  2831. }
  2832. /********************************************************
  2833. * 函数名：Send_Type1_GSM_Data_One
  2834. 作用域：本地文件调用
  2835. * 功能：
  2836. * 参数：
  2837. * 返回值：
  2838. * 创建人：
  2839. *
  2840. * 修改历史：（每条详述）
  2841. ********************************************************/
  2842. void Send_Type1_GSM_Data_One(unsigned char S_Address)
  2843. {
  2844. unsigned char nLength=0;
  2845. SRAM_Init();
  2846. nLength=SRAM_Read(TARGET_NUMBER1_2); //目标电话号码的长度
  2847. nLength=(nLength+1)/2+8+12+SRAM_Read(S_Address+3); //整个数据区的长度
  2848. Ask_SMS_Send(nLength); //发送AT指令AT+CMGS=(SMS长度)
  2849. }
  2850. /********************************************************
  2851. * 函数名：Send_Type1_GSM_Data_Two
  2852. 作用域：本地文件调用
  2853. * 功能：
  2854. * 参数：
  2855. * 返回值：
  2856. * 创建人：
  2857. *
  2858. * 修改历史：（每条详述）
  2859. ********************************************************/
  2860. void Send_Type1_GSM_Data_Two(unsigned char S_Address)
  2861. {
  2862. unsigned int i,j,k,x,y;
  2863. SRAM_Init();
  2864. Send_SMS_Head(); //这个操作发送完000400
  2865. i=SRAM_Read(S_Address+1); //nCommand，命令字
  2866. j=SRAM_Read(S_Address+2); //ACK
  2867. k=SRAM_Read(S_Address+3); //长度
  2868. OperateSPIEnd();
  2869. x=Send_Echo_GSM_Head( (char)(k+12),(char)i,(char)j,(char)(k+12-4) );//同时计算校验核
  2870. y=Send_Buffer1_GSM_Data(x,S_Address+4,k);
  2871. Send_Echo_GSM_End(y); //这个操作完成校验核和结束符号的发送
  2872. Send_COM0_Byte(0x1A);
  2873. OperateSPIEnd();
  2874. }