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

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

GPS编程

开发平台：

Others

check_gsm.c：源码内容
  2. /********************************************************
  3. * 文件名：  Check_GSM.C
  4. * 创建时间：2004年12月7日
  5. * 创建人：  
  6. * 版本号：  1.00
  7. * 功能：
  8. * 文件属性：特殊文件
  9. * 修改历史：（每条详述）
  10. ********************************************************/
  11. #include <msp430x14x.h>
  12. #include "Uart01.h"
  13. #include "General.h"
  14. #include "Define_Bit.h"
  15. #include "Sub_C.h"
  16. #include "M22_AT.h"
  17. #include "Check_GSM.h"
  18. #include "W_Protocol.h"
  19. #include "SPI45DB041.h"
  20. #include "D_Buffer.h"
  21. #include "Other_Define.h"
  22. #include "TA_Uart.h"
  23. #include "Handle_Protocol.h"
  24. #include "Disp_Protocol.h"
  25. #include "Do_Handle.h"
  26. #include "Do_SRAM.h"
  27. /*
  28. #include "Main_Init.h"
  29. #include "Do_Reset.h"
  30. #include "Do_GSM.h"
  31. #include "Msp430_Flash.h"
  32. */
  33. #define Debug_GSM_COM1
  34. void Do_SMS_Receive(unsigned int iLength,unsigned char iRLength);
  35. void Do_GPRS_Receive(void);
  36. void Deal_Command(void);
  37. unsigned char Check_Command(void);
  38. void IP_SOCKET_Switch(void);
  39. void Do_Parameter_Set(void);
  40. void Position_Echo(void);
  41. void Pass_Data_Echo(void);
  42. void Set_Cycle_Timer(void);
  43. void Disp_Dispaly_Info(void);
  44. void Set_TCP_OnOrOff(void);
  45. void Query_SYS_Ver(void);
  46. void Deal_Alarm_Echo(void);
  47. void Deal_Vehicle_Monitor(void);
  49. void Set_Phone_Limit(void);
  51. void Set_Area_Limit(void);
  52. void Send_RecordData(void);
  53. void Set_Distance_Par(void);
  54. void Set_Phone_Num(void);
  55. void Watch_Way(void);
  56. void Line_Data_Deal(void);
  57. //unsigned char Do_Deal_Area(unsigned char Add_Flash,unsigned char Add_Buffer );
  59. /********************************************************
  60. * 函数名：Check_GSM
  61. 作用域：外部文件调用
  62. * 功能： 判断处理GSM接收缓冲gReceive0_GSM_Buffer中的数据，如果判断有0x0d,0x0a表示有
  63. 一包GSM数据返回。将这一包数据转移到处理缓冲gGeneral_Buffer中进行处理
  65. * 参数：  全局变量：GSM的接收缓冲gReceive0_GSM_Buffer[]，指针gReceive0_GSM_Buffer_Move
  66.   gReceive0_GSM_Buffer_Point。
  67.   数据处理缓冲gGeneral_Buffer[]
  69. * 返回值：0：表示对GSM数据接收缓冲未做任何处理
  70. 1：表示转移一包数据，并处理完成
  71. 其中在返回的过程中，有写特殊的出口处理，需要对一些全局变量进行操作。具体见具体详细描叙
  73. * 创建人：
  74. *
  75. * 修改历史：（每条详述）
  76. ********************************************************/
  77. unsigned int Check_GSM(void)
  78. {
  79. unsigned int i,j,k;
  80. for(k=0;k<sizeof(gGeneral_Buffer);k++) gGeneral_Buffer[k]=0;
  81. i = 0;
  82. j = gReceive0_GSM_Buffer_Move;
  83. if( gReceive0_GSM_Buffer_Point == gReceive0_GSM_Buffer_Move ) return(0);
  84. gGeneral_Buffer[i] = gReceive0_GSM_Buffer[j];
  85. i++;j++;
  86. if( j >= sizeof(gReceive0_GSM_Buffer) ) j=0;
  87. while(j!=gReceive0_GSM_Buffer_Point)
  88. {
  89. gGeneral_Buffer[i] = gReceive0_GSM_Buffer[j];
  90. i++;j++;
  91. if( i >= sizeof(gGeneral_Buffer) )
  92. {
  93. // Send_COM1_String((unsigned char *)R_OVERTOP,sizeof(R_OVERTOP));
  94. for(i=0;i<sizeof(gGeneral_Buffer);i++)    gGeneral_Buffer[i]=0;
  95. for(i=0;i<sizeof(gReceive0_GSM_Buffer);i++) gReceive0_GSM_Buffer[i]=0;
  96. gReceive0_GSM_Buffer_End=sizeof(gReceive0_GSM_Buffer)-1;
  97. gReceive0_GSM_Buffer_Point=0;
  98. gReceive0_GSM_Buffer_Move=0;
  99. return(0);
  100. }
  101. if( j >= sizeof(gReceive0_GSM_Buffer) )   j=0;
  103. /********************************************************
  104. ********************************************************/
  105. //判断有发送SMS的符号+++++++++++++++++++++++++++++++++++
  106. if( (gGeneral_Buffer[i-1]==' ')&&(gGeneral_Buffer[i-2]=='>') )
  107. {
  108. #ifdef Debug_GSM_COM1
  109. Send_COM1_String(gGeneral_Buffer,i);
  110. #endif
  111. gReceive0_GSM_Buffer_Move=j; //表示一包有效帧数据处理完
  112. if(j==0) gReceive0_GSM_Buffer_End=sizeof(gReceive0_GSM_Buffer)-1;
  113. else     gReceive0_GSM_Buffer_End=j-1;
  114. return(1);
  115. }
  116. //判断有一包有效帧数据++++++++++++++++++++++++++++++++++++
  117. else if( (gGeneral_Buffer[i-1]==0x0a)&&(gGeneral_Buffer[i-2]==0x0d) )
  118. {
  119. #ifdef Debug_GSM_COM1
  120. Send_COM1_String(gGeneral_Buffer,i);
  121. #endif
  122. gReceive0_GSM_Buffer_Move=j; //表示一包有效帧数据处理完
  123. if(j==0) gReceive0_GSM_Buffer_End=sizeof(gReceive0_GSM_Buffer)-1;
  124. else     gReceive0_GSM_Buffer_End=j-1;
  126. //*下面则是一个返回数据包在缓冲General_Buffer[]中,数据包的长度为i
  127. /********************************************************
  128. 1,判断是否有电话打入方面的处理：
  129. RING
  131. +CLIP: "13670155704",129,,,,0
  133. +CLIP: "13670155704",129,,,,0
  134. ********************************************************/
  135. //***************************************************************************
  136. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_RING,sizeof(String_RING))!=0)
  137. {
  138. return(0);
  139. }
  140. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_CLIP,sizeof(String_CLIP))!=0)
  141. {
  142. if(   ((gGeneral_Flag&RESET_GSM_ON_F_1)==0 )
  143. &&((gGeneral_Flag&LAND_TCP_F_1)==0)
  144. &&((gInternal_Flag&GSM_ONEAT_SUCCESS_1)==0)   )
  145. {
  146. if((gGeneral_Flag&RING_F_1)==0) gHangUp_Timer=0;
  147. gGeneral_Flag|=TCP_PHONE_F_1;
  148. gStatus1_Flag|=PHONE_ONLINE_F_1;
  149. gGeneral_Flag|=RING_F_1;
  150. return(1);
  151. }
  152. else return(0);
  153. }
  154. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_BUSY,sizeof(String_BUSY))!=0)
  155. {
  156. return(1);
  157. }
  158. /********************************************************
  159. 2,判断是否有AT打头的属于AT指令的返回方面的处理或者空行
  160.   比方说AT指令的回显字符，或者0x0d,0x0a
  161. ********************************************************/
  162. if(Compare_String(gGeneral_Buffer,(unsigned char *)String_AT,sizeof(String_AT))!=0)
  163. {
  164. return(0);
  165. }
  166. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_END,sizeof(String_END))!=0)
  167. {
  168. return(0);
  169. }
  170. /********************************************************
  171. 3,判断是否有NO CARRIER 返回的处理
  172. ********************************************************/
  173. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_NOCARRIER,sizeof(String_NOCARRIER))!=0)
  174. {
  175. if( (gM22_Status==TCP_HANG_WORK) )
  176. {
  177. if( (gGeneral_Flag&TCP_PHONE_F_1)==0 )
  178. {
  179. gM22_Status=GSM_WORK;
  180. gGSM_Oper_Type=GSM_PHONE;
  181. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  182. gPhone_Step=0;gTimer_GSM_AT=0;
  183. }
  184. else
  185. {
  186. if(gPhone_Status==ACTIVE_MONITOR)
  187. {
  188. //监听结束
  189. gPhone_Status=READY;
  190. gGeneral_Flag&=~TCP_PHONE_F_1;
  191. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  192. gGeneral_Flag|=MONITOR_RESUME_F_1;
  193. P6OUT&=~SEL_MIC;
  194. gGeneral_Flag|=TCP_STATUS_F_1;
  195. }
  196. else if( (gPhone_Status==ACTIVE_HANDLE)||(gGeneral_Flag&RING_F_1) )
  197.   {
  198. //手柄通话结束
  199. gPhone_Status=READY;
  200. gGeneral_Flag&=~RING_F_1;
  201. gGeneral_Flag&=~TCP_PHONE_F_1;
  202. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  203. //发送一个挂机信号给手柄
  204.     Send_COM3_Load(4,MAIN_HANG_UP,0);
  205. gSys_Handle=MAIN_HANG_UP;
  206. gGeneral_Flag|=TCP_STATUS_F_1;
  207. }
  208. gGeneral_Flag&=~DAILING_UP_F_1;
  209. gGeneral_Flag&=~MONITOR_ON_F_1;
  210. gPhone_Status=READY;
  211. gGeneral_Flag&=~TCP_PHONE_F_1;
  212. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  213. gGeneral_Flag&=~RING_F_1;
  214. gGeneral_Flag|=TCP_STATUS_F_1;
  215. gCommon_Flag&=~CHECK_RINGPHONE_F_1;
  216. }
  217. }
  218. else if(gM22_Status==GSM_WORK)
  219. {
  220. if(gPhone_Status==ACTIVE_MONITOR)
  221. {
  222. //监听结束
  223. gPhone_Status=READY;
  224. gGeneral_Flag&=~TCP_PHONE_F_1;
  225. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  226. }
  227. else if( (gPhone_Status==ACTIVE_HANDLE)||(gGeneral_Flag&RING_F_1) )
  228. {
  229. //手柄通话结束
  230. gPhone_Status=READY;
  231. gGeneral_Flag&=~RING_F_1;
  232. gGeneral_Flag&=~TCP_PHONE_F_1;
  233. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  234.         Send_COM3_Load(4,MAIN_HANG_UP,0);
  235.         gSys_Handle=MAIN_HANG_UP;
  237. //发送一个挂机信号给手柄
  238. }
  239. gGeneral_Flag&=~DAILING_UP_F_1;
  240. gGeneral_Flag&=~MONITOR_ON_F_1;
  241. gPhone_Status=READY;
  242. gGeneral_Flag&=~TCP_PHONE_F_1;
  243. gStatus1_Flag&=~PHONE_ONLINE_F_1;
  244. gGeneral_Flag&=~RING_F_1;
  245. gGeneral_Flag|=MONITOR_RESUME_F_1;
  246. gCommon_Flag&=~CHECK_RINGPHONE_F_1;
  247. }
  248. return(1);
  249. }
  250. /********************************************************
  251. 4,判断是否有+CMT: 返回的处理(属于中断接收SMS的信息处理)
  252. +CMT: ,032
  253. 0891683108705505F0040D91683128782840F90004503011613495000CFF000000000000000000001B
  254. ********************************************************/
  255. else if(Compare_String(gGeneral_Buffer,(unsigned char *)String_CMT,sizeof(String_CMT))!=0)
  256. {
  257.         gSMS_In_Lenth=0;
  258.         j=4;k=0;
  259.         while(1)
  260.         {
  261.          if(gGeneral_Buffer[j]==',') {k=1;break;}
  262.          j++;
  263.          if(j>i) break;
  264.         }
  265.         if(k==1)
  266.         {
  267.          for(k=0;k<3;k++)
  268.          {
  269. gSMS_In_Lenth*=10;
  270. gSMS_In_Lenth=gSMS_In_Lenth+(gGeneral_Buffer[k+j+1]-0x30);
  271.          }
  272. gInternal_Flag|=RECEIVE_SMS_F_1;
  273.         }
  274. return(0);
  275. }
  276. else if(gInternal_Flag&RECEIVE_SMS_F_1)
  277. {
  278. gInternal_Flag&=~RECEIVE_SMS_F_1;
  279. Do_SMS_Receive(i,gSMS_In_Lenth);
  280. return(0);
  281. }
  282. /********************************************************
  283. 5,其他
  284. ********************************************************/
  285. return(1);
  286. }//end else if( (gGeneral_Buffer[i-1]==0x0a)&&(gGeneral_Buffer[i-2]==0x0d) )
  287. }//end while
  288. return(0);
  289. }
  290. /********************************************************
  291. * 函数名：Check_TCP
  292. 作用域：外部文件调用
  293. * 功能：
  295. * 参数：  全局变量：GSM的接收缓冲gReceive0_GSM_Buffer[]，指针gReceive0_GSM_Buffer_Move
  296.   gReceive0_GSM_Buffer_Point。
  297.   数据处理缓冲gGeneral_Buffer[]
  299. * 返回值：0：表示对GSM数据接收缓冲未做任何处理
  300. 1：表示转移一包数据，并处理完成
  301. 其中在返回的过程中，有写特殊的出口处理，需要对一些全局变量进行操作。具体见具体详细描叙
  303. * 创建人：
  304. *
  305. * 修改历史：（每条详述）
  306. 补充说明：
  307. ********************************************************/
  308. unsigned int Check_TCP(void)
  309. {
  310. unsigned int i,j,k,x;
  311. unsigned char nLength;
  312. unsigned char nFlag;
  313. nLength=0;
  314. //已经100ms，未接收到M22的数据，则可以判断接收缓冲区中的数据
  315. if(gM22_TCP_ECHO_Timer>60)
  316. {
  317. nFlag=0;
  318. for(k=0;k<sizeof(gGeneral_Buffer);k++) gGeneral_Buffer[k]=0;
  319. i = 0;
  320. j = gReceive0_GSM_Buffer_Move;
  321. if( gReceive0_GSM_Buffer_Point == gReceive0_GSM_Buffer_Move ) return(0);
  322. gGeneral_Buffer[i] = gReceive0_GSM_Buffer[j];
  323. i++;j++;
  324. if( j >= sizeof(gReceive0_GSM_Buffer) ) j=0;
  325. while(j!=gReceive0_GSM_Buffer_Point)
  326. {
  327. gGeneral_Buffer[i] = gReceive0_GSM_Buffer[j];
  328. i++;j++;
  329. if( i >= sizeof(gGeneral_Buffer) )
  330. {
  331. // Send_COM1_String((unsigned char *)R_OVERTOP,sizeof(R_OVERTOP));
  332. for(i=0;i<sizeof(gGeneral_Buffer);i++)    gGeneral_Buffer[i]=0;
  333. for(i=0;i<sizeof(gReceive0_GSM_Buffer);i++) gReceive0_GSM_Buffer[i]=0;
  334. gReceive0_GSM_Buffer_End=sizeof(gReceive0_GSM_Buffer)-1;
  335. gReceive0_GSM_Buffer_Point=0;
  336. gReceive0_GSM_Buffer_Move=0;
  337. return(0);
  338. }
  339. if( j >= sizeof(gReceive0_GSM_Buffer) )   j=0;
  340. //如果能执行到这里，则已经将接收缓冲的数据转移到gGeneral_Buffer缓冲中。
  341. for(k=0;k<i;k++)
  342. {
  343. //判断是否为下行的命令数据包
  344. //例：FF 4F 0B 08 00 01 01 00 08 02 10 0D
  345. if( (gGeneral_Buffer[k]==SOH) //判断包头
  346. &&(gGeneral_Buffer[gGeneral_Buffer[k+3]+3]==EOT) //判断包尾
  347. &&(gGeneral_Buffer[k+1]==(char)(~gGeneral_Buffer[k+2])) ) //判断命令字是否取反
  348. {
  349. // Send_COM1_String((unsigned char *)TCP_COMMAAND,sizeof(TCP_COMMAAND));
  350. nLength=gGeneral_Buffer[k+3]+3+1; //分析有效数据包长度
  351. j = gReceive0_GSM_Buffer_Move;
  352. for(x=0;x<nLength+k;x++)
  353. {
  354. j++;
  355. if( j >= sizeof(gReceive0_GSM_Buffer) ) j=0;
  356. }
  357. gReceive0_GSM_Buffer_Move=j; //移动处理处理缓冲区指针
  358. if(j==0) gReceive0_GSM_Buffer_End=sizeof(gReceive0_GSM_Buffer)-1;
  359. else     gReceive0_GSM_Buffer_End=j-1;
  360. //处理适合Do_GPRS_Receive()处理的gGeneral_Buffer缓冲数据安排
  361. if(k==0)
  362. {
  363. for(x=nLength;x>=1;x--)
  364. {
  365. gGeneral_Buffer[x]=gGeneral_Buffer[x-1];
  366. }
  367. gGeneral_Buffer[0]=nLength;
  368. }
  369. else if(k>0)
  370. {
  371. gGeneral_Buffer[k-1]=nLength;
  372. for(x=0;x<=nLength;x++)
  373. {
  374. gGeneral_Buffer[x]=gGeneral_Buffer[k-1+x];
  375. }
  376. }
  377. gGeneral_Flag|=LAND_TCP_SUCCESS_F_1;
  378. Do_GPRS_Receive();
  379. nFlag=1;
  380. break;
  381. }
  382. //判断是否为FF 0D的握手数据
  383. else if( (gGeneral_Buffer[0]==0xFF)&&(gGeneral_Buffer[0+1]==0x0D) )
  384. {
  385. gGeneral_Flag|=LAND_TCP_SUCCESS_F_1;
  386. gLand_Interval_Timer=0;
  387. if(gFF0D_Receive_Timer<=2)
  388. {
  389. for(i=0;i<sizeof(gGeneral_Buffer);i++)    gGeneral_Buffer[i]=0;
  390. for(i=0;i<sizeof(gReceive0_GSM_Buffer);i++) gReceive0_GSM_Buffer[i]=0;
  391. gReceive0_GSM_Buffer_End=sizeof(gReceive0_GSM_Buffer)-1;
  392. gReceive0_GSM_Buffer_Point=0;
  393. gReceive0_GSM_Buffer_Move=0;
  394. return(0);
  395. }
  396. else
  397. {
  398. Send_COM1_String((unsigned char *)TCP_TEST,sizeof(TCP_TEST));
  399. j = gReceive0_GSM_Buffer_Move;
  400. for(x=0;x<2;x++)
  401. {
  402. j++;
  403. if( j >= sizeof(gReceive0_GSM_Buffer) ) j=0;
  404. }
  405. gReceive0_GSM_Buffer_Move=j; //移动处理处理缓冲区指针
  406. if(j==0) gReceive0_GSM_Buffer_End=sizeof(gReceive0_GSM_Buffer)-1;
  407. else     gReceive0_GSM_Buffer_End=j-1;
  408. gFF0D_Receive_Timer=0;
  409. nFlag=1;
  410. }
  411. break;
  412. }
  413. //判断是否出现TCP掉线信息
  414. //0D 0A 4F 4B 0D 0A 0D 0A 43 4F 4E 4E 45 43 54 0D 0A 0D 0A 4F
  415. //4B 0D 0A 0D 0A 4F 4B 0D 0A 0D 0A 4E 4F 20 43 41 52 52 49 45 52 0D 0A
  416. else if( (gGeneral_Buffer[k]==0x4E)
  417.  &&(gGeneral_Buffer[k+1]==0x4F)
  418.  &&(gGeneral_Buffer[k+2]==0x20)
  419.  &&(gGeneral_Buffer[k+3]==0x43)
  420.  &&(gGeneral_Buffer[k+4]==0x41)
  421.  &&(gGeneral_Buffer[k+5]==0x52)
  422.  &&(gGeneral_Buffer[k+6]==0x52)
  423.  &&(gGeneral_Buffer[k+7]==0x49)
  424.  &&(gGeneral_Buffer[k+8]==0x45)
  425.  &&(gGeneral_Buffer[k+9]==0x52)
  426.  &&(gGeneral_Buffer[k+10]==0x0D)
  427.  &&(gGeneral_Buffer[k+11]==0x0A) )
  428.   {
  429.   //如果满足条件，说明已经TCP断线
  430.   Send_COM1_String((unsigned char *)TCP_QUIT,sizeof(TCP_QUIT));
  431. gGeneral_Flag&=~LAND_TCP_SUCCESS_F_1;
  432. gGSM_Oper_Type=GSM_PHONE;
  433. gM22_Status=GSM_WORK;
  434. gReceive0_GSM_Buffer_Move=gReceive0_GSM_Buffer_Point;
  435. if(gReceive0_GSM_Buffer_Point==0)  gReceive0_GSM_Buffer_End=sizeof(gReceive0_GSM_Buffer)-1;
  436. else      gReceive0_GSM_Buffer_End=gReceive0_GSM_Buffer_Point-1;
  437. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  438. gPhone_Step=0;gTimer_GSM_AT=0;
  439.   break;
  440.   }
  441. }//for(k=0;k<i;k++)
  442. }//end while(j!=gReceive0_GSM_Buffer_Point)
  443. }//end gM22_GSM_ECHO_Timer>100
  444. return(0);
  445. }
  446. /********************************************************
  447. * 函数名：Do_SMS_Receive
  448. 作用域：本文件调用
  449. * 功能：  在G20中用AT+CMGR指令读取出SMS的内容，接收并处理
  451. * 参数：  iLength  作为接收整个数据的长度，如下的例子此数据为64
  452.          iRLength 作为AT+CMGR读出返回SMS的长度为32
  453.          全局变量缓冲gGeneral_Buffer
  455. * 返回值：这个模块是将返回数据区的值变换后存储在全局变量gGeneral_Buffer中，并调用
  456. Deal_Command()模块处理数据
  457. * 创建人：
  458. *
  459. * 修改历史：（每条详述）
  460. //////////////////////////////////////////////////////////
  462. AT+CMGR=1
  463. +CMGR: 0,,24
  464. 08                   0D
  465. 0891683108705505F004 0D91683176105507F4 0008 40 0111900093000462 C94E01 (0D 0A)
  466. ----------20-------- ---------20--------- ------20------------ -----8-------
  467. 0891683108705505F0 04 0D91683128782840F9 0004 40 01 03 41 34 5400 0C FF4FB00800302E303002C40D
  469. i=HEX(GSM_Echo_Buffer[0],GSM_Echo_Buffer[1]); 读出值为08
  470. j=(i+2)*2;  20个  (0D的第一个地址)
  471. i=HEX(GSM_Echo_Buffer[j],GSM_Echo_Buffer[j+1]); 读出值为0D
  472. j=j+(i+1)/2*2+22; (02的第一个地址)
  473. i=HEX(GSM_Echo_Buffer[j],GSM_Echo_Buffer[j+1]); 读出值为0C,后面的为数据包的内容
  474. j++;
  475. j++;
  479. +CMT: ,032
  480. 0891683108705505F0040D91683128782840F90004503011613495000CFF000000000000000000001B
  481. ********************************************************/
  482. void Do_SMS_Receive(unsigned int iLength,unsigned char iRLength)
  483. {
  484. unsigned int i,j,k;
  485. unsigned int m,n;
  486. unsigned char y;
  487. //判断SMS的长度与接收的数据是否符合,整个数据包是否收全。iLength为收到的数据包长
  488. //如上例中iRLength=24,iLength=68
  489. if(ASCIITOHEX(gGeneral_Buffer[0],gGeneral_Buffer[1])+iRLength+2==iLength/2)
  490. {
  491. //将内容提取出来仍然存储在General_Buffer[]缓冲中
  492.     i=ASCIITOHEX(gGeneral_Buffer[0],gGeneral_Buffer[1]);
  493.     j=(i+2)*2;
  494.     i=ASCIITOHEX(gGeneral_Buffer[j],gGeneral_Buffer[j+1]);
  496.     //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  497.     for(m=0;m<sizeof(gNum_Phone_Temp);m++) gNum_Phone_Temp[m]=0;
  498.     m=j; //20
  499.     n=m+(i+1)/2*2+3; //37
  500.     y=0;
  501. gNum_Phone_Temp[y]=0;
  502. y++;
  503. if(gGeneral_Buffer[2]=='9')
  504. {
  505. gNum_Phone_Temp[y]='+';
  506. y++;
  507. }
  508. m=j+4;
  509. while(1)
  510. {
  511. if(m<n)
  512. {
  513. gNum_Phone_Temp[y]=gGeneral_Buffer[m+1];
  514. y++;
  515. gNum_Phone_Temp[y]=gGeneral_Buffer[m];
  516. y++;
  517. m++;m++;
  518. }
  519. else if(m==n)
  520. {
  521. gNum_Phone_Temp[y]=gGeneral_Buffer[m];
  522. y++;
  523. m++;
  524. }
  525. else break;
  526. }
  527. for(m=2;m<y;m++)
  528. {
  529. if( (gNum_Phone_Temp[m]>'9')||(gNum_Phone_Temp[m]<'0') )
  530. break;
  531. }
  532. gNum_Phone_Temp[0]=m-1;
  533. if(gNum_Phone_Temp[0]>14) gNum_Phone_Temp[0]=0;
  534. /*
  535. //显示出当前的号码存储的是否正确
  536.     Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  537. Send_COM1_Byte(ASCII(gNum_Phone_Temp[0]/10));
  538. Send_COM1_Byte(ASCII(gNum_Phone_Temp[0]%10));
  539. Send_COM1_Byte('<');
  540. for(m=1;m<=gNum_Phone_Temp[0];m++)
  541. {
  542. Send_COM1_Byte(gNum_Phone_Temp[m]);
  543. }
  544. Send_COM1_Byte('>');
  545. Send_COM1_Byte(0x0d); Send_COM1_Byte(0x0a);
  546. */
  547. //现在在缓冲gNum_Phone_Temp[]中存储的是这个的信息的来源号码
  548.     //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  549.     j=j+(i+1)/2*2+22;
  550.     i=ASCIITOHEX(gGeneral_Buffer[j],gGeneral_Buffer[j+1]);//表示数据区数据的长度
  551.     //这个时候，j所指向的是数据区的第一个字节，开始转移
  552.     //存储整个数据区的长度，不包括记录长度的第一个字节
  553.     gGeneral_Buffer[0]=i;
  554. for(k=1;k<=i;k++)
  555. {
  556. gGeneral_Buffer[k]=ASCIITOHEX(gGeneral_Buffer[j+2*k],gGeneral_Buffer[j+2*k+1]);
  557. }
  558. Deal_Command();
  559. }
  560. }
  561. /********************************************************
  562. * 函数名：Do_GPRS_Receive
  563. 作用域：本文件调用
  564. * 功能：
  565. * 参数：  全局变量缓冲gGeneral_Buffer
  567. * 返回值：
  568. * 创建人：
  569. *
  570. * 修改历史：（每条详述）
  571. ********************************************************/
  572. void Do_GPRS_Receive(void)
  573. {
  574. Deal_Command();
  575. }
  576. /********************************************************
  577. * 函数名：Deal_Command
  578. 作用域：本文件调用
  579. * 功能： 通过掉用Check_Command模块，进行下行协议的分析，根据不同的协议命令，
  580. 在这个模块中进行相应的处理和操作，具体见每个不同命令的详细描述
  581. * 参数：  全局变量缓冲gGeneral_Buffer[]
  583. * 返回值：根据不同，需要对一些全局变量重新进行附值操作（详细见不同命令的处理方式）
  584. * 创建人：
  585. *
  586. * 修改历史：（每条详述）
  587.     详细说明：
  588. Deal_Command()；模块程序说明:已经通过程序知道了命令字，则需要进行针对不
  589. 同的命令字进行相应的操作
  590. 说明：不管是从GSM还是GPRS接收来的数据最后在运行这个子程序的时候，General_Buffer
  591. 缓冲中存储数据包的格式是一样的，举例：
  592. 0891683108705505F004 0D91683176105507F400 0840907271356100 02 00 41 (0x0d 0x0a)
  593. 08                   0D                                    02
  594. 这是从GSM接收到的数据，最后处理完成的结果General_Buffer缓冲中存储的结果为
  595. gGeneral_Buffer[0]=2   （长度）
  596. gGeneral_Buffer[1]=0
  597. gGeneral_Buffer[2]=41
  598. 同样道理GPRS接收的数据
  599. +MIPRTCP: 1,0,0041
  600. gGeneral_Buffer[0]=2   （长度）
  601. gGeneral_Buffer[1]=0
  602. gGeneral_Buffer[2]=41
  603. ********************************************************/
  604. void Deal_Command(void)
  605. {
  606. unsigned char nCmd;
  607. unsigned char nSpeed=0;
  608. // Send_COM1_Byte('S');
  609. #ifdef Debug_GSM_COM1
  610. Send_COM1_Byte(ASCII(gGeneral_Buffer[0]/16));
  611. Send_COM1_Byte(ASCII(gGeneral_Buffer[0]%16));
  612. Send_COM1_Byte('[');
  613. for(nCmd=1;nCmd<=gGeneral_Buffer[0];nCmd++)
  614. {
  615. if(nCmd==0) break;
  616. Send_COM1_Byte(ASCII(gGeneral_Buffer[nCmd]/16));
  617. Send_COM1_Byte(ASCII(gGeneral_Buffer[nCmd]%16));
  618. Clear_Exter_WatchDog();
  619. }
  620. Send_COM1_Byte(']');
  621. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  622. #endif
  624. nCmd=Check_Command();
  625. //补充说明：根据以前的兼容，则如果在上行的信息中，如果带有经度，纬度的上行数据，则在后面增加4个状态量的字节
  626. switch(nCmd)
  627. {//内容由开发者自己加入
  628. //1，车辆登陆响应(不加状态位)
  629. case VEHICLE_ENTRY_ECHO_DOWN:
  630. {
  631. break;
  632. }
  633. //2，车辆参数设置(不加状态位)
  634. case PARAMETER_SET_DOWN:
  635. {
  636. break;
  637. }
  638. //3，设置上传位置时间间隔 (不加状态位，从新写)
  639. case TIME_INTERVAL_DOWN:
  640. {
  641. break;
  642. }
  643. //4，设置服务器地址，端口 (不加状态位)
  644. case SET_ADDRESS_PORT_DOWN:
  645. {
  646.         break;
  647. }
  648. //5，车辆定位查询 ( 加状态位 )
  649. case  POSITION_ASK_DOWN:
  650. {
  651. break;
  652. }
  653. //6，报警应答(不加状态位)
  654. case ALARM_ECHO_DOWN:
  655. {
  656. break;
  657. }
  658. //7，车辆监听(不加状态位)
  659. case VEHICLE_MONITOR_DOWN:
  660. {
  661. break;
  662. }
  663. //8，外接部件的相关命令(不加状态位)
  664. case EXTER_EQUIPMENT_DOWN:
  665. {
  666. break;
  667. }
  668. //9-0,和显示终端相关的相关的命令(文字信息的处理)(不加状态位)
  669. case WORD_INFORMATION_DOWN:
  670. {
  671. break;
  672. }
  673. //9-1，下载动态菜单
  674. case SET_MENU_DOWN:
  675. {
  676. break;
  677. }
  678. //9-2,下载设定短消息的下行命令
  679. case SET_SMS_COMMAND_DOWN:
  680. {
  681. break;
  682. }
  683. //10,出城登记响应(不加状态位)
  684. case OUTCITY_ECHO_DOWN:
  685. {
  686. break;
  687. }
  688. //11,历史轨迹查询的下行命令(不加状态位),
  689. case TRACK_ASK_DOWN:
  690. {
  691. break;
  692. }
  693. //12,接收下行的设置终端进入/退出状态的命令 (不加状态位)从新写
  694. case SET_TCP_ONOROFF_DOWN:
  695. {
  696. break;
  697. }
  698. //13,车载终端的版本查询 (不加状态位)
  699. case QUERY_VERSION_DOWN:
  700. {
  701. break;
  702. }
  703. //14，车辆允许退出TCP登陆的响应(不加状态位)
  704. case ALLOW_TCP_QUIT_ECHO_DOWN:
  705. {
  706. break;
  707. }
  708. //15,中心提取解除设防密码的下行命令(不加状态位)
  709. case PASSWORD_ASK_DOWN:
  710. {
  711. break;
  712. }
  713. //16，中心强制设防或者解除设防状态的下行命令(不加状态位)
  714. case FORCE_FORTIFY_DOWN:
  715. {
  716. break;
  717. }
  718. //17，中心强制制动的下行命令(不加状态位)
  719. case SET_STOP_COMMAND_DOWN:
  720. {
  721. break;
  722. }
  723. //18，中心强制解除制动的下行命令(不加状态位)
  724. case FREE_STOP_COMMAND_DOWN:
  725. {
  726. break;
  727. }
  728. //19,收到设置最大时速的下行命令
  729. case SET_MAXSPEED_DOWN:
  730. {
  731. break;
  732. }
  733. //20,设置电话的权限的下行命令
  734. case SET_PHONE_LIMIT_DOWN:
  735. {
  736. break;
  737. }
  738. //21,收到重新设置里程初始值的下行命令
  739. case SET_DISTANCE_INIT_DOWN:
  740. {
  741. break;
  742. }
  743. //22,设置中心服务号码
  744. case SET_CENTER_NUM_DOWN:
  745. {
  746. break;
  747. }
  748. //23,设置区域参数的设置
  749. case SET_ALLOW_AREA_DOWM:
  750. {
  751. break;
  752. }
  753. //24,设置间隔距离的参数
  754. case SET_DISTANCE_DATA_DOWN:
  755. {
  756. break;
  757. }
  758. //25,接收到下行的电话号码本的参数
  759. case CARRY_PHONE_NUM_DOWN:
  760. {
  761. break;
  762. }
  763. //26，接收到重点监控的命令
  764. case VEHICLE_WATCH_DOWN:
  765. {
  766. break;
  767. }
  768. //27，接收到线路偏离数据的命令
  769. case LINE_DATA_DOWN:
  770. {
  771. break;
  772. }
  773. //28,接收到线路偏离数据的距离限制值的设置
  774. case LINE_LIMIT_DISTANCE_DOWN:
  775. {
  776. break;
  777. }
  778. //29,收到测试信息的测试SMS
  779. case TEST_SMS_COMMAND_DOWN:
  780. {
  781. break;
  782. }
  783. default:
  784. {
  785. break;
  786. }
  787. }
  788. }
  789. /********************************************************
  790. * 函数名：Check_Command
  791. 作用域：本文件调用
  792. * 功能：  针对全局变量缓冲gGeneral_Buffer[]中的数据进行数据有效果判断，如果有效则返回
  793. 有效数据包中的命令字
  795. * 参数：  需要对全局变量缓冲gGeneral_Buffer[]进行操作
  797. * 返回值：0：无效的数据包
  798. gGeneral_Buffer[2]：数据包有效，返回其中命令字
  800. * 创建人：
  801. *
  802. * 修改历史：（每条详述）
  804. 补充说明： 校验数据包，提取命令字，并判断返回命令字，主要是针对gGeneral_Buffer[]
  805. gGeneral_Buffer[]的具体分布如下：
  806. gGeneral_Buffer[0]表示整个数据包的长度（但不包括这个长度本身这个字节）
  807. gGeneral_Buffer[1]消息头0XFF
  808. gGeneral_Buffer[2]命令字 gGeneral_Buffer[2]命令字的取反
  809. ............
  811. ********************************************************/
  812. unsigned char Check_Command(void)
  813. {
  814. unsigned int i,j,k;
  815. if(gGeneral_Buffer[0]==0) return(0);
  816. if(gGeneral_Buffer[1]!=0xFF) return(0);
  817. if(gGeneral_Buffer[2]!=(char)(~gGeneral_Buffer[3]) ) return(0);
  818. //计算校验核
  819. i=gGeneral_Buffer[4]+1; //数据包长度
  820.     k=0;
  821.     for( j=1;j<=i;j++ ) k=k+gGeneral_Buffer[j]; //计算校验核
  822.     if( k/256!=gGeneral_Buffer[gGeneral_Buffer[4]+2] ) return(0);
  823.     if( k%256!=gGeneral_Buffer[gGeneral_Buffer[4]+3] ) return(0);
  824.     return( gGeneral_Buffer[2] );
  825. }
  826. /********************************************************
  827. * 函数名：IP_SOCKET_Switch
  828. 作用域：本文件调用
  829. * 功能：  这里是将从接收到的参数设置中的IP地址和端口号（long int）型的数据。
  830. IP地址直接是N个ASCII字符，则只需要直接存储在FLASH和buffer1中
  831. SOCKET因为是long int的数值，则需要转换成ASCLL字符的形式表示。这里做个限制
  832. 最多5位数字的ASCII。并存储在Flash 和buffer1中
  833. * 参数：
  835. * 返回值：
  836. * 创建人：
  837. *
  838. * 修改历史：（每条详述）
  840. 补充说明1:
  841. long int变量为IP_Port_Num,将这个变量所表示的数值转换为最多5位的ASCII数字形式
  842. 处理结果是在Flash和buffer1中存储断口数据
  843. 调用这个子程序，是在收到下行的设置服务器地址和端口号以后，处理好数据后，所得到的结果
  844. 先处理IP地址的数据，
  845. 还包括一个长度字节（General_Buffer[0]）
  847. 补充说明2： 在运行这个子程序的时候，判断在gGeneral_Buffer[]中的命令字是属于设置服务器地址，端口
  848. gGeneral_Buffer[]的数据结构分布如下：
  849. gGeneral_Buffer[0]表示整个数据包的长度（但不包括这个长度字节本身）
  850. gGeneral_Buffer[1]----gGeneral_Buffer[9]  前面固定的（包括消息头，消息号等等）
  851. gGeneral_Buffer[10]----gGeneral_Buffer[10+N] IP地址的字符串，以0x00作为结束符号（ASCII字符串）
  852. gGeneral_Buffer[10+N+1]----gGeneral_Buffer[10+N+1+4] 为服务器通讯端口号（4个字节，为一个long int型数据）
  854. //处理第二类型GPRS数据的详细步骤
  856. //0x7B----0xB6用来存储针对下行信息的反馈信息（长度不固定）根据协议，此存储空间以60个字节存储
  857. //#define  ECHO_SMS_2 0x7B
  858. //0x7B 存储表示这个区域的SMS是否处理，为1(VAILD_2)则表示后面还有未处理的SMS，为0(NULL_2)则表示已经处理完了SMS
  859. //0x7C 存储数据包的命令字在这里则为nCommand
  860. //0x7D 存储数据包的ACK的值ACK
  861. //0x7E 存储后面数据包的长度（但注意没有存储CHK(MSB),CHK(LSB),EOT,这三个字节）
  862. //0x7F  从这开始存储数据包
  863. 在这个命令中的数据包为从在gGeneral_Buffer[10]开始
  864. ********************************************************/
  865. void IP_SOCKET_Switch(void)
  866. {
  867. unsigned int i,j,k;
  868. unsigned char APN_Length=0;
  869. unsigned char Check_Data=0;
  870. //在gGeneral_Buffer[i]中表示IP地址的第一个数
  871. i=10;
  872. while(1)
  873. {
  874. if(gGeneral_Buffer[i]==0x00) break;
  875. i++;
  876. if(i>gGeneral_Buffer[0])  return;
  877. }
  878. //存储IP地址的长度，不包括长度本身
  879. SRAM_Init();
  880. SRAM_Write(GPRS_IP_ADDRESS1_2,i-10);
  881. //一，+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  882. //1,IP的服务器地址的处理
  883. Check_Data=0;
  884. for(j=10;j<i;j++)
  885. {
  886. SRAM_Write(GPRS_IP_ADDRESS1_2+j-9,gGeneral_Buffer[j]);
  887. Check_Data += gGeneral_Buffer[j];
  888. }
  889. SRAM_Write(GPRS_IP_ADDRESS1_CHECK_2,Check_Data);
  891. //2，将IP地址的SOCKET数据存储在buffer1相应的缓冲区中，因为上面gGeneral_Buffer[i]=0x00
  892. gIP_Port_Num = gGeneral_Buffer[i+1];
  893. gIP_Port_Num<<=8;
  894. gIP_Port_Num += gGeneral_Buffer[i+2];
  895. gIP_Port_Num<<=8;
  896. gIP_Port_Num += gGeneral_Buffer[i+3];
  897. gIP_Port_Num<<=8;
  898. gIP_Port_Num += gGeneral_Buffer[i+4];
  899. //3，将GPRS的APN的内容存储在buffer1中
  900. k=i+5;
  901. while(1)
  902. {
  903. if(gGeneral_Buffer[k]==0x00) break;
  904. k++;
  905. if(k>gGeneral_Buffer[0]) return;
  906. }
  907. //4，存储APN地址的长度，不包括长度本身这个字节的内容
  908. APN_Length=k-i-5;
  909. if( (APN_Length>=4)&&(APN_Length<=25) )
  910. {
  911. SRAM_Write(GPRS_APN_ADDRESS2_2,APN_Length);
  912. //5，存储APN的数据值到相应的BUFFER1中
  913. Check_Data=0;
  914. for(j=i+5;j<k;j++)
  915. {
  916. SRAM_Write(GPRS_APN_ADDRESS2_2+j-i-4,gGeneral_Buffer[j]);
  917. Check_Data += gGeneral_Buffer[j];
  918. }
  919. SRAM_Write(GPRS_APN_END_2,Check_Data);
  920. }
  921. else
  922. {
  923. SRAM_Write(GPRS_APN_ADDRESS2_2,sizeof(APN_DEFAULT));
  924. //5，存储APN的数据值到相应的BUFFER1中
  925. Check_Data=0;
  926. for(i=0;i<sizeof(APN_DEFAULT);i++)
  927. {
  928. SRAM_Write(GPRS_APN_ADDRESS2_2+i+1,APN_DEFAULT[i]);
  929. Check_Data += APN_DEFAULT[i];
  930. }
  931. SRAM_Write(GPRS_APN_END_2,Check_Data);
  932. }
  933. //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  934. //存储作为第2类信息发送的响应数据的存储
  935. //服务器端口设置成功后的响应
  936. SRAM_Write(ECHO_SMS_2,VAILD_2);
  937. SRAM_Write(ECHO_SMS_2+1,ADDRESS_PORT_ECHO_UP);
  938. SRAM_Write(ECHO_SMS_2+2,gGeneral_Buffer[5]);
  939. SRAM_Write(ECHO_SMS_2+3,k-10);
  940. for(j=10;j<k;j++)
  941. {
  942. SRAM_Write(ECHO_SMS_2+4+j-10,gGeneral_Buffer[j]);
  943. }
  944. //因为端口号为一个long int 型的数据，则需要转换为ASCII字符的形式做实际应用
  945. //这里最多能表示5位的端口号，
  946. Check_Data=0;
  947. SRAM_Write(GPRS_SOCKET1_2+0,ASCII(gIP_Port_Num/10000));
  948. Check_Data += ASCII(gIP_Port_Num/10000);
  949. SRAM_Write(GPRS_SOCKET1_2+1,ASCII((gIP_Port_Num%10000)/1000));
  950. Check_Data += ASCII((gIP_Port_Num%10000)/1000);
  951. SRAM_Write(GPRS_SOCKET1_2+2,ASCII((gIP_Port_Num%1000)/100));
  952. Check_Data += ASCII((gIP_Port_Num%1000)/100);
  953. SRAM_Write(GPRS_SOCKET1_2+3,ASCII((gIP_Port_Num%100)/10));
  954. Check_Data +=ASCII((gIP_Port_Num%100)/10);
  955. SRAM_Write(GPRS_SOCKET1_2+4,ASCII(gIP_Port_Num%10));
  956. Check_Data += ASCII(gIP_Port_Num%10);
  957. SRAM_Write(GPRS_SOCKET1_END_2,Check_Data);
  958. gTimer=0;Clear_Exter_WatchDog();
  959. while(gTimer<100){}
  960. Clear_Exter_WatchDog();
  961. //二，++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  962. //注意，这里在程序刚上电的最开始已经检查过了FLASH的第1，第2扇区的数据
  963. //在这里则不需要在继续检查
  964. //读第一个扇区的数据到buffer2中
  965. // OperateSPIEnd();ReadOnePageToBuffer2(FLASH_INFO1_ONE_2);OperateSPIEnd();
  966. Deal_Sector(FLASH_INFO1_ONE_2);
  967. //1，将IP地址数据已经写入相应的buffer2中
  968. i=10;
  969. while(1)
  970. {
  971. if(gGeneral_Buffer[i]==0x00) break;
  972. i++;
  973. if(i>26) return;
  974. }
  975. //1-1,写IP地址数据长度
  976. OperateSPIEnd();
  977. WriteOneByteToBuffer2(GPRS_IP_ADDRESS1_F_2,i-10);
  978. //1-2，写IP地址数据包
  979. for(j=10;j<i;j++)
  980. {
  981. WriteNextByteToBuffer2(gGeneral_Buffer[j]);
  982. }
  983. OperateSPIEnd();
  984. gGeneral_Flag|=TCP_IP_VALID_1;
  985. gStatus2_Flag|=IP_VAILD_F_1;
  986. //2，将SOCKET的数据写入相应的buffer2中
  987. i=i+4;//此时的gGeneral_Buffer[i]=0x00
  988. i++;
  989. OperateSPIEnd();
  990. WriteOneByteToBuffer2(GPRS_SOCKET1_F_2,ASCII(gIP_Port_Num/10000));
  991. WriteNextByteToBuffer2(ASCII((gIP_Port_Num%10000)/1000));
  992. WriteNextByteToBuffer2(ASCII((gIP_Port_Num%1000)/100));
  993. WriteNextByteToBuffer2(ASCII((gIP_Port_Num%100)/10));
  994. WriteNextByteToBuffer2(ASCII(gIP_Port_Num%10));
  995. OperateSPIEnd();
  996. //3,将APN的内容写入相应的buffer2中
  997. OperateSPIEnd();
  998. //3-1,写入APN数据的长度
  999. WriteOneByteToBuffer2(GPRS_APN_DATA_F_2,APN_Length);
  1000. //3-2，写APN数据包
  1001. for(j=i;j<i+APN_Length;j++)
  1002. {
  1003. WriteNextByteToBuffer2(gGeneral_Buffer[j]);
  1004. }
  1005. OperateSPIEnd();
  1006. RFlash_Sector(FLASH_INFO1_ONE_2);
  1007. Re430_Flash(0);
  1008. if(gM22_Status!=GSM_WORK) gOther_Flag|=QUIT_TCP_F_1;
  1009. gCheck_Par_Timer=CHECK_SYS_PAR_TIME+1;
  1010. Judge_SMS_Way();
  1011. }
  1013. /********************************************************
  1014. * 函数名：Do_Parameter_Set
  1015. 作用域：本文件调用
  1016. * 功能：  如果在Deal_Command()模块中判断属于处理下行的数据命令字为
  1017. 参数设置，则调用这个函数进行处理，收到的参数有
  1018. 车型，类别，组别，车号，目标号码1(以0x00结束)，目标号码2(备用)(以0x00结束)
  1019. 对于上面信息的处理，一是存储在Flash相应的区域，一是存储在buffer1相应的区域
  1020. 同时设置参数设置响应的标志（发送第一类的SMS），存储此ACK到gSMS_ACK[]相应的区域
  1021. * 参数： 全局变量gGeneral_Buffer[]中的数据
  1023. * 返回值：进行和参数相关的设置
  1025. * 创建人：
  1026. *
  1027. * 修改历史：（每条详述）
  1029. 补充说明： 在运行这个子程序的时候，判断在gGeneral_Buffer[]中的数据是参数设置，此时
  1030. gGeneral_Buffer[]的数据结构分布如下：
  1031. gGeneral_Buffer[0]表示整个数据包的长度（但不包括这个长度字节本身）
  1032. gGeneral_Buffer[1]----gGeneral_Buffer[9]  前面固定的（包括消息头，消息号等等）
  1033. gGeneral_Buffer[10]----gGeneral_Buffer[14]   需要设置的车型，类别，组别，车号
  1034. gGeneral_Buffer[15]----gGeneral_Buffer[15+N] 中心的短消息接收号码（以0x00作为结束符）
  1035. gGeneral_Buffer[15+N+1]-----gGeneral_Buffer[15+N+M] 中心的短消息接收备用号码 （以0x00作为结束符）
  1037. 如果收到参数设置的下行命令，则首先的需要恢复出厂时的设置，将第0个扇区，第1个扇区，第2个扇区里的数据ERASE
  1038. 执行条件：只有处于GSM工作方式下才处理
  1039. ********************************************************/
  1040. void Do_Parameter_Set(void)
  1041. {
  1042. //进行参数设置响应（上行数据发送）
  1043. //表示第一类SMS的数据发送:参数设置响应
  1044. //设置发送参数设置响应的标志
  1045. Load_Buffer1_Echo(PARAMETER_SETECHO_UP,gGeneral_Buffer[5]);
  1046. Do_Par();
  1047. }
  1049. /********************************************************
  1050. * 函数名：Position_Echo
  1051. 作用域：本文件调用
  1052. * 功能：  收到下行的需要定位查询的命令，则做相关的处理
  1053. 将此时此刻的效果的经度，纬度，时间信息打成数据包
  1054. 存储在第二类SMS数据的存储区（buffer1的0x7B----0xB6区域）
  1055. 0x7B设置为1（VAILD_2）,并将数据包依次存储在后面的字节缓冲中。
  1056. 后面数据包的形式为
  1058. * 参数： 全局变量gGeneral_Buffer[]中的数据
  1060. * 返回值：进行和参数相关的设置
  1062. * 创建人：
  1063. *
  1064. * 修改历史：（每条详述）
  1066. 补充说明：
  1068. 补充说明：具体在buffer1中存储第2类SMS的数据形式如下：0x7B----0xB6（整个分配的区域大小）
  1069.   0x7B 存储表示这个区域的SMS是否处理，为1则表示后面还有未处理的SMS，为0则表示已经处理完了SMS
  1070.   0x7C 存储数据包的命令字在这里则为nCommand
  1071.   0x7D 存储数据包的ACK的值ACK
  1072.   0x7E 存储后面数据包的长度（但注意没有存储CHK(MSB),CHK(LSB),EOT,这三个字节）
  1073.   0x7F  从这开始存储数据包
  1074. 数据区的内容：
  1075. LONGTITUDE 4 bytes，无符号整型 经度
  1076. LATITUDE 4 bytes，无符号整型 纬度
  1077. SPEED 1 byte， 无符号整型 速度，单位：米／秒
  1078. AZIMUTH 1 byte， 无符号整型 方位角／15，单位：度
  1079. FLAG 1 byte， 无符号整型 标志
  1080. TIME 6 bytes，字符型 时间(YYMMDDHHMISS)
  1082. ********************************************************/
  1083. void Position_Echo(void)
  1084. {
  1085. unsigned char nCheck=0;
  1086. unsigned int i=0;
  1087. //1，如果中心号码无效果，则进行暂时的返回发送
  1088. if(   ((gGeneral_Flag&NUM1_VAILD_F_1)==0)
  1089. &&(gNum_Phone_Temp[0]<=14) )
  1090. {
  1091. //1,存储目标号码
  1092. SRAM_Init();
  1093. SRAM_Write(TARGET_NUMBER1_2+0,gNum_Phone_Temp[0]);
  1094. for(i=1;i<=gNum_Phone_Temp[0];i++)
  1095. {
  1096. SRAM_Write(TARGET_NUMBER1_2+i,gNum_Phone_Temp[i]);
  1097. nCheck += gNum_Phone_Temp[i];
  1098. }
  1099. SRAM_Write(TARGET_NUMBER1_CHECK_2,nCheck);
  1100. //2,存储车组，车类，车型，车号
  1101. gKind=gGeneral_Buffer[6];
  1102. gGroup=gGeneral_Buffer[7];
  1103. gVID = gGeneral_Buffer[8];
  1104. gVID<<=8;
  1105. gVID += gGeneral_Buffer[9];
  1106. gGeneral_Flag|=NUM1_VAILD_F_1;
  1107. }
  1108. SRAM_Init();
  1109. SRAM_Write(ECHO_SMS_2+0,VAILD_2);
  1110. SRAM_Write(ECHO_SMS_2+1,POSITION_ASKECHO_UP);
  1111. SRAM_Write(ECHO_SMS_2+2,gGeneral_Buffer[5]);
  1112. SRAM_Write(ECHO_SMS_2+3,17+4);
  1113. Write_PartData_Sram(ECHO_SMS_2+3); //17
  1114. SRAM_Write(ECHO_SMS_2+3+18,0);
  1115. SRAM_Write(ECHO_SMS_2+3+19,0);
  1116. SRAM_Write(ECHO_SMS_2+3+20,gStatus2_Flag);
  1117. SRAM_Write(ECHO_SMS_2+3+21,gStatus1_Flag);
  1118. Judge_SMS_Way();
  1119. }
  1121. /********************************************************
  1122. * 函数名：Set_Cycle_Timer
  1123. 作用域：本地文件调用
  1124. * 功能： 收到设置上传位置时间间隔的下行命令后，做一些相关的处理
  1125. 一是附给变量gCycle_GPRS和gCycle_GSM，二是存储在相应的Flash区中
  1126. gCycle_GPRS变量存储的是在GPRS在线的状态下发送行驶状态数据上行信息的时间间隔
  1127. gCycle_GSM变量存储的是在GSM在线的但GPRS不在线的状态下发送行驶状态数据上行信息的时间间隔
  1129. * 参数：  无
  1130. * 返回值：无
  1131. * 创建人：
  1132. *
  1133. * 修改历史：（每条详述）
  1134. ********************************************************/
  1135. void Set_Cycle_Timer(void)
  1136. {
  1137. unsigned int i=0,j=0;
  1138. unsigned char nACK=0;
  1139. nACK=gGeneral_Buffer[5];
  1140. gCycle_TCP = gGeneral_Buffer[1+9];
  1141. gCycle_TCP <<= 8;
  1142. gCycle_TCP += gGeneral_Buffer[1+10];
  1144. gCycle_GSM = gGeneral_Buffer[1+11];
  1145. gCycle_GSM <<= 8;
  1146. gCycle_GSM += gGeneral_Buffer[1+12];
  1148. if( (gCycle_TCP>0)&&(gCycle_TCP<5) ) gCycle_TCP=5;
  1149. if( (gCycle_GSM>0)&&(gCycle_GSM<5) ) gCycle_GSM=5;
  1151. //如果间隔距离符合条件,则将间隔距离设置为0
  1152. if( gCycle_TCP>=5 )
  1153. {
  1154. gCycle_Distance=0;
  1155. }
  1156. gPublic_Flag &=~ SET_DISTANCE_OK_F_1;
  1157. gSet_Distance_Info_Count=WAIT_DISPINFO_TIME-2;
  1158. // OperateSPIEnd();ReadOnePageToBuffer2(FLASH_INFO2_ONE_2);OperateSPIEnd();
  1159. Deal_Sector(FLASH_INFO2_ONE_2);
  1160. WriteOneByteToBuffer2(TCP_TIMER_2,gGeneral_Buffer[1+9]);
  1161. WriteNextByteToBuffer2(gGeneral_Buffer[1+10]);
  1162. WriteNextByteToBuffer2(gGeneral_Buffer[1+11]);
  1163. WriteNextByteToBuffer2(gGeneral_Buffer[1+12]);
  1164. WriteNextByteToBuffer2(0);
  1165. WriteNextByteToBuffer2(0);
  1166. OperateSPIEnd();
  1167. RFlash_Sector(FLASH_INFO2_ONE_2);
  1168. Re430_Flash(1);
  1169. OperateSPIEnd();
  1170. Clear_Exter_WatchDog();
  1172. SRAM_Init();
  1173. SRAM_Write(ECHO_SMS_2+0,VAILD_2);
  1174. SRAM_Write(ECHO_SMS_2+1,TIME_INTERVAL_ECHO_UP);
  1175. SRAM_Write(ECHO_SMS_2+2,nACK);
  1176. SRAM_Write(ECHO_SMS_2+3,21);
  1177. Write_PartData_Sram(ECHO_SMS_2+3); //17
  1178. SRAM_Write(ECHO_SMS_2+3+18,0);
  1179. SRAM_Write(ECHO_SMS_2+3+19,0);
  1180. SRAM_Write(ECHO_SMS_2+3+20,gStatus2_Flag);
  1181. SRAM_Write(ECHO_SMS_2+3+21,gStatus1_Flag);
  1182. Judge_SMS_Way();
  1184. //1，IP地址有效果，并且2，TCP的开关量是否开启
  1185. if( (gGeneral_Flag&TCP_IP_VALID_1)&&((gON_OFF_Temp0&TCP_LAND_ON_OFF_1)==0) )
  1186. {
  1187. if( (gCycle_TCP>0)&&(gCycle_Send_Status!=ALARM_DATA)&&(gCycle_Send_Status!=PASS_DATA) )
  1188. {
  1189. gCycle_Send_Status=TRACK_DATA_TIME;
  1190. }
  1191. else if( (gCycle_TCP==0)&&(gCycle_Send_Status==TRACK_DATA_TIME))
  1192. {
  1193. gCycle_Send_Status=NOP_DATA;
  1194. }
  1195. }
  1196. //1，IP地址无效，或者TCP的开关量关闭
  1197. else
  1198. {
  1199. if( (gCycle_GSM>0)&&(gCycle_Send_Status!=ALARM_DATA)&&(gCycle_Send_Status!=PASS_DATA) )
  1200. {
  1201. gCycle_Send_Status=TRACK_DATA_TIME;
  1202. }
  1203. else if( (gCycle_GSM==0)&&(gCycle_Send_Status==TRACK_DATA_TIME))
  1204. {
  1205. gCycle_Send_Status=NOP_DATA;
  1206. }
  1207. }
  1208. }
  1209. /********************************************************
  1210. * 函数名：Pass_Data_Echo()
  1211. 作用域：本地文件调用
  1212. * 功能： 接收到下行的查询历史轨迹的命令
  1213. 将需要查询的历史轨迹的起始时间附给变量Check_Track_Time_Start
  1214. 将需要查询的历史轨迹的结束时间附给变量Check_Track_Time_end
  1215. 然后设置有需要进行历史轨迹操作的标志位 gInternal_Flag|=PASS_DATA_F_1
  1217. * 参数：  无
  1218. * 返回值：无
  1219. * 创建人：
  1220. *
  1221. * 修改历史：（每条详述）
  1222. 补充说明：这个时候需要处理的gGeneral_Buffer[]缓冲中的数据
  1223. SMS_ACK[TRACK_ASKECHO_ACK]=gGeneral_Buffer[5]   存储ACK
  1226. ********************************************************/
  1227. void Pass_Data_Echo(void)
  1228. {
  1230. unsigned int i=0;
  1231. //存储发送历史轨迹的开始的ACK
  1232. gSMS_ACK[TRACK_ASKECHO_ACK]=gGeneral_Buffer[5];
  1233. //存储计算历史轨迹的开始时间
  1234. gCheck_Track_Time_Start=0;
  1235. gCheck_Track_Time_Start= ( (gGeneral_Buffer[10]%100)/10*16+ (gGeneral_Buffer[10]%10)  );
  1236. gCheck_Track_Time_Start <<= 8;
  1237. gCheck_Track_Time_Start += ( (gGeneral_Buffer[11]%100)/10*16+ (gGeneral_Buffer[11]%10) );
  1238. gCheck_Track_Time_Start <<= 8;
  1239. gCheck_Track_Time_Start += ( (gGeneral_Buffer[12]%100)/10*16+ (gGeneral_Buffer[12]%10) );
  1240. gCheck_Track_Time_Start <<= 8;
  1241. gCheck_Track_Time_Start += ( (gGeneral_Buffer[13]%100)/10*16+ (gGeneral_Buffer[13]%10) );
  1243.     //存储计算历史轨迹的结束时间
  1244.     gCheck_Track_Time_end=0;
  1245. gCheck_Track_Time_end= ( (gGeneral_Buffer[15]%100)/10*16+ (gGeneral_Buffer[15]%10) );
  1246. gCheck_Track_Time_end <<= 8;
  1247. gCheck_Track_Time_end += ( (gGeneral_Buffer[16]%100)/10*16+ (gGeneral_Buffer[16]%10) );
  1248. gCheck_Track_Time_end <<= 8;
  1249. gCheck_Track_Time_end += ( (gGeneral_Buffer[17]%100)/10*16+ (gGeneral_Buffer[17]%10) );
  1250. gCheck_Track_Time_end <<= 8;
  1251. gCheck_Track_Time_end+= ( (gGeneral_Buffer[18]%100)/10*16+ (gGeneral_Buffer[18]%10) );;
  1254. //如果接收到的历史轨迹开始查询时间和结束时间相同，则表示接收到的是结束历史轨迹查询的命令
  1255. if(gCheck_Track_Time_Start==gCheck_Track_Time_end)
  1256. {
  1257. gCycle_Send_Status=NOP_DATA;
  1258. gCircle_Buffer_Point=0;
  1259. for(i=0;i<sizeof(gCircle_Buffer);i++) gCircle_Buffer[i]=0;
  1260. gOther_Flag&=~FIND_PASSPAGE_F_1;gOther_Flag&=~FIRST_PASSPAGE_F_1;gOther_Flag&=~SEND_PASSPAGE_F_1;
  1261. gOther_Flag&=~PASS_DATA_LASE_F_1;
  1262. gOther_Flag&=~SEND_PASSPAGE_F_1;
  1263. //设置发送历史轨迹结束的标志
  1264. Load_Buffer1_Echo(TRACK_ENDECHO_UP,gGeneral_Buffer[5]);
  1265. Send_COM1_String( (unsigned char *)PASS_END,sizeof(PASS_END) );
  1266. return;
  1267. }
  1268. if (gCycle_Send_Status!=ALARM_DATA )
  1269. {
  1271. gCycle_Send_Status=PASS_DATA;gOther_Flag|=FIND_PASSPAGE_F_1;
  1272. gOther_Flag&=~FIRST_PASSPAGE_F_1;gOther_Flag&=~SEND_PASSPAGE_F_1;
  1273. if(gPassTrack_Store_Sector==FLASH_PASTDATA_E_2-1)
  1274. {
  1275. gPassPage_First=FLASH_PASTDATA_S_2;
  1276. gPassPage_End=FLASH_PASTDATA_E_2-1;
  1277. }
  1278. else if(gPassTrack_Store_Sector>=FLASH_PASTDATA_E_2)
  1279. {
  1280. gPassPage_First=FLASH_PASTDATA_S_2+1;
  1281. gPassPage_End=FLASH_PASTDATA_E_2;
  1282. }
  1283. else
  1284. {
  1285. gPassPage_First=gPassTrack_Store_Sector+2;
  1286. gPassPage_End=FLASH_PASTDATA_E_2;
  1287. }
  1288. }
  1289. #ifdef Debug_GSM_COM1
  1290. Send_COM1_String( (unsigned char *)TIME_START,sizeof(TIME_START) );
  1291. Send_COM1_Byte('[');
  1292.     Send_COM1_Byte(ASCII(gCheck_Track_Time_Start/0x10000000));
  1293.     Send_COM1_Byte(ASCII((gCheck_Track_Time_Start%0x10000000)/0x1000000));
  1294.     Send_COM1_Byte(ASCII((gCheck_Track_Time_Start%0x1000000)/0x100000));
  1295.     Send_COM1_Byte(ASCII((gCheck_Track_Time_Start%0x100000)/0x10000));
  1296.     Send_COM1_Byte(ASCII((gCheck_Track_Time_Start%0x10000)/0x1000));
  1297.     Send_COM1_Byte(ASCII((gCheck_Track_Time_Start%0x1000)/0x100));
  1298.     Send_COM1_Byte(ASCII((gCheck_Track_Time_Start%0x100)/0x10));
  1299. Send_COM1_Byte(ASCII(gCheck_Track_Time_Start%0x10));
  1300. Send_COM1_Byte(']');
  1301. Send_COM1_String( (unsigned char *)TIME_END,sizeof(TIME_END) );
  1302. Send_COM1_Byte('[');
  1303.     Send_COM1_Byte(ASCII(gCheck_Track_Time_end/0x10000000));
  1304.     Send_COM1_Byte(ASCII((gCheck_Track_Time_end%0x10000000)/0x1000000));
  1305.     Send_COM1_Byte(ASCII((gCheck_Track_Time_end%0x1000000)/0x100000));
  1306.     Send_COM1_Byte(ASCII((gCheck_Track_Time_end%0x100000)/0x10000));
  1307.     Send_COM1_Byte(ASCII((gCheck_Track_Time_end%0x10000)/0x1000));
  1308.     Send_COM1_Byte(ASCII((gCheck_Track_Time_end%0x1000)/0x100));
  1309.     Send_COM1_Byte(ASCII((gCheck_Track_Time_end%0x100)/0x10));
  1310. Send_COM1_Byte(ASCII(gCheck_Track_Time_end%0x10));
  1311. Send_COM1_Byte(']');
  1312. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  1314. Send_COM1_String( (unsigned char *)PAGE_S,sizeof(PAGE_S) );
  1315. Send_COM1_Byte('[');
  1316.     Send_COM1_Byte(ASCII(gPassPage_First/1000));
  1317.     Send_COM1_Byte(ASCII((gPassPage_First%1000)/100));
  1318.     Send_COM1_Byte(ASCII(((gPassPage_First%1000)%100)/10));
  1319. Send_COM1_Byte(ASCII(gPassPage_First%10));
  1320. Send_COM1_Byte(']');
  1321. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  1322. Send_COM1_String( (unsigned char *)PAGE_E,sizeof(PAGE_E) );
  1323. Send_COM1_Byte('[');
  1324.     Send_COM1_Byte(ASCII(gPassPage_End/1000));
  1325.     Send_COM1_Byte(ASCII((gPassPage_End%1000)/100));
  1326.     Send_COM1_Byte(ASCII(((gPassPage_End%1000)%100)/10));
  1327. Send_COM1_Byte(ASCII(gPassPage_End%10));
  1328. Send_COM1_Byte(']');
  1329. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  1330. #endif
  1331. Judge_SMS_Way();
  1333. }
  1335. /********************************************************
  1336. * 函数名：Disp_Dispaly_Info();
  1337. 作用域：本地文件调用
  1338. * 功能：
  1339. * 参数：  无
  1340. * 返回值：无
  1341. * 创建人：
  1342. *
  1343. * 修改历史：（每条详述）
  1344. ********************************************************/
  1345. void Disp_Dispaly_Info(void)
  1346. {
  1347.     unsigned int i=0;
  1349. if(gDisp_Buffer_Point+gGeneral_Buffer[0]+2+6<=sizeof(gDisp_Buffer))
  1350. {
  1351.     gDisp_Buffer[gDisp_Buffer_Point]=gGeneral_Buffer[0]+2+6;
  1352.     gDisp_Buffer_Point++;
  1353.     gDisp_Buffer[gDisp_Buffer_Point]=0;
  1354.     gDisp_Buffer_Point++;
  1355.     gDisp_Buffer[gDisp_Buffer_Point]='@';
  1356.     gDisp_Buffer_Point++;
  1357.     gDisp_Buffer[gDisp_Buffer_Point]='%';
  1358.     gDisp_Buffer_Point++;
  1359.     gDisp_Buffer[gDisp_Buffer_Point]=gGeneral_Buffer[0]+2+4;
  1360.     gDisp_Buffer_Point++;
  1361.     gDisp_Buffer[gDisp_Buffer_Point]=DISP_MAIN_WORD_DOWN;
  1362.     gDisp_Buffer_Point++;
  1363.     //从0xFF开始存储数据(转移整个中心的数据包)
  1364.     Copy_String(gGeneral_Buffer+1,gDisp_Buffer+gDisp_Buffer_Point,gGeneral_Buffer[0]);
  1365.     gDisp_Buffer_Point=gDisp_Buffer_Point+gGeneral_Buffer[0];
  1366.     gDisp_Buffer[gDisp_Buffer_Point]='$';
  1367.     gDisp_Buffer_Point++;
  1368.     gDisp_Buffer[gDisp_Buffer_Point]='&';
  1369.     gDisp_Buffer_Point++;
  1370. }
  1371. //下面是显示调试信息
  1372. /*
  1373. #ifdef Debug_GSM_COM1
  1374. Send_COM1_Byte(ASCII(gDisp_Buffer[0]/16));
  1375. Send_COM1_Byte(ASCII(gDisp_Buffer[0]%16));
  1376. Send_COM1_Byte('=');
  1377. Send_COM1_Byte(ASCII(gDisp_Buffer_Point/16));
  1378. Send_COM1_Byte(ASCII(gDisp_Buffer_Point%16));
  1379. Send_COM1_Byte('{');
  1380. for(i=0;i<gDisp_Buffer[0];i++)
  1381. {
  1382. Send_COM1_Byte(ASCII(gDisp_Buffer[i]/16));
  1383. Send_COM1_Byte(ASCII(gDisp_Buffer[i]%16));
  1384. }
  1385. Send_COM1_Byte('}');
  1386. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  1387. #endif
  1388. */
  1389. }
  1390. /********************************************************
  1391. * 函数名：Set_TCP_OnOrOff();
  1392. 作用域：本地文件调用
  1393. * 功能：
  1394. * 参数：  无
  1395. * 返回值：无
  1396. * 创建人：
  1397. *
  1398. * 修改历史：（每条详述）
  1399. 补充说明：接收到下行的是设置进入/退出联网状态的命令，
  1400. 需要进行如下几个操作，存储需要响应的ACK
  1401. 1，改变进入TCP的开关量，并存储扇区0
  1402. 2，写入B类数据区此命令的回应上行命令
  1403. ********************************************************/
  1404. void Set_TCP_OnOrOff(void)
  1405. {
  1406. unsigned int i=0,j=0;
  1407. SRAM_Init();
  1408. SRAM_Write(ECHO_SMS_2+0,VAILD_2);
  1409. SRAM_Write(ECHO_SMS_2+1,SET_TCP_ONOROFF_ECHO_UP);
  1410. SRAM_Write(ECHO_SMS_2+2,gGeneral_Buffer[5]);
  1411. SRAM_Write(ECHO_SMS_2+3,1);
  1412. SRAM_Write(ECHO_SMS_2+4,gGeneral_Buffer[10]);
  1413. Judge_SMS_Way();
  1414. }
  1415. /********************************************************
  1416. * 函数名：Query_SYS_Ver();
  1417. 作用域：本地文件调用
  1418. * 功能：
  1419. * 参数：  无
  1420. * 返回值：无
  1421. * 创建人：
  1422. *
  1423. * 修改历史：（每条详述）
  1424. ********************************************************/
  1425. void Query_SYS_Ver(void)
  1426. {
  1427. unsigned int i=0;
  1429. SRAM_Init();
  1430. SRAM_Write(ECHO_SMS_2+0,VAILD_2);
  1431. SRAM_Write(ECHO_SMS_2+1,QUERY_VERSION_ECHO_UP);
  1432. SRAM_Write(ECHO_SMS_2+2,gGeneral_Buffer[5]);
  1433. SRAM_Write(ECHO_SMS_2+3,14);
  1434. SRAM_Write(ECHO_SMS_2+4,SYS_EDITION[0]);
  1435. SRAM_Write(ECHO_SMS_2+5,SYS_EDITION[1]);
  1436. for(i=0;i<6;i++)
  1437. {
  1438. SRAM_Write(ECHO_SMS_2+6+i,SYS_TIME[i]);
  1439. }
  1440. for(i=0;i<6;i++)
  1441. {
  1442. SRAM_Write(ECHO_SMS_2+12+i,SYS_UPDATATIME[i]);
  1443. }
  1444. Judge_SMS_Way();
  1445. }
  1447. /********************************************************
  1448. * 函数名：Deal_Alarm_Echo();
  1449. 作用域：本地文件调用
  1450. * 功能：
  1451. * 参数：  无
  1452. * 返回值：无
  1453. * 创建人：
  1454. *
  1455. * 修改历史：（每条详述）
  1456. ********************************************************/
  1457. void Deal_Alarm_Echo(void)
  1458. {
  1459. unsigned int i=0,j=0;
  1460. gSMS_ACK[ALARM_ACK]=gGeneral_Buffer[5];
  1461. gCycle_Alarm = gGeneral_Buffer[10];
  1462. gCycle_Alarm <<= 8;
  1463. gCycle_Alarm += gGeneral_Buffer[11];
  1464. if( gCycle_Alarm == 0)
  1465. {
  1466. gAlarm_Type=NOP_ALARM;
  1467. gCycle_Send_Status=NOP_DATA;
  1468. gAlarm_Count=0;
  1469. gStatus2_Flag&=~ROB_ALARM_F_1;
  1470. Load_Buffer1_Echo(ALARM_END_UP,gGeneral_Buffer[5]);
  1471. }
  1472. else if( gCycle_Alarm <= 5 ) gCycle_Alarm=5;
  1473. }
  1475. /********************************************************
  1476. * 函数名：Deal_Vehicle_Monitor();
  1477. 作用域：本地文件调用
  1478. * 功能：
  1479. * 参数：  无
  1480. * 返回值：无
  1481. * 创建人：
  1482. *
  1483. * 修改历史：（每条详述）
  1484. ********************************************************/
  1485. void Deal_Vehicle_Monitor(void)
  1486. {
  1487. unsigned int i=0,j=0;
  1488. i=10;j=0;
  1489. while(gGeneral_Buffer[i]!=0x00)
  1490. {
  1491. i++;j++;if(j>16) {j=0;break;}
  1492. }
  1493. //接收到下行的监听信令。
  1494. if(j>4)
  1495. {
  1496. SRAM_Init();
  1497. SRAM_Write(PHONE_AT_2+0,VAILD_2);
  1498. SRAM_Write(PHONE_AT_2+1,M_DIAL);
  1499. SRAM_Write(PHONE_AT_2+2,j);
  1500. for(i=0;i<j;i++)
  1501. {
  1502. SRAM_Write(PHONE_AT_2+3+i,gGeneral_Buffer[i+10]);
  1503. }
  1504. }
  1505. }
  1508. /********************************************************
  1509. * 函数名：Defence_Password_Ask_Echo();
  1510. 作用域：本地文件调用
  1511. * 功能：
  1512. * 参数：  无
  1513. * 返回值：无
  1514. * 创建人：
  1515. *
  1516. * 修改历史：（每条详述）
  1517. ********************************************************/
  1519. void Defence_Password_Ask_Echo(void)
  1520. {
  1521. unsigned int i=0;
  1522. unsigned char OldPassWord_Length=0;
  1524. //读取FLASH相应存储密码区域的密码信息,将密码暂时存储在gGeneral_Buffer[]中
  1525. OperateSPIEnd();
  1526. ReadOnePageToBuffer2(FLASH_INFO1_ONE_2);
  1527. OperateSPIEnd();
  1528. gGeneral_Buffer[0]=ReadByteFromBuffer2(PASSWORD1_F_2);
  1529. for(i=1;i<6;i++)
  1530. {
  1531. gGeneral_Buffer[i]=ReadNextFromBuffer2();
  1532. }
  1533. OperateSPIEnd();
  1535. //调试显示出读出的密码是否正确
  1536. #ifdef Debug_GSM_COM1
  1537. Send_COM1_Byte('P');Send_COM1_Byte('[');
  1538. for(i=0;i<6;i++) Send_COM1_Byte(gGeneral_Buffer[i]);
  1539. Send_COM1_Byte(']');Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  1540. #endif
  1542. //读出的密码存储在gGeneral_Buffer[0]---gGeneral_Buffer[5]
  1543. for(i=0;i<6;i++)
  1544. {
  1545. if( (gGeneral_Buffer[i]<'0')||(gGeneral_Buffer[i]>'9') ) break;
  1546. }
  1547. //知道密码的长度
  1548. OldPassWord_Length=i;
  1550. //调试显示密码的数据
  1551. #ifdef Debug_GSM_COM1
  1552. Send_COM1_Byte(ASCII(OldPassWord_Length/10));
  1553. Send_COM1_Byte(ASCII(OldPassWord_Length%10));
  1554. Send_COM1_Byte('[');
  1555. for(i=0;i<OldPassWord_Length;i++) Send_COM1_Byte(gGeneral_Buffer[i]);
  1556. Send_COM1_Byte(']');Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  1557. #endif
  1558. SRAM_Init();
  1559. SRAM_Write(OTHER_SMS_2+0,VAILD_2);
  1560. SRAM_Write(OTHER_SMS_2+1,PASSWORD_ASKECHO_UP);
  1561. SRAM_Write(OTHER_SMS_2+2,gGeneral_Buffer[5]);
  1562. SRAM_Write(OTHER_SMS_2+3,OldPassWord_Length+1);
  1563. for(i=0;i<OldPassWord_Length;i++)
  1564. {
  1565. SRAM_Write(OTHER_SMS_2+4+i,gGeneral_Buffer[i]);
  1566. }
  1567. SRAM_Write(OTHER_SMS_2+4+OldPassWord_Length,0x00);
  1568. Judge_SMS_Way();
  1569. }
  1572. /********************************************************
  1573. * 函数名：Set_Phone_Limit();
  1574. 作用域：本地文件调用
  1575. * 功能：
  1576. * 参数：  无
  1577. * 返回值：无
  1578. * 创建人：
  1579. *
  1580. * 修改历史：（每条详述）
  1581. ********************************************************/
  1582. void Set_Phone_Limit(void)
  1583. {
  1584. unsigned char nACK=0;
  1585. nACK=gGeneral_Buffer[5];
  1586. //1，接收判断
  1587. //判断电话呼入限制的功能
  1588. if(gGeneral_Buffer[10]==0)
  1589. {
  1590. //电话呼入禁止
  1591. gON_OFF_Temp0&=~PHONE_IN_ON;
  1592. gStatus2_Flag|=HANDLE_PHONE_IN_LIMIT;
  1593. }
  1594. else if(gGeneral_Buffer[10]==0xFF)
  1595. {
  1596. //电话呼出允许
  1597. gON_OFF_Temp0|=PHONE_IN_ON;
  1598. gStatus2_Flag&=~HANDLE_PHONE_IN_LIMIT;
  1599. }
  1600. //判断电话呼出限制的功能
  1601. if(gGeneral_Buffer[11]==0)
  1602. {
  1603. //电话呼出禁止
  1604. gON_OFF_Temp0&=~PHONE_OUT_ON;
  1605. gStatus2_Flag|=HANDLE_PHONE_OUT_LIMIT;
  1606. }
  1607. else if(gGeneral_Buffer[11]==0xFF)
  1608. {
  1609. //电话呼出允许
  1610. gON_OFF_Temp0|=PHONE_OUT_ON;
  1611. gStatus2_Flag&=~HANDLE_PHONE_OUT_LIMIT;
  1612. }
  1613. //2，处理后的状态存储
  1614. //根据状态的改变，则需要重新更新扇区5中的数据，并重新计算校验核，写入扇区
  1615. // OperateSPIEnd();ReadOnePageToBuffer2(FLASH_INFO2_ONE_2);OperateSPIEnd();
  1616. Deal_Sector(FLASH_INFO2_ONE_2);
  1617. WriteOneByteToBuffer2(ON_OFF_V1_2,gON_OFF_Temp0);
  1618. OperateSPIEnd();
  1619. RFlash_Sector(FLASH_INFO2_ONE_2);
  1620. Re430_Flash(1);
  1621. //3,处理完后的响应
  1622. //下面是处理需要发送接收到终端进入/退出联网状态的响应
  1623. SRAM_Init();
  1624. SRAM_Write(ECHO_SMS_2+0,VAILD_2);
  1625. SRAM_Write(ECHO_SMS_2+1,SET_PHONE_LIMIT_ECHO_UP);
  1626. SRAM_Write(ECHO_SMS_2+2,nACK);
  1627. SRAM_Write(ECHO_SMS_2+3,2);
  1628. SRAM_Write(ECHO_SMS_2+4,gGeneral_Buffer[10]);
  1629. SRAM_Write(ECHO_SMS_2+5,gGeneral_Buffer[11]);
  1630. gGeneral_Flag&=~LAND_TCP_ERROR_F_1;
  1631. Judge_SMS_Way();
  1632. }
  1633. /********************************************************
  1634. * 函数名：Set_Center_Num();
  1635. 作用域：本地文件调用
  1636. * 功能：
  1637. * 参数：  无
  1638. * 返回值：无
  1639. * 创建人：
  1640. *
  1641. * 修改历史：（每条详述）
  1642. ********************************************************/
  1644. void Set_Center_Num(void)
  1645. {
  1646. unsigned int i=0,j=0,k=0;
  1647. unsigned char cNum1,cNum2,cNum3;
  1648. //先读出Flash相应的第5个扇区的数据到buffer2中
  1649. OperateSPIEnd();ReadOnePageToBuffer2(FLASH_INFO2_ONE_2);OperateSPIEnd();
  1650. //1，处理接收中心服务号码
  1651. //========================================
  1652. i=1+9;
  1653. while(1)
  1654. {
  1655. if(gGeneral_Buffer[i]==0x00) break;
  1656. i++;
  1657. if(i>1+9+15) return;
  1658. //这里的15表示目标号码1不会超过15个数
  1659. }
  1660. cNum1=i-(1+9);
  1661. //如果中心服务号码的长度没有超过15，则目标号码有效
  1662. if( (i<=1+9+15)&&(cNum1>0) )
  1663. {
  1664. //计算出此中心服务的号码长度并写入buffer2中相应的位置
  1665. OperateSPIEnd();
  1666. WriteOneByteToBuffer2(CENTER_NUM_F_2,cNum1);
  1667. for(j=1+9;j<i;j++)
  1668. {
  1669. WriteNextByteToBuffer2(gGeneral_Buffer[j]);
  1670. }
  1671. OperateSPIEnd();
  1672. }
  1673. OperateSPIEnd();
  1674. //2，处理接收报警电话号码
  1675. //========================================
  1676. j=i+1;
  1677. while(1)
  1678. {
  1679. if(gGeneral_Buffer[j]==0x00) break;
  1680. j++;
  1681. if(j>1+i+15) return;
  1682. }
  1683. cNum2=j-i;
  1684. if( (j<=1+i+15)&&(cNum2>0) )
  1685. {
  1686. //计算出此报警号码的号码长度并写入buffer2
  1687. OperateSPIEnd();
  1688. WriteOneByteToBuffer2(ARALM_NUM_2,cNum2);
  1689. for(k=i+1;k<j;k++)
  1690. {
  1691. WriteNextByteToBuffer2(gGeneral_Buffer[k]);
  1692. }
  1693. OperateSPIEnd();
  1694. }
  1695. OperateSPIEnd();
  1696. //3，处理接收监听电话号码
  1697. //========================================
  1698. k=j+1;
  1699. while(1)
  1700. {
  1701. if(gGeneral_Buffer[k]==0x00) break;
  1702. k++;if(k>1+j+15) return;
  1703. }
  1704. cNum3=k-j;
  1705. if( (k<=j+1+15)&&(cNum3>0) )
  1706. {
  1707. }
  1708. //4，预留电话号码
  1709. //========================================
  1710. //5，将更新的设置重新写入相应的Flash
  1711. OperateSPIEnd();
  1712. RFlash_Sector(FLASH_INFO2_ONE_2);
  1713. Re430_Flash(1);
  1714. //6，接收处理完毕，则发送设置响应
  1715. //========================================
  1716. SRAM_Init();
  1717. SRAM_Write(ECHO_SMS_2+0,VAILD_2);
  1718. SRAM_Write(ECHO_SMS_2+1,CENTER_NUMECHO_UP);
  1719. SRAM_Write(ECHO_SMS_2+2,gGeneral_Buffer[5]);
  1720. SRAM_Write(ECHO_SMS_2+3,21);
  1721. Write_PartData_Sram(ECHO_SMS_2+3);
  1722. SRAM_Write(ECHO_SMS_2+3+18,0);
  1723. SRAM_Write(ECHO_SMS_2+3+19,gStatus3_Flag);
  1724. SRAM_Write(ECHO_SMS_2+3+20,gStatus2_Flag);
  1725. SRAM_Write(ECHO_SMS_2+3+21,gStatus1_Flag);
  1726. Judge_SMS_Way();
  1727. }
  1729. /********************************************************
  1730. * 函数名：Set_Area_Limit();
  1731. 作用域：本地文件调用
  1732. * 功能：
  1733. * 参数：  无
  1734. * 返回值：无
  1735. * 创建人：
  1736. * 修改历史：（每条详述）
  1737. 此程序的处理是将响应的区域参数存储在外部SRAM中，和buffer2中。并计算gArea_Par的值
  1738. ********************************************************/
  1739. void Set_Area_Limit(void)
  1740. {
  1741. unsigned int  i=0;
  1742. unsigned char Buffer2_Temp=0;
  1743. gArea_Par=0;
  1744. //1,存储外部的FLASH中。
  1745. OperateSPIEnd();ReadOnePageToBuffer2(FLASH_AREA_ONE_2);OperateSPIEnd();
  1746. WriteOneByteToBuffer2(FAREA1_LON_1_2,gGeneral_Buffer[1+9]);
  1747. for(i=1;i<68;i++)
  1748. {
  1749. WriteNextByteToBuffer2(gGeneral_Buffer[1+9+i]);
  1750. }
  1751. OperateSPIEnd();
  1752. RFlash_Sector(FLASH_AREA_ONE_2);
  1753. //3，存储外部的SRAM中的相应位置
  1754. SRAM_Init();
  1755. SRAM_Write( SAREA_DATA_FS,0x55); //存储区域的有效标志
  1756. for(i=0;i<68;i++)
  1757. {
  1758. SRAM_Write( (SAREA1_LON_1_2+i),gGeneral_Buffer[1+9+i]);
  1759. }
  1760. SRAM_Write( SAREA_DATA_FE,0xAA);
  1761. //4,显示当前区域的参数
  1762. gArea_Par=0;
  1763. SRAM_Init();
  1764. Buffer2_Temp=SRAM_Read(SAREA1_PAR_2);
  1765. if( Buffer2_Temp==0x55) {gArea_Par|=AREA1_ON;}
  1766. else if(Buffer2_Temp==0xAA) {gArea_Par|=AREA1_ON;gArea_Par|=AREA1_DIR;}
  1767. Buffer2_Temp=SRAM_Read(SAREA2_PAR_2);
  1768. if( Buffer2_Temp==0x55) {gArea_Par|=AREA2_ON;}
  1769. else if(Buffer2_Temp==0xAA) {gArea_Par|=AREA2_ON;gArea_Par|=AREA2_DIR;}
  1770. Buffer2_Temp=SRAM_Read(SAREA3_PAR_2);
  1771. if( Buffer2_Temp==0x55) {gArea_Par|=AREA3_ON;}
  1772. else if(Buffer2_Temp==0xAA) {gArea_Par|=AREA3_ON;gArea_Par|=AREA3_DIR;}
  1773. Buffer2_Temp=SRAM_Read(SAREA4_PAR_2);
  1774. if( Buffer2_Temp==0x55) {gArea_Par|=AREA4_ON;}
  1775. else if(Buffer2_Temp==0xAA) {gArea_Par|=AREA4_ON;gArea_Par|=AREA4_DIR;}
  1776. //4，接收到区域参数的响应
  1777. Load_Buffer1_Echo(ALLOW_AREA_ECHO_UP,gGeneral_Buffer[5]);
  1778. if(gArea_Par!=0) gStatus2_Flag|=AREA_VAILD_F_1;
  1779. else gStatus2_Flag&=~AREA_VAILD_F_1;
  1780. }
  1782. /********************************************************
  1783. * 函数名：Send_RecordData();
  1784. 作用域：本地文件调用
  1785. * 功能：
  1786. * 参数：  无
  1787. * 返回值：无
  1788. * 创建人：
  1789. * 修改历史：（每条详述）
  1790. 补充说明：将外部数据从新组包，发送给记录仪，然后等待回音
  1791. ********************************************************/
  1792. void Send_RecordData(void)
  1793. {
  1794.     unsigned int i=0;
  1795. gSMS_ACK[RECORD_EQUIPMENT_ACK]=gGeneral_Buffer[5];
  1796. for(i=11;i<=gGeneral_Buffer[0]-3;i++)
  1797. {
  1798. Send_COM1_Byte(gGeneral_Buffer[i]);
  1799. }
  1800. /*
  1801. #ifdef Debug_GSM_COM1
  1802. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  1803. for(i=11;i<=gGeneral_Buffer[0]-3;i++)
  1804. {
  1805. Send_COM1_Byte(ASCII(gGeneral_Buffer[i]/0x10));
  1806. Send_COM1_Byte(ASCII(gGeneral_Buffer[i]%0x10));
  1807. }
  1808. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  1809. #endif
  1810. */
  1812. }
  1813. /********************************************************
  1814. * 函数名：Set_Distance_Par();
  1815. 作用域：本地文件调用
  1816. * 功能：
  1817. * 参数：  无
  1818. * 返回值：无
  1819. * 创建人：
  1820. * 修改历史：（每条详述）
  1822. ********************************************************/
  1823. void Set_Distance_Par(void)
  1824. {
  1825. gCycle_Distance = gGeneral_Buffer[1+9];
  1826. gCycle_Distance <<= 8;
  1827. gCycle_Distance += gGeneral_Buffer[1+10];
  1829. if(gGeneral_Buffer[1+11]==1)
  1830. {
  1831. gON_OFF_Temp1 &=~ DISTANCE_TCP_ON_1;
  1832. gStatus3_Flag |= DISTANCE_ON_F_1;
  1833. }
  1834. else if(gGeneral_Buffer[1+11]==0)
  1835. {
  1836. gON_OFF_Temp1 |= DISTANCE_TCP_ON_1;
  1837. gStatus3_Flag &=~ DISTANCE_ON_F_1;
  1838. }
  1839. gCycle_TCP=0;
  1840. gCycle_GSM=0;
  1841. gCycle_Send_Status = NOP_DATA;
  1842. Load_Buffer1_Echo(SET_DISTANCE_DATA_UP,gGeneral_Buffer[5]);
  1843. //根据状态的改变，则需要重新更新扇区0中的数据，并重新计算校验核，写入扇区
  1844. //OperateSPIEnd();ReadOnePageToBuffer2(FLASH_INFO2_ONE_2);OperateSPIEnd();
  1845. Deal_Sector(FLASH_INFO2_ONE_2);
  1846. WriteOneByteToBuffer2(ON_OFF_V2_2,gON_OFF_Temp1);
  1847. OperateSPIEnd();
  1848. WriteOneByteToBuffer2(TCP_TIMER_2,0);
  1849. WriteNextByteToBuffer2(0);
  1850. WriteNextByteToBuffer2(0);
  1851. WriteNextByteToBuffer2(0);
  1852. WriteNextByteToBuffer2(gGeneral_Buffer[1+9]);
  1853. WriteNextByteToBuffer2(gGeneral_Buffer[1+10]);
  1854. OperateSPIEnd();
  1855. RFlash_Sector(FLASH_INFO2_ONE_2);
  1856. Re430_Flash(1);
  1857. gPublic_Flag &=~ SET_DISTANCE_OK_F_1;
  1858. gSet_Distance_Info_Count=WAIT_DISPINFO_TIME-2;
  1860. }
  1861. /********************************************************
  1862. * 函数名：Set_Phone_Num();
  1863. 作用域：本地文件调用
  1864. * 功能：
  1865. * 参数：  无
  1866. * 返回值：无
  1867. * 创建人：
  1868. * 修改历史：（每条详述）
  1869. 电话号码本的存储，固定2个扇区，每个扇区存储10个电话本
  1870. 一个电话本固定23个字节的长度，8(姓名)+13(电话号码)
  1871. 扇区的0xFF处，存储当前页的号码个数，如果值为0，则需要另外存储一个扇区页
  1872. ********************************************************/
  1873. void Set_Phone_Num(void)
  1874. {
  1875. Do_Phone_Note();
  1876. //存储作为第2类信息发送的响应数据的存储
  1877. //服务器端口设置成功后的响应
  1878. SRAM_Init();
  1879. SRAM_Write(ECHO_SMS_2+0,VAILD_2);
  1880. SRAM_Write(ECHO_SMS_2+1,ASK_PHONE_NUMECHO_UP);
  1881. SRAM_Write(ECHO_SMS_2+2,gGeneral_Buffer[5]);
  1882. SRAM_Write(ECHO_SMS_2+3,2);
  1883. SRAM_Write(ECHO_SMS_2+4,gGeneral_Buffer[1+9]);
  1884. SRAM_Write(ECHO_SMS_2+5,gGeneral_Buffer[1+10]);
  1885. Judge_SMS_Way();
  1886. }
  1887. /********************************************************
  1888. * 函数名：Watch_Way();
  1889. 作用域：本地文件调用
  1890. * 功能：
  1891. * 参数：  无
  1892. * 返回值：无
  1893. * 创建人：
  1894. * 修改历史：（每条详述）
  1896. ********************************************************/
  1897. void Watch_Way(void)
  1898. {
  1899. unsigned int i=0;
  1900. gWatch_Circle = gGeneral_Buffer[1+9];
  1901. gWatch_Circle <<= 8;
  1902. gWatch_Circle += gGeneral_Buffer[1+10];
  1904. gWatch_Time = gGeneral_Buffer[1+11];
  1905. gWatch_Time <<= 8;
  1906. gWatch_Time += gGeneral_Buffer[1+12];
  1908. gWatch_Count = gGeneral_Buffer[1+13];
  1909. gWatch_Count <<= 8;
  1910. gWatch_Count += gGeneral_Buffer[1+14];
  1912. if(gWatch_Circle==0)
  1913. {
  1914. if(gCycle_Send_Status==WATCH_DATA) gCycle_Send_Status=NOP_DATA;
  1915. gWatch_Count=0;gWatch_Time=0;
  1916. gWatch_Type=WATCH_TYPE_NULL;
  1917. Load_Buffer1_Echo(ASK_FREEWATCH_UP,gGeneral_Buffer[5]);
  1918. }
  1919. else
  1920. {
  1921. if(   (gCycle_Send_Status==TRACK_DATA_TIME)
  1922. ||(gCycle_Send_Status==TRACK_DATA_DISTANCE)
  1923. ||(gCycle_Send_Status==NOP_DATA)  )
  1924. {
  1925. gCycle_Send_Status=WATCH_DATA;
  1926. gPublic_Flag&=~ACCOFF_OK_F_1;
  1927. gPublic_Flag&=~ACC_OFF_UP_F_1;
  1928. gPublic_Flag&=~ACCOFF_TRACK_F_1;
  1929. ACC_OFF_Timer=0;
  1930. if(gWatch_Time!=0)
  1931. {
  1932. gWatch_Count=0;
  1933. gWatch_Type=WATCH_TYPE_TIME;
  1934. }
  1935. else
  1936. {
  1937. if(gWatch_Count!=0) gWatch_Type=WATCH_TYPE_COUNT;
  1938. else
  1939. {
  1940. Load_Buffer1_Echo(ASK_FREEWATCH_UP,gGeneral_Buffer[5]);
  1941. }
  1942. }
  1943. }
  1944. }
  1945. }
  1947. /********************************************************
  1948. * 函数名：Line_Data_Deal();
  1949. 作用域：本地文件调用
  1950. * 功能：
  1951. * 参数：  无
  1952. * 返回值：无
  1953. * 创建人：
  1954. * 修改历史：（每条详述）
  1956. ********************************************************/
  1957. void Line_Data_Deal(void)
  1958. {
  1959. unsigned int i=0,j=0;
  1960. unsigned char nTemp=0;
  1961. unsigned char Line_Num=0;
  1962. nTemp=gGeneral_Buffer[1+10]; //帧数(范围值1,2)
  1963. Line_Num=gGeneral_Buffer[1+11]; //当前线路点的个数(1--30)
  1964. SRAM_Init();
  1965. SRAM_Write(ECHO_SMS_2+0,VAILD_2);
  1966. SRAM_Write(ECHO_SMS_2+1,LINE_DATA_ECHO_UP);
  1967. SRAM_Write(ECHO_SMS_2+2,gGeneral_Buffer[5]);
  1968. SRAM_Write(ECHO_SMS_2+3,2);
  1969. SRAM_Write(ECHO_SMS_2+4,gGeneral_Buffer[1+9]);
  1970. SRAM_Write(ECHO_SMS_2+5,gGeneral_Buffer[1+10]);
  1971. Judge_SMS_Way();
  1972. if(Line_Num>30 )
  1973. {
  1974. Line_Num=30;
  1975. }
  1976. OperateSPIEnd();
  1977. //表示当前是第一页的数据
  1978. if(nTemp==1)
  1979. {
  1980. ReadOnePageToBuffer2(FLASH_LINEDATA1_ONE_2);
  1981. }
  1982. //表示是当前第二页的数据
  1983. else if(nTemp==2)
  1984. {
  1985. ReadOnePageToBuffer2(FLASH_LINEDATA2_ONE_2);
  1986. }
  1987. OperateSPIEnd();
  1989. //写buffer2中第一个数据
  1990. WriteOneByteToBuffer2(FLINE_DATA_1,gGeneral_Buffer[1+12]);
  1992. for(i=1;i<8*Line_Num;i++)
  1993. {
  1994. WriteNextByteToBuffer2(gGeneral_Buffer[1+12+i]);
  1995. }
  1996. for(i=8*Line_Num+1;i<264;i++)
  1997. {
  1998. WriteNextByteToBuffer2(0xFF);
  1999. }
  2000. OperateSPIEnd();
  2001. //写入当前页点的个数
  2002. WriteOneByteToBuffer2(FLINE_NUM_1,Line_Num);
  2003. WriteNextByteToBuffer2(~Line_Num);
  2004. OperateSPIEnd();
  2005. if(nTemp==1) RFlash_Sector(FLASH_LINEDATA1_ONE_2);
  2006. else if(nTemp==2) RFlash_Sector(FLASH_LINEDATA2_ONE_2);
  2007. Clear_Exter_WatchDog();
  2008. OperateSPIEnd();
  2009. //将扇区存储在相应的FLASH中
  2011. //判断是否接收完线路报警，如果接收完，则将FLAHS中的数据转移到SRAM中
  2012. if(gGeneral_Buffer[1+9]==gGeneral_Buffer[1+10])
  2013. {
  2014. Load_Info_Four();
  2015. }
  2016. }