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

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

GPS编程

开发平台：

Others

Do_Handle.C：源码内容
  1. /********************************************************
  2. * 文件名：  Do_Handle.h
  3. * 创建时间：2004年10月20日
  4. * 创建人：  
  5. * 版本号：  1.00
  6. * 功能：
  7. *
  8. * 修改历史：（每条详述）
  10. ********************************************************/
  11. #include <msp430x14x.h>
  12. #include "Handle_Protocol.h"
  13. #include "SPI45DB041.h"
  14. #include "TA_Uart.h"
  15. #include "General.h"
  16. #include "D_Buffer.h"
  17. #include "Other_Define.h"
  18. #include "Define_Bit.h"
  19. #include "Uart01.h"
  20. #include "Sub_C.h"
  21. #include "M22_AT.h"
  22. #include "Do_Handle.h"
  23. #include "W_Protocol.h"
  24. #include "Disp_Protocol.h"
  25. #include "Do_SRAM.h"
  26. #include "Msp430_Flash.h"
  28. /*
  29. #include "Check_GSM.h"
  30. #include "Do_Reset.h"
  31. #include "Main_Init.h"
  32. #include "Do_GSM.h"
  33. */
  34. //#define Debug_GSM_COM1
  35. unsigned char Check_Handle_Command(void);
  36. void Handle_Dailing(unsigned char nPoint_Temp);
  37. void Handle_Answer(void);
  38. void Write_Dail_Record(unsigned char nPhone_Length);
  39. void Read_Dail_Record(unsigned char nItem);
  40. void Write_Talk_Record(unsigned char nPhone_Length);
  41. void Read_Talk_Record(unsigned char nItem);
  42. void Handle_ReadOnePage_Data(unsigned char Page_H,unsigned char Page_L);
  43. //void Handle_EraseOnePage_Data(unsigned char Page_H,unsigned char Page_L);
  44. void Move_Right_Item(unsigned char Start_Item,unsigned char End_Item,unsigned char Move_Count);
  45. //void Handle_Set_NumPhone(void);
  46. //void Handle_Set_TCP_Par(void);
  47. //unsigned char  Check_All_Flash(void);
  48. unsigned int  Check_Allow_Phone(unsigned char Length_Phone);
  49. void Read_Phone_Note_Record(unsigned char nItem);
  50. void Handle_Set_Par(unsigned char nLength);
  51. void Handle_Set_TcpIp(void);
  52. void Handle_Set_Time(void);
  53. void Handle_Ask_Par(void);
  54. void Handle_Set_SMS(void);
  55. void Handle_Set_Phone(unsigned char nLength);
  56. void Handle_Set_Dis(void);
  57. void Handle_Test_Sram(void);
  58. /********************************************************
  59. * 函数名：Do_Handle_Module
  60. 作用域：外部文件调用
  61. * 功能： 与手柄通讯模块。
  62. * 参数：
  63. * 返回值：
  64. * 创建人：
  65. *
  66. * 修改历史：（每条详述）
  67. 补充说明：
  68. 收到的每一个手柄数据存储在gGeneral_Buffer[]中。
  69. 由Check_Handle_Command()子程序处理接收在gGeneral_Buffer中的数据
  70. 根据信令的不一样，需要分别处理，需要通过有G20的AT操作的指令则直接
  71. 存储在buffer1中的0x5D----0x7A 区域共30个字节。
  73. 手柄与电话有关的AT指令包括如下几类
  74. 这里只存储AT指令的类型有如下几类：
  75. 1，拨号，2，挂机，3，接听，4，DMTF，5，音量调节，6，CSCA的设置
  76. 根据上面的情形，以30个字节足够存储的
  78. 还有一类的指令则是需要直接处理的，比如说电话记录的查询，密码设置等等
  80. 0x5D----0x7A 区域的分配如下：
  81. 0x5D--  存储后面数据是否处理完的标志，为1则表示后面的数据未处理，为0则表示
  82. 已经处理完毕，可以在填写下个指令。
  83. 0x5E-- 存储相关的AT指令的类型。如手柄拨号，挂机等等
  84. 0x5F-- 存储后面数据的长度，如需要拨号的电话号码等。如果后面无任何数据，则写0。
  85. ********************************************************/
  86. void Do_Handle_Module(void)
  87. {
  88. unsigned int i=0,k=0;
  89. unsigned char nHandle_Piont_Temp=0;
  90. //指令的重发机制，目前只针对主控发送给手柄的挂机指令和接通指令
  91. if(   (gSend_Handle_Timer>2)
  92. &&((gSys_Handle==MAIN_HANG_UP)||(gSys_Handle==MAIN_TALKING))  )
  93. {
  94. gSend_Handle_Timer=0;
  95. Send_COM3_Load(4,gSys_Handle,0);
  96. gRe_Send_Count++;
  97. if(gRe_Send_Count>=5)
  98. {
  99. gRe_Send_Count=0;
  100. gSys_Handle=0;
  101. }
  102. }
  103. if(gDTMF_SAVE[0]>0)
  104. {
  105. SRAM_Init();
  106. if(SRAM_Read(PHONE_AT_2)==NULL_2)
  107. {
  108. OperateSPIEnd();
  109. k=gDTMF_SAVE[1];
  110. gDTMF_SAVE[0]--;
  111. for(i=0;i<gDTMF_SAVE[0];i++)
  112. {
  113. gDTMF_SAVE[i+1]=gDTMF_SAVE[i+2];
  114. }
  115. SRAM_Init();
  116. SRAM_Write(PHONE_AT_2+0,VAILD_2);
  117. SRAM_Write(PHONE_AT_2+1,H_DTMF);
  118. SRAM_Write(PHONE_AT_2+2,1);
  119. SRAM_Write(PHONE_AT_2+3,k);
  120. }
  121. OperateSPIEnd();
  122. }
  123. if( (gHandle_Receive_Over>40)&&(gHandle_Buffer_Point>0) )
  124. {
  125. #ifdef Debug_GSM_COM1
  126. Send_COM1_Byte(ASCII(gHandle_Buffer_Point/10));
  127. Send_COM1_Byte(ASCII(gHandle_Buffer_Point%10));
  128. Send_COM1_Byte('[');
  129. Send_COM1_String(gHandle_Buffer,gHandle_Buffer_Point);
  130. Send_COM1_Byte(']');
  131. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  132. #endif
  133. //作为判断手柄是否被摘除掉或者手柄出现程序异常的判
  134. //接收完数据，则开始处理数据
  135. k=Check_Handle_Command();
  136. nHandle_Piont_Temp=gHandle_Buffer_Point;
  137. gHandle_Buffer_Point=0;
  138. switch(k)
  139. {
  140. /********************************************************
  141. 0,手柄的指令ECHO（手柄命令）
  142. ********************************************************/
  143. case HANDLE_ECHO:
  144. {
  145. gHandle_OnLine_Timer=0;
  146. gStatus1_Flag &=~ HANDLE_ON_0_F_1;
  147. gStatus1_Flag |= HANDLE_ON_1_F_1;
  148. //判断返回的是那一个指令的ECHO
  149. if( (gSys_Handle==MAIN_HANG_UP)&&(gHandle_Buffer[3]==MAIN_HANG_UP) )
  150. {
  151. gRe_Send_Count=0;
  152. gSys_Handle=0;
  153. }
  154. else if( (gSys_Handle==MAIN_TALKING)&&(gHandle_Buffer[3]==MAIN_TALKING) )
  155. {
  156. gRe_Send_Count=0;
  157. gSys_Handle=0;
  158. }
  159. break;
  160. }
  161. /********************************************************
  162. 1,手柄拨号（手柄命令）
  163. ********************************************************/
  164. case HANDLE_DIAL:
  165. {
  166. gCommon_Flag&=~CHECK_RINGPHONE_F_1;
  167. gHandle_OnLine_Timer=0;
  168. gStatus1_Flag &=~ HANDLE_ON_0_F_1;
  169. gStatus1_Flag |= HANDLE_ON_1_F_1;
  170. k=SRAM_Read(PHONE_AT_2);
  171. i=SRAM_Read(PHONE_AT_2+1);
  172. if( (i==H_HUNGUP)&&(k==VAILD_2) )
  173. {
  174. Send_COM3_Load(5,MAIN_RETURN_PHONE_ECHO,COMMAND_ERROR);
  175. }
  176. else
  177. {
  178. Handle_Dailing(nHandle_Piont_Temp);
  179. }
  180. break;
  181. }
  182. /********************************************************
  183. 2,手柄接听（手柄命令）
  184. ********************************************************/
  185. case  HANDLE_ANSWER:
  186. {
  187. gCommon_Flag&=~CHECK_RINGPHONE_F_1;
  188. gHandle_OnLine_Timer=0;
  189. gStatus1_Flag &=~ HANDLE_ON_0_F_1;
  190. gStatus1_Flag |= HANDLE_ON_1_F_1;
  191. Send_COM3_Load(5,MAIN_RETURN_PHONE_ECHO,COMMAND_OK);
  192. Handle_Answer();
  193. break;
  194. }
  195. /********************************************************
  196. 3,手柄挂机（手柄命令）
  197. ********************************************************/
  198. case HANDLE_HANGUP:
  199. {
  200. gCommon_Flag&=~CHECK_RINGPHONE_F_1;
  201. gHandle_OnLine_Timer=0;
  202. gStatus1_Flag &=~ HANDLE_ON_0_F_1;
  203. gStatus1_Flag |= HANDLE_ON_1_F_1;
  204. Send_COM3_Load(5,MAIN_RETURN_PHONE_ECHO,COMMAND_OK);
  205. //如果这个时候处于监听状态，则下面不用处理
  206. if( (gGeneral_Flag&MONITOR_ON_F_1)||(gPhone_Status==ACTIVE_MONITOR))
  207. {
  208. gHandle_Buffer_Point=0;
  209. }
  210. else
  211. {
  212. SRAM_Init();
  213. SRAM_Write(PHONE_AT_2+0,VAILD_2);
  214. SRAM_Write(PHONE_AT_2+1,H_HUNGUP);
  215. SRAM_Write(PHONE_AT_2+2,0);
  216. }
  217. break;
  218. }
  219. /********************************************************
  220. 4,手柄调节音量（手柄命令）
  221. ********************************************************/
  222. case HANDLE_VOL:
  223. {
  224. gCommon_Flag&=~CHECK_RINGPHONE_F_1;
  225. gHandle_OnLine_Timer=0;
  226. gStatus1_Flag &=~ HANDLE_ON_0_F_1;
  227. gStatus1_Flag |= HANDLE_ON_1_F_1;
  228. SRAM_Init();
  229. SRAM_Write(PHONE_AT_2+0,VAILD_2);
  230. SRAM_Write(PHONE_AT_2+1,H_VOLADJ);
  231. SRAM_Write(PHONE_AT_2+2,1);
  232. SRAM_Write(PHONE_AT_2+3,gHandle_Buffer[3]);
  233. break;
  234. }
  235. /********************************************************
  236. 5,手柄的DTMF（手柄命令）
  237. ********************************************************/
  238. case HANDLE_DTMF:
  239. {
  240. gCommon_Flag&=~CHECK_RINGPHONE_F_1;
  241. gHandle_OnLine_Timer=0;
  242. gStatus1_Flag &=~ HANDLE_ON_0_F_1;
  243. gStatus1_Flag |= HANDLE_ON_1_F_1;
  244. if(gDTMF_SAVE[0]<sizeof(gDTMF_SAVE)-1)
  245. {
  246. gDTMF_SAVE[0]++;
  247. gDTMF_SAVE[gDTMF_SAVE[0]]=gHandle_Buffer[3];
  248. }
  249. break;
  250. }
  251. /********************************************************
  252. 6,手柄读最新拨出电话号码（手柄命令）
  253. ********************************************************/
  254. case HANDLE_READ_DIAL:
  255. {
  256. gCommon_Flag&=~CHECK_RINGPHONE_F_1;
  257. gHandle_OnLine_Timer=0;
  258. gStatus1_Flag &=~ HANDLE_ON_0_F_1;
  259. gStatus1_Flag |= HANDLE_ON_1_F_1;
  260. if(gPhone_Status==ACTIVE_MONITOR);
  261. else if(gGeneral_Flag&TCP_PHONE_F_1)
  262. {
  263. gCommon_Flag|=ALLOW_HANGUP_PHONE_F_1;
  264. }
  265. //while(gDelay_Flash_Timer<3) {Clear_Exter_WatchDog();}
  266. Read_Dail_Record(gHandle_Buffer[3]);
  267. gDelay_Flash_Timer=0;
  268. break;
  269. }
  270. /********************************************************
  271. 7,手柄读前一个拨出电话号码（手柄命令）
  272. ********************************************************/
  273. case HANDLE_UP_DIAL:
  274. {
  275. gCommon_Flag&=~CHECK_RINGPHONE_F_1;
  276. gHandle_OnLine_Timer=0;
  277. gStatus1_Flag &=~ HANDLE_ON_0_F_1;
  278. gStatus1_Flag |= HANDLE_ON_1_F_1;
  279. /*
  280. if(gPhone_Status==ACTIVE_MONITOR);
  281. else if(gGeneral_Flag&TCP_PHONE_F_1)
  282. {
  283. gCommon_Flag|=ALLOW_HANGUP_PHONE_F_1;
  284. }
  285. &*/
  286. //while(gDelay_Flash_Timer<3) {Clear_Exter_WatchDog();}
  287. Read_Dail_Record(gHandle_Buffer[3]);
  288. gDelay_Flash_Timer=0;
  289. break;
  290. }
  291. /********************************************************
  292. 8,手柄读后一个拨出电话号码（手柄命令）
  293. ********************************************************/
  294. case HANDLE_DOWN_DIAL:
  295. {
  296. gCommon_Flag&=~CHECK_RINGPHONE_F_1;
  297. gHandle_OnLine_Timer=0;
  298. gStatus1_Flag &=~ HANDLE_ON_0_F_1;
  299. gStatus1_Flag |= HANDLE_ON_1_F_1;
  300. /*
  301. if(gPhone_Status==ACTIVE_MONITOR);
  302. else if(gGeneral_Flag&TCP_PHONE_F_1)
  303. {
  304. gCommon_Flag|=ALLOW_HANGUP_PHONE_F_1;
  305. }
  306. */
  307. //while(gDelay_Flash_Timer<3) {Clear_Exter_WatchDog();}
  308. Read_Dail_Record(gHandle_Buffer[3]);
  309. gDelay_Flash_Timer=0;
  310. break;
  311. }
  312. /********************************************************
  313. 9,手柄读最新一次的通话记录（手柄命令）
  314. ********************************************************/
  315. /*
  316. case HANDLE_READ_TALK:
  317. {
  318. gHandle_OnLine_Timer=0;
  319. if(gPhone_Status==ACTIVE_MONITOR);
  320. else if(gGeneral_Flag&TCP_PHONE_F_1)
  321. {
  322. gCommon_Flag|=ALLOW_HANGUP_PHONE_F_1;
  323. }
  324. //while(gDelay_Flash_Timer<3) {Clear_Exter_WatchDog();}
  325. Read_Talk_Record(gHandle_Buffer[3]);
  326. gDelay_Flash_Timer=0;
  328. break;
  329. }
  330. */
  331. /********************************************************
  332. 10,手柄读前一个通话记录（手柄命令）
  333. ********************************************************/
  334. /*
  335. case HANDLE_UP_TALK:
  336. {
  337. gHandle_OnLine_Timer=0;
  338. if(gPhone_Status==ACTIVE_MONITOR);
  339. else if(gGeneral_Flag&TCP_PHONE_F_1)
  340. {
  341. gCommon_Flag|=ALLOW_HANGUP_PHONE_F_1;
  342. }
  343. //while(gDelay_Flash_Timer<3) {Clear_Exter_WatchDog();}
  344. Read_Talk_Record( gHandle_Buffer[3] );
  345. gDelay_Flash_Timer=0;
  347. break;
  348. }
  349. */
  350. /********************************************************
  351. 11,手柄读后一个通话记录（手柄命令）
  352. ********************************************************/
  353. /*
  354. case HANDLE_DOWN_TALK:
  355. {
  356. gHandle_OnLine_Timer=0;
  357. if(gPhone_Status==ACTIVE_MONITOR);
  358. else if(gGeneral_Flag&TCP_PHONE_F_1)
  359. {
  360. gCommon_Flag|=ALLOW_HANGUP_PHONE_F_1;
  361. }
  362. //while(gDelay_Flash_Timer<3) {Clear_Exter_WatchDog();}
  363. Read_Talk_Record(gHandle_Buffer[3]);
  364. gDelay_Flash_Timer=0;
  366. break;
  367. }
  368. */
  369. /********************************************************
  370. 12,手柄送给主控存储的通话记录（手柄命令）
  371. ********************************************************/
  372. /*
  373. case HANDLE_SEND_TALK:
  374. {
  375. gHandle_OnLine_Timer=0;
  376. if(gPhone_Status==ACTIVE_MONITOR);
  377. else if(gGeneral_Flag&TCP_PHONE_F_1)
  378. {
  379. gCommon_Flag|=ALLOW_HANGUP_PHONE_F_1;
  380. }
  381. //while(gDelay_Flash_Timer<3) {Clear_Exter_WatchDog();}
  382. Init_Buffer2();
  383. Write_Talk_Record(nHandle_Piont_Temp);
  384. gDelay_Flash_Timer=0;
  385. Init_Buffer2();
  387. break;
  388. }
  389. */
  390. /********************************************************
  391. 13,手柄送被盗设防命令（手柄命令）,取消
  392. ********************************************************/
  393. /*
  394. case HANDLE_SET_DEFENCE:
  395. {
  396. gHandle_OnLine_Timer=0;
  397. break;
  398. }
  399. */
  400. /********************************************************
  401. 14,手柄解除设防命令（手柄命令）
  402. ********************************************************/
  403. /*
  404. case HANDLE_FREE_DEFENCE:
  405. {
  406. gHandle_OnLine_Timer=0;
  407. break;
  408. }
  409. */
  410. /********************************************************
  411. 15,手柄提取短消息中心号码（手柄命令,暂时取消）
  412. ********************************************************/
  413. /*
  414. case HANDLE_ASK_CENTER_NUM:
  415. {
  416. gHandle_OnLine_Timer=0;
  417. break;
  418. }
  419. */
  420. /********************************************************
  421. 16,手柄设置短消息中心号码（手柄命令，暂时取消）
  422. ********************************************************/
  423. /*
  424. case HANDLE_SET_CENTER_NUM:
  425. {
  426. break;
  427. }
  428. */
  429. /********************************************************
  430. 17,手柄更改设置密码（手柄命令）
  431. ********************************************************/
  432. /*
  433. case HANDLE_PASSWORD:
  434. {
  435. break;
  436. }
  437. */
  438. /********************************************************
  439. 18,手柄进行对车载终端进行出厂设置操作（初始化系统）
  440. ********************************************************/
  441. case HANDLE_DEFAULT_SET:
  442. {
  443. gHandle_OnLine_Timer=0;
  444. //1,清除信息区1
  445. OperateSPIEnd();EraseOnePage(FLASH_INFO1_ONE_2);OperateSPIEnd();
  446. OperateSPIEnd();EraseOnePage(FLASH_INFO1_TWO_2);OperateSPIEnd();
  447. Clear_Exter_WatchDog();
  448. RX2_Ready();RX3_Ready();RX4_Ready();
  449. //2,清除信息区2
  450. OperateSPIEnd();EraseOnePage(FLASH_INFO2_ONE_2);OperateSPIEnd();
  451. OperateSPIEnd();EraseOnePage(FLASH_INFO2_TWO_2);OperateSPIEnd();
  452. Clear_Exter_WatchDog();
  453. RX2_Ready();RX3_Ready();RX4_Ready();
  454. //3,清除电话号码拨出和通话记录区域
  455. OperateSPIEnd();EraseOnePage(FLASH_DIAL_PHONE);OperateSPIEnd();
  456. OperateSPIEnd();EraseOnePage(FLASH_RECORD_PHONE_2);OperateSPIEnd();
  457. Clear_Exter_WatchDog();
  458. RX2_Ready();RX3_Ready();RX4_Ready();
  459. //4,清除存储区域数据的区域
  460. OperateSPIEnd();EraseOnePage(FLASH_AREA_ONE_2);OperateSPIEnd();
  461. OperateSPIEnd();EraseOnePage(FLASH_AREA_TWO_2);OperateSPIEnd();
  462. Clear_Exter_WatchDog();
  463. RX2_Ready();RX3_Ready();RX4_Ready();
  464. //5,清除存储线路数据的区域1的数据
  465. OperateSPIEnd();EraseOnePage(FLASH_LINEDATA1_ONE_2);OperateSPIEnd();
  466. OperateSPIEnd();EraseOnePage(FLASH_LINEDATA1_TWO_2);OperateSPIEnd();
  467. Clear_Exter_WatchDog();
  468. RX2_Ready();RX3_Ready();RX4_Ready();
  469. //6,清除存储线路数据的区域2的数据
  470. OperateSPIEnd();EraseOnePage(FLASH_LINEDATA2_ONE_2);OperateSPIEnd();
  471. OperateSPIEnd();EraseOnePage(FLASH_LINEDATA2_TWO_2);OperateSPIEnd();
  472. Clear_Exter_WatchDog();
  473. RX2_Ready();RX3_Ready();RX4_Ready();
  474. //7,清除存储电话号码本的区域数据
  475. OperateSPIEnd();EraseOnePage(FLASH_PHONE_INFO_ONE_2);OperateSPIEnd();
  476. OperateSPIEnd();EraseOnePage(FLASH_PHONE_INFO_TWO_2);OperateSPIEnd();
  477. Clear_Exter_WatchDog();
  478. RX2_Ready();RX3_Ready();RX4_Ready();
  479. //
  480. for(i=0;i<128;i++)
  481. {
  482. gGeneral_Buffer[i]=0xFF;
  483. }
  484. Write_SegAB(0);
  485. gTimer=0;
  486. while(gTimer<3000){Clear_Exter_WatchDog();}
  487. RX2_Ready();RX3_Ready();RX4_Ready();
  488. Write_SegAB(1);
  489. gTimer=0;
  490. while(gTimer<1500){Clear_Exter_WatchDog();}
  491.     TACTL|=TASSEL1;         //输入时钟选择MCLK
  492.     TACTL|=TACLR;           //定时器A清除位CLR清零
  493.     TACTL|=MC1;             //定时器A选择连续增记数模式
  494.     TAR=0;                  //定时器A的值清零
  495.     TACCTL0|=OUT;           //TXD2 Idle as Mark
  496. TACCTL1|=OUT;           //TXD3 Idle as Mark
  497. TACCTL2|=OUT;           //TXD4 Idle as Mark
  498. gON_OFF_Temp0=0xFF;gON_OFF_Temp1=0xFF;gON_OFF_Temp2=0xFF;
  499. gAlarm_Type=0;gWatch_Type=0;gCycle_Send_Status=NOP_DATA;
  500. gStatus2_Flag&=~ROB_ALARM_F_1;
  501. //设防状态清除
  502. gInternal_Flag&=~VEHICLE_DEFENCE_F_1;
  503. gStatus1_Flag&=~DEFENCE_STATUS_F_1;
  504. //行车轨迹上传的间隔
  505. gCycle_GSM=0;gCycle_TCP=0;
  506. //TCP的IP地址无效
  507. gGeneral_Flag&=~NUM1_VAILD_F_1;
  508. gGeneral_Flag&=~TCP_IP_VALID_1;
  509. gStatus2_Flag&=~IP_VAILD_F_1;
  510. gStatus2_Flag&=~TCP_ON_OFF_F_1;
  511. RX2_Ready();RX3_Ready();RX4_Ready();
  512. Waiting_Allow_Send();
  513. Send_COM3_SubProgram(5,MAIN_RETURN_INIT,COMMAND_OK);
  514. gTimer=0;
  515. gDelay_Flash_Timer=0;
  516. while(gTimer<50){}
  517. break;
  518. }
  519. /********************************************************
  520. 19,手柄返回是否开机的状态（手柄命令）
  521. ********************************************************/
  522. case HANDLE_STATUS:
  523. {
  524. //如果接收到此命令，则根据命令字，来判断是否车载电话是否处于开机和关机状态，同时清除计时判断手柄未接的计数变量
  525. //判断手柄显示终端关机
  526. gHandle_OnLine_Timer=0;
  527. if( gHandle_Buffer[3]==0 )
  528. {
  529. gStatus1_Flag |= HANDLE_ON_0_F_1;
  530. gStatus1_Flag &=~ HANDLE_ON_1_F_1;
  531. }
  532. //判断手柄显示终端开机
  533. else if ( gHandle_Buffer[3]==1 )
  534. {
  535. gStatus1_Flag &=~ HANDLE_ON_0_F_1;
  536. gStatus1_Flag |= HANDLE_ON_1_F_1;
  537. }
  538. break;
  539. }
  540. /********************************************************
  541. 20,手柄查询指定位置的电话号码本的内容（手柄命令）
  542. ********************************************************/
  543. case HANDLE_PHONE_NOTE:
  544. {
  545. gHandle_OnLine_Timer=0;
  546. gStatus1_Flag &=~ HANDLE_ON_0_F_1;
  547. gStatus1_Flag |= HANDLE_ON_1_F_1;
  548. Read_Phone_Note_Record(gHandle_Buffer[3]);
  549. break;
  550. }
  551. /********************************************************
  552. A1,手柄对指定页数据的擦除（测试命令）
  553. ********************************************************/
  554. /*
  555. case HANDLE_ERASE_PAGEDATA:
  556. {
  557. break;
  558. }
  559. */
  560. /********************************************************
  561. A2,手柄对指定页数据的读取（测试命令）
  562. ********************************************************/
  563. case HANDLE_READ_PAGEDATA:
  564. {
  565. gHandle_OnLine_Timer=0;
  566. Handle_ReadOnePage_Data(gHandle_Buffer[3],gHandle_Buffer[4]);
  567. break;
  568. }
  569. /********************************************************
  570. A3,通过手柄(COM3)设置目标电话号码1（测试命令）
  571. ********************************************************/
  572. /*
  573. case HANDLE_SET_PHONE_NUM:
  574. {
  575. break;
  576. }
  577. */
  578. /********************************************************
  579. A4,通过手柄(COM3)发送检查整个FLASH（测试命令）根据情况，则只检查buffer1和buffer2的情况
  580. ********************************************************/
  581. /*
  582. case HANDLE_CHECK_FLASH:
  583. {
  584. break;
  585. }
  586. */
  587. /********************************************************
  588. A5,通过手柄(COM3)发送检查GPS数据格式有效性（测试命令）
  589. ********************************************************/
  590. /*
  591. case HANDLE_CHECK_GPS:
  592. {
  593. break;
  594. }
  595. */
  596. /********************************************************
  597. A6,通过手柄(COM3)使GSM模块自发自收一个SMS的命令（测试命令）
  598. ********************************************************/
  599. /*
  600. case HANDLE_CHECK_SMS:
  601. {
  602. break;
  603. }
  604. */
  605. /********************************************************
  606. A7,手柄接口调试监听语音电路(测试命令)
  607. ********************************************************/
  608. case HANDLED_ACTIVE_MONITOR:
  609. {
  610. gHandle_OnLine_Timer=0;
  611. SRAM_Init();
  612. SRAM_Write(PHONE_AT_2+0,VAILD_2);
  613. SRAM_Write(PHONE_AT_2+1,M_DIAL);
  614. SRAM_Write(PHONE_AT_2+2,gHandle_Buffer[1]-4);
  615. for(i=0;i<gHandle_Buffer[1]-4;i++)
  616. {
  617. SRAM_Write(PHONE_AT_2+3+i,gHandle_Buffer[i+3]);
  618. }
  619. break;
  620. }
  621. /********************************************************
  622. A8,手柄插除所有的历史轨迹的数据（测试命令）
  623. ********************************************************/
  624. /*
  625. case HANDLE_ERASE_ALLPASS:
  626. {
  627. break;
  628. }
  629. */
  630. /********************************************************
  631. A8-1,测试外部SRAM的数据正确性（测试命令）
  632. ********************************************************/
  633. case HANDLE_TEST_SRAM:
  634. {
  635. gHandle_OnLine_Timer=0;
  636. Handle_Test_Sram();
  637. break;
  638. }
  639. /********************************************************
  640. A9,手柄设置相关TCP的参数（测试命令）
  641. 做测试用，设置IP和PORT后，则需要开启进行TCP登陆的操作
  642. 以测试此登陆TCP的功能正确
  643. ********************************************************/
  644. /*
  645. case HANDLE_SET_TCP:
  646. {
  647. break;
  648. }
  649. */
  650. /********************************************************
  651. A10,手柄读取版本号（测试命令）
  652. ********************************************************/
  653. case HNADLE_READ_EDITION:
  654. {
  655. gHandle_OnLine_Timer=0;
  656. if(gHandle_Buffer[3]=(char)(~gHandle_Buffer[2]))
  657. {
  658. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  659. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  660. for(i=0;i<35;i++) Send_COM1_Byte('=');
  661. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  662. for(i=0;i<sizeof(String_A);i++)
  663. {
  664. Send_COM1_Byte(String_A[i]-1);
  665. Send_COM1_Byte(String_EDIT[i]+1);
  666. }
  667. for(i=0;i<35;i++) Send_COM1_Byte('=');
  668. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  669. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  670. }
  671. break;
  672. }
  673. /********************************************************
  674. A12,手柄接口设置基本参数（参数设置命令）
  675. ********************************************************/
  676. case HANDLE_SET_PAR:
  677. {
  678. gHandle_OnLine_Timer=0;
  679. Handle_Set_Par(nHandle_Piont_Temp);
  680. break;
  681. }
  682. /********************************************************
  683. A13,手柄接口设置TCP的相关参数（参数设置命令）
  684. ********************************************************/
  685. case HANDLE_SET_TCPIP:
  686. {
  687. Handle_Set_TcpIp();
  688. break;
  689. }
  690. /********************************************************
  691. A14,手柄接口设置时间间隔的相关参数（参数设置命令）
  692. ********************************************************/
  693. case HANDLE_SET_TIME:
  694. {
  695. gHandle_OnLine_Timer=0;
  696. Handle_Set_Time();
  697. break;
  698. }
  699. /********************************************************
  700. A15,手柄接口设置短消息预置的相关参数（参数设置命令）
  701. ********************************************************/
  702. case HANDLE_SET_SMS:
  703. {
  704. gHandle_OnLine_Timer=0;
  705. Handle_Set_SMS();
  706. break;
  707. }
  708. /********************************************************
  709. A16,手柄接口设置电话号码本设置置的相关参数（参数设置命令）
  710. ********************************************************/
  711. case HANDLE_SET_PHONE_NOTE:
  712. {
  713. Handle_Set_Phone(nHandle_Piont_Temp);
  714. break;
  715. }
  716. /********************************************************
  717. A17,手柄接口设置按距离上传数据的相关参数（参数设置命令）
  718. ********************************************************/
  719. case HANDLE_SET_DISTANCE:
  720. {
  721. gHandle_OnLine_Timer=0;
  722. Handle_Set_Dis();
  723. break;
  724. }
  725. /********************************************************
  726. A18,（查询所有参数设置命令的返回的命令）
  727. ********************************************************/
  728. case HANDLE_ASK_PAR:
  729. {
  730. gHandle_OnLine_Timer=0;
  731. Handle_Ask_Par();
  732. break;
  733. }
  734. /********************************************************
  735. A19,手柄端口人为设置目标号码在buffer1中错误（调试命令）
  736. ********************************************************/
  737. /*
  738. case HANDLE_ERROR_NUM:
  739. {
  740. break;
  741. }
  742. */
  743. /********************************************************
  744. A20,手柄接口端口人为设置短消息中心号码在buffer1中错误（调试命令）
  745. ********************************************************/
  746. /*
  747. case HANDLE_ERROR_CENTER:
  748. {
  749. break;
  750. }
  751. */
  752. /********************************************************
  753. A21,手柄端口 人为设置430两个信息扇区的错误（调试命令）
  754. ********************************************************/
  755. /*
  756. case HANDLE_ERROR_IP:
  757. {
  759. for(i=0;i<128;i++)
  760. {
  761. gGeneral_Buffer[i]=0xFF;
  762. }
  763. Write_SegAB(gHandle_Buffer[3]);
  765. break;
  766. }
  767. */
  768. /********************************************************
  769. A22,手柄端口 人为设置在扇区中的错误（调试命令）
  770. ********************************************************/
  771. /*
  772. case HANDLE_ERROR_PORT:
  773. {
  775. OperateSPIEnd();ReadOnePageToBuffer2((int)gHandle_Buffer[3]);OperateSPIEnd();
  776. if( (gHandle_Buffer[3]==1)||(gHandle_Buffer[3]==2) )
  777. {
  778. if(gHandle_Buffer[4]==0) k=TARGET_NUMBER1_F_2;
  779. else if(gHandle_Buffer[4]==1) k=GPRS_IP_ADDRESS1_F_2;
  780. WriteOneByteToBuffer2(k+gHandle_Buffer[5],0x47);
  781. for(i=0;i<gHandle_Buffer[6];i++)
  782. {
  783. WriteNextByteToBuffer2(0x47);
  784. }
  785. OperateSPIEnd();
  786. if(gHandle_Buffer[7]==1)
  787. {
  788. RFlash_Sector((int)gHandle_Buffer[3]);
  789. }
  790. else
  791. {
  792. WriteBuffer2ToPage((int)gHandle_Buffer[3]);
  793. gTimer=0;
  794. while(gTimer<1000){Clear_Exter_WatchDog();}
  795. }
  796. }
  798. break;
  799. }
  800. */
  801. /********************************************************
  802. A23,手柄端口人为设置在扇区中的错误（调试命令）
  803. ********************************************************/
  804. /*
  805. case HANDLE_SET_ALARM:
  806. {
  807. break;
  808. }
  809. */
  810. /********************************************************
  811. A25,手柄端口 读取数据从外部的SRAM中相应的位置（调试命令）
  812. ********************************************************/
  813. /*
  814. case HANDLE_READ_SRAM:
  815. {
  816. break;
  817. }
  818. */
  819. /********************************************************
  820. A26,手柄端口 设置命令初始化显示终端
  821. ********************************************************/
  822. case HANDLE_CLEAR_DISP:
  823. {
  824. gHandle_OnLine_Timer=0;
  825. if(gDisp_Buffer_Point+6+2<=sizeof(gDisp_Buffer))
  826. {
  827. gDisp_Buffer[gDisp_Buffer_Point]=6+2;
  828. gDisp_Buffer_Point++;
  829. gDisp_Buffer[gDisp_Buffer_Point]=0;
  830. gDisp_Buffer_Point++;
  831. gDisp_Buffer[gDisp_Buffer_Point]='@';
  832. gDisp_Buffer_Point++;
  833. gDisp_Buffer[gDisp_Buffer_Point]='%';
  834. gDisp_Buffer_Point++;
  835. gDisp_Buffer[gDisp_Buffer_Point]=6;
  836. gDisp_Buffer_Point++;
  837. gDisp_Buffer[gDisp_Buffer_Point]=DISP_CLEAR_DOWN;
  838. gDisp_Buffer_Point++;
  839. gDisp_Buffer[gDisp_Buffer_Point]='$';
  840. gDisp_Buffer_Point++;
  841. gDisp_Buffer[gDisp_Buffer_Point]='&';
  842. gDisp_Buffer_Point++;
  843. }
  844. break;
  845. }
  847. /********************************************************
  848. 其他
  849. ********************************************************/
  850. default:
  851. break;
  852. }
  853. gHandle_Buffer_Point=0;
  854. for(i=0;i<sizeof(gHandle_Buffer);i++) gHandle_Buffer[i]=0;
  855. }
  856. //判断是否有需要发送的手柄数据
  857. else if(  (gHandle_Receive_Over>20)
  858.   &&(gDisp_Receive_Over>20)
  859.   &&( (gCommon_Flag&ALLOW_R232_F_1)==0)
  860.   &&(gGPS_Receive_Over>20)
  861.   &&(gReceive1_Over_Count>20)  )
  862. {
  863. SRAM_Init();
  864. i=SRAM_Read(SHANDLE_DATA_VAILD);
  865. if(i!=NULL_2)
  866. {
  867. for(k=0;k<SRAM_Read(SHANDLE_DATA_VAILD+2);k++)
  868. {
  869. Send_COM3_Byte( SRAM_Read(SHANDLE_DATA_VAILD+1+k) );
  870. }
  871. RX3_Ready();
  872. SRAM_Init();
  873. SRAM_Write(SHANDLE_DATA_VAILD+0,NULL_2);
  874. }
  875. }
  876. }
  878. /********************************************************
  879. * 函数名：Check_Handle_Command
  880. 作用域：本地文件调用
  881. * 功能： 校验在手柄通讯完后，判断收到数据包的数据是否属于正确数据包
  882. 并返回信令字
  883. * 参数：
  884. * 返回值：
  885. * 创建人：
  886. *
  887. * 修改历史：（每条详述）
  888. ********************************************************/
  889. unsigned char Check_Handle_Command(void)
  890. {
  891. if(gHandle_Buffer_Point<4) return(0); //最小的包长为4个字节，如果小于4说明数据包未收全
  892. if(gHandle_Buffer_Point!=gHandle_Buffer[1]) return(0); //接收到的数据包与数据包里的字长不符合，也说明数据未收全
  893. if(gHandle_Buffer[0]!=0x24) return(0); //收到的包头不正确
  894. if(gHandle_Buffer[gHandle_Buffer_Point-1]!=0x0d) return(0); //收到的包尾不正确
  895. return(gHandle_Buffer[2]);
  896. }
  897. /********************************************************
  898. * 函数名：Handle_Dailing
  899. 作用域：本地文件调用
  900. * 功能：
  902. * 参数：
  903. * 返回值：
  904. * 创建人：
  905. *
  906. * 修改历史：（每条详述）
  907. ********************************************************/
  908. void Handle_Dailing(unsigned char nPoint_Temp)
  909. {
  910. unsigned int i=0;
  911. unsigned char nTemp=0;
  912. unsigned char nFlag=0;
  913. nTemp=nPoint_Temp;
  915. //1,如果主控状态处于电话禁止呼出状态
  916. if(  (gON_OFF_Temp0&PHONE_OUT_ON)==0 )
  917. {
  918. //如果存在中心服务电话，则允许此号码拨出
  919. for(i=0;i<nTemp-4;i++)
  920. {
  921. gGeneral_Buffer[i]=gHandle_Buffer[3+i];
  922. }
  923. i=1;
  924. i=Check_Allow_Phone(nTemp-4);
  925. //判断书否属于112，110，119，13800138000，1860，1861，1001，等一类的服务号码
  926. if(Compare_String(gGeneral_Buffer,(unsigned char *)PHONE1,nTemp-4)) i=0;
  927. else if(Compare_String(gGeneral_Buffer,(unsigned char *)PHONE2,nTemp-4)) i=0;
  928. else if(Compare_String(gGeneral_Buffer,(unsigned char *)PHONE3,nTemp-4)) i=0;
  929. else if(Compare_String(gGeneral_Buffer,(unsigned char *)PHONE4,nTemp-4)) i=0;
  930. else if(Compare_String(gGeneral_Buffer,(unsigned char *)PHONE5,nTemp-4)) i=0;
  931. else if(Compare_String(gGeneral_Buffer,(unsigned char *)PHONE6,nTemp-4)) i=0;
  932. else if(Compare_String(gGeneral_Buffer,(unsigned char *)PHONE7,nTemp-4)) i=0;
  933. //拨出号码与比较号码均不匹配，则不允许拨出此号码
  934. if(i==1)
  935. {
  936. nFlag=1;
  937. }
  938. else if( (gGeneral_Flag&MONITOR_ON_F_1)||(gPhone_Status==ACTIVE_MONITOR) )
  939. {
  940. nFlag=2;
  941. }
  942. else if( (gGeneral_Flag&DAILING_UP_F_1)||(gPhone_Status==ACTIVE_HANDLE)||(gGeneral_Flag&RING_F_1) )
  943. {
  944. nFlag=3;
  945. }
  946. else
  947. {
  948. nFlag=0;
  949. }
  950. }
  951. //如果这个时候处于监听状态，或者处于正在监听的拨号状态下，则返回手柄一个busy信令
  952. else if( (gGeneral_Flag&MONITOR_ON_F_1)||(gPhone_Status==ACTIVE_MONITOR) )
  953. {
  954. nFlag=2;
  955. }
  956. //如果这个时候处于手柄拨号，或者正在通话的状态，或者正在来电的状态下，则返回一个busy信令
  957. else if( (gGeneral_Flag&DAILING_UP_F_1)||(gPhone_Status==ACTIVE_HANDLE)||(gGeneral_Flag&RING_F_1) )
  958. {
  959. nFlag=3;
  960. }
  961. //返回一个电话禁止呼出
  962. if(nFlag==1)
  963. {
  964. Send_COM3_Load(4,MAIN_RETURN_NO_CALLOUT,0);
  965. }
  966. //返回给手柄一个Busy信令
  967. else if(nFlag==2)
  968. {
  969. Send_COM3_Load(4,MAIN_BUSY,0);
  970. }
  971. //返回挂机命令
  972. else if(nFlag==3)
  973. {
  974. SRAM_Init();
  975. SRAM_Write(PHONE_AT_2+0,VAILD_2);
  976. SRAM_Write(PHONE_AT_2+1,H_HUNGUP);
  977. SRAM_Write(PHONE_AT_2+2,0);
  978. //Send_COM3_Load(5,MAIN_RETURN_PHONE_ECHO,COMMAND_ERROR);
  979. }
  980. //返回一个正常的拨出号码
  981. else
  982. {
  983. Send_COM3_Load(5,MAIN_RETURN_PHONE_ECHO,COMMAND_OK);
  984. SRAM_Init();
  985. SRAM_Write(PHONE_AT_2+0,VAILD_2);
  986. SRAM_Write(PHONE_AT_2+1,H_DIAL);
  987. SRAM_Write(PHONE_AT_2+2,nTemp-4);
  988. for(i=3;i<nTemp-1;i++)
  989. {
  990. SRAM_Write(PHONE_AT_2+i,gHandle_Buffer[i]);
  991. }
  992. //将拨出电话记录存储在相应的Flash中
  993. //while(gDelay_Flash_Timer<3) {Clear_Exter_WatchDog();}
  994. //Init_Buffer2();
  995. Write_Dail_Record(nTemp);
  996. gDelay_Flash_Timer=0;
  997. gHandle_Buffer_Point=0;
  998. gTimer=0;Clear_Exter_WatchDog();
  999. while(gTimer<500){}
  1000. Clear_Exter_WatchDog();
  1001. OperateSPIEnd();
  1002. //Init_Buffer2();
  1003. }
  1004. }
  1006. /********************************************************
  1007. * 函数名：Handle_Answer
  1008. 作用域：本地文件调用
  1009. * 功能：
  1010. * 参数：
  1011. * 返回值：
  1012. * 创建人：
  1013. *
  1014. * 修改历史：（每条详述）
  1015. ********************************************************/
  1016. void Handle_Answer(void)
  1017. {
  1018. unsigned char nFlag=0;
  1019. //1，如果设备处于呼入禁止状态下，判断是否有允许此号码呼入的标志
  1020. if(  (gON_OFF_Temp0&PHONE_IN_ON)==0 )
  1021. {
  1022. if(gPublic_Flag&ALLOW_PHONE_IN_F_1) nFlag=1;
  1023. else nFlag=0;
  1024. }
  1025. //2，设备没有处于呼入禁止的状态
  1026. else nFlag=1;
  1028. if(nFlag==1)
  1029. {
  1030. SRAM_Init();
  1031. SRAM_Write(PHONE_AT_2+0,VAILD_2);
  1032. SRAM_Write(PHONE_AT_2+1,H_ANSWER);
  1033. SRAM_Write(PHONE_AT_2+2,0);
  1034. }
  1035. else
  1036. {
  1037. Send_COM3_Load(4,MAIN_RETURN_NO_CALLIN,0);
  1038. SRAM_Init();
  1039. SRAM_Write(PHONE_AT_2+0,VAILD_2);
  1040. SRAM_Write(PHONE_AT_2+1,H_HUNGUP);
  1041. SRAM_Write(PHONE_AT_2+2,0);
  1042. }
  1043. }
  1044. /********************************************************
  1045. * 函数名：Move_Right_Item()
  1046. 作用域：本地文件调用
  1047. * 功能： 针对gGeneral_Buffer[]中存储的号码有重复的地方，则如何消除重复号码那一条
  1048. * 参数： Start_Item：
  1049. End_Item：
  1050. Move_Count：
  1051. * 返回值：
  1052. * 创建人：
  1053. *
  1054. * 修改历史：（每条详述）
  1055. ********************************************************/
  1056. void Move_Right_Item(unsigned char Start_Item,unsigned char End_Item,unsigned char Move_Count)
  1057. {
  1058. unsigned int i=0,j=0;
  1059. if(Move_Count==1)
  1060. {
  1061. for( i=End_Item;i>Start_Item;i=i-1 )
  1062. {
  1063. for(j=0;j<16;j++)
  1064. {
  1065. gGeneral_Buffer[i*16+j]=gGeneral_Buffer[(i-1)*16+j];
  1066. }
  1067. }
  1068. }
  1069. else if(Move_Count==2)
  1070. {
  1071. for( i=7;i>0;i-- )
  1072. {
  1073. for(j=0;j<32;j++)
  1074. {
  1075. gGeneral_Buffer[i*32+j]=gGeneral_Buffer[(i-1)*32+j];
  1076. }
  1077. }
  1078. }
  1079. }
  1081. /********************************************************
  1082. * 函数名：Write_Dail_Record
  1083. 作用域：本地文件调用
  1084. * 功能： 用来在每次拨出电话号码后，存储拨出电话号码的记录
  1085. * 参数：
  1086. * 返回值：
  1087. * 创建人：
  1088. *
  1089. * 修改历史：（每条详述）
  1090. 补充说明：这个子程序是将拨出的电话号码存储在缓冲区中。
  1091.   先判断已经存储的缓冲区中是否有相同的拨好记录
  1092.   如果有，则先将此记录删除，然后重新排列，将
  1093.   整个缓冲向左移动一个存储记录，则将第一个存储
  1094.   记录的空间留下来，则将最新的拨出电话记录存储在
  1095.   位置上。
  1096. ********************************************************/
  1097. void Write_Dail_Record(unsigned char nPhone_Length)
  1098. {
  1099. unsigned char nItem=0xff;
  1100. unsigned int i,j,k;
  1101. i=nPhone_Length;
  1102. Clear_Exter_WatchDog();
  1103. OperateSPIEnd();
  1104. ReadOnePageToBuffer2(FLASH_DIAL_PHONE); //读第3个扇区的数据到buffer2中
  1105. OperateSPIEnd();
  1106. //将buffer2中的数据转移到gGeneral_Buffer中
  1107. gGeneral_Buffer[0]=ReadByteFromBuffer2(0);
  1108. for(i=1;i<264;i++) gGeneral_Buffer[i]=ReadNextFromBuffer2();
  1109. OperateSPIEnd();
  1110. //判断gHandle_Buffer[]中的号码是否与gGeneral_Buffer[]中有重复的号码
  1111. i=0;
  1112. k=0;
  1113. while(i<16)
  1114. {
  1115. j=0;
  1116. while(j<nPhone_Length-4)
  1117. {
  1118. if( gGeneral_Buffer[i*16+j]!=gHandle_Buffer[3+j] )
  1119. {
  1120. i++;j=0;k=0;break;
  1121. }
  1122. j++;
  1123. if(j>=nPhone_Length-4)
  1124. {
  1125. k=1;break;
  1126. }
  1127. }
  1128. if(k==1) break;
  1129. }
  1131. //说明有重复的号码,则将这一条的重复号码给覆盖住
  1132. if(k==1)
  1133. {
  1134. nItem=i;
  1135. if(nItem>0) Move_Right_Item(0,nItem,1);
  1136. }
  1137. //没有重复号码，则将整个号码向后移动一条。
  1138. else
  1139. {
  1140. Move_Right_Item(0,15,1);
  1141. }
  1142. //将最新号码写在第一条号码的位置
  1143. for(i=0;i<16;i++)
  1144. {
  1145. gGeneral_Buffer[i]=0x20;
  1146. }
  1147. for(i=0;i<nPhone_Length-4;i++)
  1148. {
  1149. gGeneral_Buffer[i]=gHandle_Buffer[3+i];
  1150. }
  1151. //将gGeneral_Buffer[]中的数写入buffer2中
  1152. OperateSPIEnd();
  1153. WriteOneByteToBuffer2(0,gGeneral_Buffer[0]);
  1154. for(i=1;i<264;i++)
  1155. {
  1156. WriteNextByteToBuffer2( gGeneral_Buffer[i] );
  1157. }
  1158. OperateSPIEnd();
  1159. //4,将已经写入了新的拨号记录的buffer2写到flash 相应的区域中
  1160. Clear_Exter_WatchDog();
  1161. P6OUT|=SPI45DB041_WP;
  1162. WriteBuffer2ToPage(FLASH_DIAL_PHONE);
  1163. P6OUT&=~SPI45DB041_WP;
  1164. gTimer=0;Clear_Exter_WatchDog();
  1165. OperateSPIEnd();
  1166. }
  1167. /********************************************************
  1168. * 函数名：Read_Dail_Record
  1169. 作用域：本地文件调用
  1170. * 功能：  读取记录拨出电话记录的FLASH中的相应位置的数据
  1172. * 参数： nItem：表示当前所指向的记录号，其值有如下0-----15
  1174. * 返回值：
  1175. * 创建人：
  1176. *
  1177. * 修改历史：（每条详述）
  1178. ********************************************************/
  1179. void Read_Dail_Record(unsigned char nItem)
  1180. {
  1181. unsigned char nTemp,Record_Flag;
  1182. unsigned int i;
  1183. Clear_Exter_WatchDog();
  1184. OperateSPIEnd();
  1185. //读第3个扇区的数据到buffer2中
  1186. ReadOnePageToBuffer2(FLASH_DIAL_PHONE);
  1187. OperateSPIEnd();
  1188. nTemp = ReadByteFromBuffer2(nItem*0x10);
  1189. OperateSPIEnd();
  1190. Record_Flag=0;
  1191. //判断当前电话记录是否为空
  1192. if( (nTemp>'9')||(nTemp<'0') ) Record_Flag=1;
  1193. else Record_Flag=0;
  1194. //将所指向的拨出电话号码记录发送出去
  1195. SRAM_Init();
  1196. SRAM_Write(SHANDLE_DATA_VAILD+0,VAILD_2);
  1197. SRAM_Write(SHANDLE_DATA_VAILD+1,0x24);
  1198. SRAM_Write(SHANDLE_DATA_VAILD+2,0x15);
  1199. SRAM_Write(SHANDLE_DATA_VAILD+3,MAIN_DIALRECORD);
  1200. SRAM_Write(SHANDLE_DATA_VAILD+4,nItem);
  1201. if(Record_Flag==0)
  1202. {
  1203. OperateSPIEnd();
  1204. nTemp=ReadByteFromBuffer2(nItem*0x10);
  1205. SRAM_Write(SHANDLE_DATA_VAILD+5,nTemp);
  1206. for(i=1;i<16;i++)
  1207. {
  1208. SRAM_Write(SHANDLE_DATA_VAILD+5+i,ReadNextFromBuffer2());
  1209. }
  1210. OperateSPIEnd();
  1211. }
  1212. else
  1213. {
  1214. for(i=0;i<16;i++)
  1215. {
  1216. SRAM_Write(SHANDLE_DATA_VAILD+5+i,0x20);
  1217. }
  1218. }
  1219. SRAM_Write(SHANDLE_DATA_VAILD+5+16,0x0d);
  1220. }
  1222. /********************************************************
  1223. * 函数名：Read_Phone_Note_Record
  1224. 作用域：本地文件调用
  1225. * 功能：  读取电话号码
  1227. * 参数： nItem：表示当前所指向的记录号，其值有如下1-----20
  1229. * 返回值：
  1230. * 创建人：
  1231. *
  1232. * 修改历史：（每条详述）
  1233. ********************************************************/
  1234. void Read_Phone_Note_Record(unsigned char nItem)
  1235. {
  1236. unsigned int i=0,j=0,k=0;
  1237. unsigned char Phone_Page=0;
  1238. unsigned char Phone_Item=0;
  1239. unsigned int  Phone_Address=0;
  1240. unsigned char Phone_Num=0;
  1241. unsigned char nTemp=0;
  1243. if( nItem<10 ) Phone_Page=1;
  1244. else if( (nItem>=10)&&(nItem<20) ) Phone_Page=2;
  1245. else {Phone_Page=0;return;}
  1247. OperateSPIEnd();
  1248. if(Phone_Page==1)
  1249. {
  1250. ReadOnePageToBuffer2(FLASH_PHONE_INFO_ONE_2);
  1251. Phone_Item=nItem;
  1252. }
  1253. else if(Phone_Page==2)
  1254. {
  1255. ReadOnePageToBuffer2(FLASH_PHONE_INFO_TWO_2);
  1256. Phone_Item=nItem-10;
  1257. }
  1258. OperateSPIEnd();
  1259. Phone_Num=ReadByteFromBuffer2(PHONE_NUM_2);
  1260. OperateSPIEnd();
  1261. if( (Phone_Num>0)&&(Phone_Num<=10)&&(Phone_Item<=Phone_Num) ) j=1;
  1262. else j=0;
  1263. Phone_Address=Phone_Item*21+ONE_1_FRAME_2;
  1264. OperateSPIEnd();
  1265. nTemp=ReadByteFromBuffer2(Phone_Address);
  1266. OperateSPIEnd();
  1267. if(nTemp==0x20) j=0;
  1269. SRAM_Init();
  1270. SRAM_Write(SHANDLE_DATA_VAILD+0,VAILD_2);
  1271. SRAM_Write(SHANDLE_DATA_VAILD+1,0x24);
  1272. SRAM_Write(SHANDLE_DATA_VAILD+2,0x1A);
  1273. SRAM_Write(SHANDLE_DATA_VAILD+3,MAIN_RETURN_PHONE_NOTE);
  1274. SRAM_Write(SHANDLE_DATA_VAILD+4,nItem);
  1275. if(j==1)
  1276. {
  1277. SRAM_Write(SHANDLE_DATA_VAILD+5,ReadByteFromBuffer2(Phone_Address));
  1278. for(i=1;i<8+13;i++)
  1279. {
  1280. SRAM_Write(SHANDLE_DATA_VAILD+5+i,ReadNextFromBuffer2());
  1281. }
  1282. }
  1283. else
  1284. {
  1285. for(i=0;i<8+13;i++)
  1286. {
  1287. SRAM_Write(SHANDLE_DATA_VAILD+5+i,0x20);
  1288. }
  1289. }
  1290. SRAM_Write(SHANDLE_DATA_VAILD+5+8+13,0x0d);
  1291. }
  1292. /********************************************************
  1293. * 函数名：Write_Talk_Record
  1294. 作用域：本地文件调用
  1295. * 功能： 用来每次通话结束后，存储通话记录(此记录均是用手柄发送过来的数据包)
  1296. 参数：
  1297. * 返回值：
  1298. * 创建人：
  1299. *
  1300. * 修改历史：（每条详述）
  1301. ********************************************************/
  1302. /*
  1303. void Write_Talk_Record(unsigned char nPhone_Length)
  1304. {
  1305.     unsigned int i;
  1306.     OperateSPIEnd();
  1307.     Clear_Exter_WatchDog();
  1308.     //1,读第4个扇区的数据到buffer2中
  1309. ReadOnePageToBuffer2(FLASH_RECORD_PHONE_2);
  1310. OperateSPIEnd();
  1311. //将buffer2中的数据转移到gGeneral_Buffer中
  1312. gGeneral_Buffer[0]=ReadByteFromBuffer2(0);
  1313. for(i=1;i<264;i++) gGeneral_Buffer[i]=ReadNextFromBuffer2();
  1314. OperateSPIEnd();
  1315. //2,平移动buffer2中的通话记录
  1316. Move_Right_Item(0,14,2);
  1318. for(i=0;i<32;i++)
  1319. {
  1320. gGeneral_Buffer[i]=0x20;
  1321. }
  1322. //3,将新的通话记录的数据写入第一个记录区
  1323. for(i=0;i<nPhone_Length-4;i++)
  1324. {
  1325. gGeneral_Buffer[i]=gHandle_Buffer[3+i];
  1326. }
  1327. //将gGeneral_Buffer[]中的数写入buffer2中
  1328. OperateSPIEnd();
  1329. WriteOneByteToBuffer2(0,gGeneral_Buffer[0]);
  1330. for(i=1;i<264;i++)
  1331. {
  1332. WriteNextByteToBuffer2( gGeneral_Buffer[i] );
  1333. }
  1334. OperateSPIEnd();
  1335. //4,将更新完毕的buffer2中的数据写入第4扇区
  1336. Clear_Exter_WatchDog();
  1337. P6OUT|=SPI45DB041_WP;
  1338. WriteBuffer2ToPage(FLASH_RECORD_PHONE_2);
  1339. P6OUT&=~SPI45DB041_WP;
  1340. gTimer=0;Clear_Exter_WatchDog();
  1341. OperateSPIEnd();
  1342. }
  1343. */
  1344. /********************************************************
  1345. * 函数名：Read_Talk_Record
  1346. 作用域：本地文件调用
  1347. * 功能：
  1348. * 参数：  nItem：表示当前所指向的记录，其值有如下0-----7
  1350. * 参数：
  1351. * 返回值：
  1352. * 创建人：
  1353. *
  1354. * 修改历史：（每条详述）
  1355. ********************************************************/
  1356. void Read_Talk_Record(unsigned char nItem)
  1357. {
  1358. unsigned char nTemp,Record_Flag;
  1359. unsigned int i;
  1360. Record_Flag=0;
  1361. if( nItem>7 ) return;
  1362. //读第4个扇区的数据到buffer2中
  1363. ReadOnePageToBuffer2(FLASH_RECORD_PHONE_2);
  1364. OperateSPIEnd();
  1365. nTemp = ReadByteFromBuffer2( nItem*0x10 );
  1366. OperateSPIEnd();
  1367. ReadOnePageToBuffer2(FLASH_RECORD_PHONE_2);
  1368. nTemp = ReadByteFromBuffer2( (2*nItem)*0x10 );
  1369. OperateSPIEnd();
  1370. if( (nTemp>'9')||(nTemp<'0') ) Record_Flag=1;
  1371. else Record_Flag=0;
  1372. SRAM_Init();
  1373. SRAM_Write(SHANDLE_DATA_VAILD+0,VAILD_2);
  1374. SRAM_Write(SHANDLE_DATA_VAILD+1,0x24);
  1375. SRAM_Write(SHANDLE_DATA_VAILD+2,0x1e);
  1376. SRAM_Write(SHANDLE_DATA_VAILD+3,MAIN_TALKRECORD);
  1377. SRAM_Write(SHANDLE_DATA_VAILD+4,nItem);
  1378. if(Record_Flag==0)
  1379. {
  1380. OperateSPIEnd();
  1381. ReadOnePageToBuffer2(FLASH_RECORD_PHONE_2);
  1382. OperateSPIEnd();
  1383. nTemp=ReadByteFromBuffer2( (2*nItem)*0x10 );
  1385. SRAM_Write(SHANDLE_DATA_VAILD+5,nTemp);
  1386. for(i=1;i<25;i++)
  1387. {
  1388. SRAM_Write(SHANDLE_DATA_VAILD+5+i,ReadNextFromBuffer2());
  1389. }
  1390. OperateSPIEnd();
  1391. }
  1392. else
  1393. {
  1394. for(i=0;i<25;i++)
  1395. {
  1396. SRAM_Write(SHANDLE_DATA_VAILD+5+i,0x20);
  1397. }
  1398. }
  1399. SRAM_Write(SHANDLE_DATA_VAILD+5+25,0x0d);
  1400. }
  1401. /********************************************************
  1402. * 函数名：Handle_ReadOnePage_Data
  1403. 作用域：本地文件调用
  1404. * 功能：
  1405. * 参数：
  1406. * 参数：
  1407. * 返回值：
  1408. * 创建人：
  1409. * 修改历史：（每条详述）
  1410. ********************************************************/
  1411. void Handle_ReadOnePage_Data(unsigned char Page_H,unsigned char Page_L)
  1412. {
  1413. unsigned int Page_Address=0,i=0;
  1414. unsigned char Length=0;
  1415. Page_Address = Page_H;
  1416. Page_Address <<=8;
  1417. Page_Address += Page_L;
  1419. if(Page_Address<2048)
  1420. {
  1421. OperateSPIEnd();
  1422. ReadOnePageToBuffer2(Page_Address);
  1423. OperateSPIEnd();
  1424. gGeneral_Buffer[0]=ReadByteFromBuffer2(0);
  1425. for(i=1;i<256;i++) gGeneral_Buffer[i]=ReadNextFromBuffer2();
  1426. OperateSPIEnd();
  1427. Length=4+256;
  1428. Waiting_Allow_Send();
  1429. Send_COM3_Byte(0x24);Send_COM3_Byte(Length);
  1430. Send_COM3_Byte(MAIN_READPAGE_ECHO);
  1431. for(i=0;i<256;i++)
  1432. {
  1433. Send_COM3_Byte(gGeneral_Buffer[i]);
  1434. Clear_Exter_WatchDog();
  1435. }
  1436. Send_COM3_Byte(0x0d);
  1437. RX3_Ready();
  1438. }
  1439. }
  1440. /********************************************************
  1441. * 函数名：Handle_EraseOnePage_Data
  1442. 作用域：本地文件调用
  1443. * 功能：
  1444. * 参数：
  1445. * 参数：
  1446. * 返回值：
  1447. * 创建人：
  1448. * 修改历史：（每条详述）
  1449. ********************************************************/
  1450. /*
  1451. void Handle_EraseOnePage_Data(unsigned char Page_H,unsigned char Page_L)
  1452. {
  1453. unsigned int Page_Address=0;
  1454. Page_Address = Page_H;
  1455. Page_Address <<=8;
  1456. Page_Address += Page_L;
  1458. if(Page_Address<2048)
  1459. {
  1460. OperateSPIEnd();EraseOnePage(Page_Address);OperateSPIEnd();
  1461. }
  1462. Send_COM3_Load(5,MAIN_ERASEPAGE_ECHO,COMMAND_OK);
  1463. }
  1464. */
  1465. /********************************************************
  1466. * 函数名：Send_COM3_SubProgram
  1467. 作用域：本地文件调用
  1468. * 功能：
  1469. * 参数：
  1470. * 参数：
  1471. * 返回值：
  1472. * 创建人：
  1473. * 修改历史：（每条详述）
  1474. ********************************************************/
  1475. void Send_COM3_SubProgram(unsigned char DataLength,unsigned char nCommand,unsigned char DataTemp)
  1476. {
  1477. unsigned char Length=0;
  1478. unsigned char Command=0;
  1479. unsigned char Data=0;
  1480. Length=DataLength;
  1481. Command=nCommand;
  1482. Data=DataTemp;
  1483. Send_COM3_Byte(0x24);Send_COM3_Byte(Length);
  1484. Send_COM3_Byte(Command);
  1485. if(Length==4)
  1486. {
  1487. }
  1488. else if(Length==5)
  1489. {
  1490. Send_COM3_Byte(Data);
  1491. }
  1492. Send_COM3_Byte(0x0d);
  1493. RX3_Ready();
  1494. }
  1495. /********************************************************
  1496. * 函数名：Send_COM3_SubProgram
  1497. 作用域：本地文件调用
  1498. * 功能：
  1499. * 参数：
  1500. * 参数：
  1501. * 返回值：
  1502. * 创建人：
  1503. * 修改历史：（每条详述）
  1504. ********************************************************/
  1505. void Send_COM3_Load(unsigned char DataLength,unsigned char nCommand,unsigned char DataTemp)
  1506. {
  1507. unsigned char Length=0;
  1508. unsigned char Command=0;
  1509. unsigned char Data=0;
  1510. Length=DataLength;
  1511. Command=nCommand;
  1512. Data=DataTemp;
  1513. SRAM_Init();
  1514. SRAM_Write(SHANDLE_DATA_VAILD+0,VAILD_2);
  1515. SRAM_Write(SHANDLE_DATA_VAILD+1,0x24);
  1516. SRAM_Write(SHANDLE_DATA_VAILD+2,Length);
  1517. SRAM_Write(SHANDLE_DATA_VAILD+3,Command);
  1518. if(Length==4)
  1519. {
  1520. SRAM_Write(SHANDLE_DATA_VAILD+4,0x0d);
  1521. }
  1522. else if(Length==5)
  1523. {
  1524. SRAM_Write(SHANDLE_DATA_VAILD+4,Data);
  1525. SRAM_Write(SHANDLE_DATA_VAILD+5,0x0d);
  1526. }
  1527. }
  1528. /********************************************************
  1529. * 函数名：Handle_Set_Par
  1530. 作用域：本地文件调用
  1531. * 功能:测试外部设备的功能
  1532. * 参数：
  1533. * 参数：
  1534. * 返回值：
  1535. * 创建人：
  1536. * 修改历史：（每条详述）
  1537. ********************************************************/
  1538. void Handle_Set_Par(unsigned char nLength)
  1539. {
  1540. unsigned int i=0;
  1541. for(i=0;i<sizeof(gGeneral_Buffer);i++)    gGeneral_Buffer[i]=0;
  1542. for(i=0;i<nLength-3;i++)
  1543. {
  1544. gGeneral_Buffer[i+1+9]=gHandle_Buffer[i+3];
  1545. }
  1546. Do_Par();
  1547. Waiting_Allow_Send();
  1548. Send_COM3_SubProgram(5,HANDLE_SET_PAR_ECHO,COMMAND_OK);
  1549. gTimer=0;
  1550. while(gTimer<50){}
  1551. }
  1553. /********************************************************
  1554. * 函数名：Handle_Set_TcpIp
  1555. 作用域：本地文件调用
  1556. * 功能:测试外部设备的功能
  1557. * 参数：
  1558. * 参数：
  1559. * 返回值：
  1560. * 创建人：
  1561. * 修改历史：（每条详述）
  1562. ********************************************************/
  1563. void Handle_Set_TcpIp(void)
  1564. {
  1565. unsigned int i,j,k;
  1566. unsigned char APN_Length=0;
  1567. unsigned char Check_Data=0;
  1568. //在gHandle_Buffer[i]中表示IP地址的第一个数
  1569. i=3;
  1570. while(1)
  1571. {
  1572. if(gHandle_Buffer[i]==0x00) break;
  1573. i++;
  1574. if(i>16+3) return;
  1575. }
  1576. //一，+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1577. //1-1,存储IP的数据值到相应的BUFFER1中,存储IP地址的长度，不包括长度本身
  1578. Check_Data=0;
  1579. SRAM_Init();
  1580. SRAM_Write(GPRS_IP_ADDRESS1_2+0,i-3);
  1581. for(j=3;j<i;j++)
  1582. {
  1583. Check_Data += gHandle_Buffer[j];
  1584. SRAM_Write(GPRS_IP_ADDRESS1_2+j-2,gHandle_Buffer[j]);
  1585. }
  1586. SRAM_Write(GPRS_IP_ADDRESS1_CHECK_2,Check_Data);
  1588. //1-2,将IP地址的SOCKET数据存储在buffer1相应的缓冲区中，因为上面gHandle_Buffer[i]=0x00
  1589. i++;
  1590. gIP_Port_Num = gHandle_Buffer[i];
  1591. gIP_Port_Num<<=8;
  1592. gIP_Port_Num += gHandle_Buffer[i+1];
  1593. gIP_Port_Num<<=8;
  1594. gIP_Port_Num += gHandle_Buffer[i+2];
  1595. gIP_Port_Num<<=8;
  1596. gIP_Port_Num += gHandle_Buffer[i+3];
  1597. SRAM_Init();
  1598. Check_Data=ASCII(gIP_Port_Num/10000);
  1599. SRAM_Write(GPRS_SOCKET1_2+0,ASCII(gIP_Port_Num/10000));
  1600. Check_Data += ASCII((gIP_Port_Num%10000)/1000);
  1601. SRAM_Write(GPRS_SOCKET1_2+1,ASCII((gIP_Port_Num%10000)/1000));
  1602. Check_Data += ASCII((gIP_Port_Num%1000)/100);
  1603. SRAM_Write(GPRS_SOCKET1_2+2,ASCII((gIP_Port_Num%1000)/100));
  1604. Check_Data += ASCII((gIP_Port_Num%100)/10);
  1605. SRAM_Write(GPRS_SOCKET1_2+3,ASCII((gIP_Port_Num%100)/10));
  1606. Check_Data += ASCII(gIP_Port_Num%10);
  1607. SRAM_Write(GPRS_SOCKET1_2+4,ASCII(gIP_Port_Num%10));
  1608. SRAM_Write(GPRS_SOCKET1_2+5,Check_Data);
  1609. OperateSPIEnd();
  1610. //1-3,TCP开关量的判断处理
  1611. gON_OFF_Temp0 &=~ TCP_LAND_ON_OFF_1;
  1612. gStatus2_Flag |= TCP_ON_OFF_F_1;
  1614. //1-4，APN方面的判断处理
  1615. k=i+5;
  1616. while(1)
  1617. {
  1618. if(gHandle_Buffer[k]==0x00) break;
  1619. k++;
  1620. if(k>gHandle_Buffer[1]) return;
  1621. }
  1622. APN_Length=k-i-5;
  1623. if( (APN_Length>=4)&&(APN_Length<=25) )
  1624. {
  1625. SRAM_Init();
  1626. SRAM_Write(GPRS_APN_ADDRESS2_2+0,APN_Length);
  1627. Check_Data=0;
  1628. for(j=i+5;j<k;j++)
  1629. {
  1630. SRAM_Write(GPRS_APN_ADDRESS2_2+(j-i-5)+1,APN_Length);
  1631. Check_Data += gHandle_Buffer[j];
  1632. }
  1633. SRAM_Write(GPRS_APN_END_2,Check_Data);
  1634. }
  1635. else
  1636. {
  1637. SRAM_Write(GPRS_APN_ADDRESS2_2,sizeof(APN_DEFAULT));
  1638. //5，存储APN的数据值到相应的BUFFER1中
  1639. Check_Data=0;
  1640. for(i=0;i<sizeof(APN_DEFAULT);i++)
  1641. {
  1642. SRAM_Write(GPRS_APN_ADDRESS2_2+i+1,APN_DEFAULT[i]);
  1643. Check_Data += APN_DEFAULT[i];
  1644. }
  1645. SRAM_Write(GPRS_APN_END_2,Check_Data);
  1646. }
  1647. //将TCP的开关量的信息存储在相应的FLASH中
  1648. OperateSPIEnd();ReadOnePageToBuffer2(FLASH_INFO2_ONE_2);OperateSPIEnd();
  1649. WriteOneByteToBuffer2(ON_OFF_V1_2,gON_OFF_Temp0);OperateSPIEnd();
  1650. RFlash_Sector(FLASH_INFO2_ONE_2);
  1651. Re430_Flash(1);
  1652. RX2_Ready();RX3_Ready();RX4_Ready();
  1653. //二，++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1654. //注意，这里在程序刚上电的最开始已经检查过了FLASH的第1，第2扇区的数据
  1655. //在这里则不需要在继续检查
  1656. //读第一个扇区的数据到buffer2中
  1657. gTimer=0;
  1658. while(gTimer<500){}
  1659. Clear_Exter_WatchDog();
  1660. //2-1，将IP地址数据已经写入相应的buffer2中
  1661. i=3;
  1662. while(1)
  1663. {
  1664. if(gHandle_Buffer[i]==0x00) break;
  1665. i++;
  1666. if(i>16+3) return;
  1667. }
  1668. //这个时候的i指向0x00
  1669. OperateSPIEnd();ReadOnePageToBuffer2(FLASH_INFO1_ONE_2);OperateSPIEnd();
  1670. WriteOneByteToBuffer2(GPRS_IP_ADDRESS1_F_2,i-3);
  1671. for(j=3;j<i;j++)
  1672. {
  1673. WriteNextByteToBuffer2(gHandle_Buffer[j]);
  1674. }
  1675. OperateSPIEnd();
  1676. gGeneral_Flag|=TCP_IP_VALID_1;
  1677. gStatus2_Flag|=IP_VAILD_F_1;
  1678. //2-2，将SOCKET的数据写入相应的buffer2中
  1679. OperateSPIEnd();
  1680. WriteOneByteToBuffer2(GPRS_SOCKET1_F_2,ASCII(gIP_Port_Num/10000));
  1681. WriteNextByteToBuffer2(ASCII((gIP_Port_Num%10000)/1000));
  1682. WriteNextByteToBuffer2(ASCII((gIP_Port_Num%1000)/100));
  1683. WriteNextByteToBuffer2(ASCII((gIP_Port_Num%100)/10));
  1684. WriteNextByteToBuffer2(ASCII(gIP_Port_Num%10));
  1685. OperateSPIEnd();
  1686. //2-3,将APN的数据写入到相应的buffer2中
  1687. //i指向APN的第一个字节
  1688. k=i+6;
  1689. while(1)
  1690. {
  1691. if(gHandle_Buffer[k]==0x00) break;
  1692. k++;
  1693. if(k>gHandle_Buffer[1]) return;
  1694. }
  1695. APN_Length=k-i-6;
  1696. WriteOneByteToBuffer2(GPRS_APN_DATA_F_2,APN_Length);
  1697. for(j=i+6;j<k;j++)
  1698. {
  1699. WriteNextByteToBuffer2(gHandle_Buffer[j]);
  1700. }
  1701. OperateSPIEnd();
  1703. gTimer=0;
  1704. while(gTimer<50){}
  1705. Clear_Exter_WatchDog();
  1706. RFlash_Sector(FLASH_INFO1_ONE_2);
  1707. Re430_Flash(0);
  1708. Waiting_Allow_Send();
  1709. Send_COM3_SubProgram(5,HANDLE_SET_TCPIP_ECHO,COMMAND_OK);
  1710. gCheck_Par_Timer=CHECK_SYS_PAR_TIME+1;
  1711. Init_Buffer2();
  1712. RX2_Ready();
  1713. RX3_Ready();
  1714. RX4_Ready();
  1717. }
  1718. /********************************************************
  1719. * 函数名：Handle_Set_Time
  1720. 作用域：本地文件调用
  1721. * 功能:测试外部设备的功能
  1722. * 参数：
  1723. * 参数：
  1724. * 返回值：
  1725. * 创建人：
  1726. * 修改历史：（每条详述）
  1727. ********************************************************/
  1728. void Handle_Set_Time(void)
  1729. {
  1730. unsigned int i=0,j=0;
  1731. gCycle_TCP = gHandle_Buffer[3];
  1732. gCycle_TCP <<= 8;
  1733. gCycle_TCP += gHandle_Buffer[4];
  1734. gCycle_GSM = gHandle_Buffer[5];
  1735. gCycle_GSM <<= 8;
  1736. gCycle_GSM += gHandle_Buffer[6];
  1738. if( (gCycle_TCP>0)&&(gCycle_TCP<5) ) gCycle_TCP=5;
  1739. if( (gCycle_GSM>0)&&(gCycle_GSM<5) ) gCycle_GSM=5;
  1740. OperateSPIEnd();ReadOnePageToBuffer2(FLASH_INFO2_ONE_2);OperateSPIEnd();
  1741. WriteOneByteToBuffer2(TCP_TIMER_2,gHandle_Buffer[3]);
  1742. WriteNextByteToBuffer2(gHandle_Buffer[4]);
  1743. WriteNextByteToBuffer2(gHandle_Buffer[5]);
  1744. WriteNextByteToBuffer2(gHandle_Buffer[6]);
  1745. OperateSPIEnd();
  1746. RFlash_Sector(FLASH_INFO2_ONE_2);
  1747. Re430_Flash(1);
  1748. //1，IP地址有效果，并且2，TCP的开关量是否开启
  1749. if( (gGeneral_Flag&TCP_IP_VALID_1)&&((gON_OFF_Temp0&TCP_LAND_ON_OFF_1)==0) )
  1750. {
  1751. if( (gCycle_TCP>0)&&(gCycle_Send_Status!=ALARM_DATA)&&(gCycle_Send_Status!=PASS_DATA) )
  1752. {
  1753. gCycle_Send_Status=TRACK_DATA_TIME;
  1754. }
  1755. else if( (gCycle_TCP==0)&&(gCycle_Send_Status==TRACK_DATA_TIME))
  1756. {
  1757. gCycle_Send_Status=NOP_DATA;
  1758. }
  1759. }
  1760. //1，IP地址无效，或者TCP的开关量关闭
  1761. else
  1762. {
  1763. if( (gCycle_GSM>0)&&(gCycle_Send_Status!=ALARM_DATA)&&(gCycle_Send_Status!=PASS_DATA) )
  1764. {
  1765. gCycle_Send_Status=TRACK_DATA_TIME;
  1766. }
  1767. else if( (gCycle_GSM==0)&&(gCycle_Send_Status==TRACK_DATA_TIME))
  1768. {
  1769. gCycle_Send_Status=NOP_DATA;
  1770. }
  1771. }
  1772. Waiting_Allow_Send();
  1773. Send_COM3_SubProgram(5,HANDLE_SET_TIME_ECHO,COMMAND_OK);
  1774. gTimer=0;
  1775. while(gTimer<50){}
  1776. }
  1778. /********************************************************
  1779. * 函数名：Handle_Ask_Par
  1780. 作用域：本地文件调用
  1781. * 功能:测试外部设备的功能
  1782. * 参数：
  1783. * 参数：
  1784. * 返回值：
  1785. * 创建人：
  1786. * 修改历史：（每条详述）
  1787. ********************************************************/
  1788. void Handle_Ask_Par(void)
  1789. {
  1790. unsigned int i=0;
  1791. Ask_Par();
  1792. SRAM_Init();
  1793. SRAM_Write(SHANDLE_DATA_VAILD+0,VAILD_2);
  1794. SRAM_Write(SHANDLE_DATA_VAILD+1,0x24);
  1795. SRAM_Write(SHANDLE_DATA_VAILD+2,gGeneral_Buffer[0]+1+3);
  1796. SRAM_Write(SHANDLE_DATA_VAILD+3,HANDLE_ASK_PAR_ECHO);
  1797. for(i=1;i<=gGeneral_Buffer[0];i++)
  1798. {
  1799. SRAM_Write(SHANDLE_DATA_VAILD+3+i,gGeneral_Buffer[i]);
  1800. }
  1801. SRAM_Write(SHANDLE_DATA_VAILD+4+gGeneral_Buffer[0],0x0d);
  1802. }
  1804. /********************************************************
  1805. * 函数名：Handle_Set_SMS
  1806. 作用域：本地文件调用
  1807. * 功能:
  1808. * 参数：
  1809. * 参数：
  1810. * 返回值：
  1811. * 创建人：
  1812. * 修改历史：（每条详述）
  1813. ********************************************************/
  1814. void Handle_Set_SMS(void)
  1815. {
  1816. if(gDisp_Buffer_Point+gHandle_Buffer[1]-4+2+6<=sizeof(gDisp_Buffer))
  1817. {
  1818.     gDisp_Buffer[gDisp_Buffer_Point]=gHandle_Buffer[1]-4+2+6;
  1819.     gDisp_Buffer_Point++;
  1820.     gDisp_Buffer[gDisp_Buffer_Point]=0;
  1821.     gDisp_Buffer_Point++;
  1822.     gDisp_Buffer[gDisp_Buffer_Point]='@';
  1823.     gDisp_Buffer_Point++;
  1824.     gDisp_Buffer[gDisp_Buffer_Point]='%';
  1825.     gDisp_Buffer_Point++;
  1826.     gDisp_Buffer[gDisp_Buffer_Point]=gHandle_Buffer[1]-4+2+4;
  1827.     gDisp_Buffer_Point++;
  1828.     gDisp_Buffer[gDisp_Buffer_Point]=DISP_MAIN_WORD_DOWN;
  1829.     gDisp_Buffer_Point++;
  1830.     //从0xFF开始存储数据(转移整个中心的数据包)
  1831.     Copy_String(gHandle_Buffer+3,gDisp_Buffer+gDisp_Buffer_Point,gHandle_Buffer[1]-4);
  1832.     gDisp_Buffer_Point=gDisp_Buffer_Point+gHandle_Buffer[1]-4;
  1833.     gDisp_Buffer[gDisp_Buffer_Point]='$';
  1834.     gDisp_Buffer_Point++;
  1835.     gDisp_Buffer[gDisp_Buffer_Point]='&';
  1836.     gDisp_Buffer_Point++;
  1837. Waiting_Allow_Send();
  1838. Send_COM3_SubProgram(5,HANDLE_SET_SMS_ECHO,COMMAND_OK);
  1839. }
  1840. }
  1841. /********************************************************
  1842. * 函数名：Handle_Set_Phone
  1843. 作用域：本地文件调用
  1844. * 功能:
  1845. * 参数：
  1846. * 参数：
  1847. * 返回值：
  1848. * 创建人：
  1849. * 修改历史：（每条详述）
  1850. ********************************************************/
  1851. void Handle_Set_Phone(unsigned char nLength)
  1852. {
  1853. unsigned int i=0;
  1854. for(i=0;i<sizeof(gGeneral_Buffer);i++)    gGeneral_Buffer[i]=0;
  1855. for(i=0;i<nLength-3;i++)
  1856. {
  1857. gGeneral_Buffer[i+1+9]=gHandle_Buffer[i+3];
  1858. }
  1859. Do_Phone_Note();
  1860. Waiting_Allow_Send();
  1861. Send_COM3_SubProgram(5,HANDLE_SET_PHONE_NOTE_ECHO,COMMAND_OK);
  1862. }
  1863. /********************************************************
  1864. * 函数名：Handle_Set_Dis
  1865. 作用域：本地文件调用
  1866. * 功能:
  1867. * 参数：
  1868. * 参数：
  1869. * 返回值：
  1870. * 创建人：
  1871. * 修改历史：（每条详述）
  1872. ********************************************************/
  1873. void Handle_Set_Dis(void)
  1874. {
  1875. gCycle_Distance = gHandle_Buffer[3];
  1876. gCycle_Distance <<= 8;
  1877. gCycle_Distance += gHandle_Buffer[4];
  1879. if(gHandle_Buffer[5]==1)
  1880. {
  1881. gON_OFF_Temp1 &=~ DISTANCE_TCP_ON_1;
  1882. gStatus3_Flag |= DISTANCE_ON_F_1;
  1883. }
  1884. else if(gGeneral_Buffer[5]==0)
  1885. {
  1886. gON_OFF_Temp1 |= DISTANCE_TCP_ON_1;
  1887. gStatus3_Flag &=~ DISTANCE_ON_F_1;
  1888. }
  1889. gCycle_TCP=0;
  1890. gCycle_GSM=0;
  1891. gCycle_Send_Status = NOP_DATA;
  1892. //根据状态的改变，则需要重新更新扇区0中的数据，并重新计算校验核，写入扇区
  1893. OperateSPIEnd();ReadOnePageToBuffer2(FLASH_INFO2_ONE_2);OperateSPIEnd();
  1894. WriteOneByteToBuffer2(ON_OFF_V2_2,gON_OFF_Temp1);
  1895. OperateSPIEnd();
  1896. WriteOneByteToBuffer2(TCP_TIMER_2,0);
  1897. WriteNextByteToBuffer2(0);
  1898. WriteNextByteToBuffer2(0);
  1899. WriteNextByteToBuffer2(0);
  1900. WriteNextByteToBuffer2(gHandle_Buffer[3]);
  1901. WriteNextByteToBuffer2(gHandle_Buffer[4]);
  1902. OperateSPIEnd();
  1903. RFlash_Sector(FLASH_INFO2_ONE_2);
  1904. Re430_Flash(1);
  1905. gPublic_Flag &=~ SET_DISTANCE_OK_F_1;
  1906. gSet_Distance_Info_Count=WAIT_DISPINFO_TIME-2;
  1908. //返回设置成功
  1909. Waiting_Allow_Send();
  1910. Send_COM3_SubProgram(5,HANDLE_SET_DISTANCE_ECHO,COMMAND_OK);
  1911. }
  1912. /********************************************************
  1913. * 函数名：Handle_Test_Sram
  1914. 作用域：本地文件调用
  1915. * 功能:
  1916. * 参数：
  1917. * 返回值：
  1918. * 创建人：
  1919. * 修改历史：（每条详述）
  1920. ********************************************************/
  1921. void Handle_Test_Sram(void)
  1922. {
  1923. unsigned int i=0,j=0,k=0;
  1924. unsigned char Data_Temp=0;
  1925. unsigned char Data_Read=0;
  1926. //关闭中断1;停止中断对外部SRAM的操作
  1927. IE2&=~URXIE1;            //USART1接收中断禁止
  1928. j=0;
  1929. for(k=0;k<=0x100;k++)
  1930. {
  1931. for(i=0;i<=0xFF;i++)
  1932. {
  1933. gGeneral_Buffer[i]=(char)(i+k);
  1934. }
  1935. Clear_Exter_WatchDog();
  1936. SRAM_Init();
  1937. for(i=0;i<=0xFF;i++)
  1938. {
  1939. SRAM_Write( (int)(k*0xFF+i),gGeneral_Buffer[i]);
  1940. }
  1941. SRAM_Init();
  1942. for(i=0;i<=0xFF;i++)
  1943. {
  1944. Data_Temp=SRAM_Read((int)(k*0xFF+i));
  1945. if(Data_Temp!=gGeneral_Buffer[i])
  1946. {
  1947. j=1;break;
  1948. }
  1949. }
  1950. if(j==1) break;
  1951. }
  1952. if(j==1)
  1953. {
  1954. Send_COM3_SubProgram(5,HANDLE_TEST_SRAM,COMMAND_ERROR);
  1955. }
  1956. else
  1957. {
  1958. Send_COM3_SubProgram(5,HANDLE_TEST_SRAM,COMMAND_OK);
  1959. }
  1960. IE2|=URXIE1;            //USART1接收中断允许
  1961. RX2_Ready();
  1962. RX3_Ready();
  1963. RX4_Ready();
  1964. gTimer=0;
  1965. while(gTimer<50){}
  1966. }