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

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

GPS编程

开发平台：

Others

Do_Other.C：源码内容
  1. /********************************************************
  2. * 文件名：  Do_Other.C
  3. * 创建时间：2004年12月7日
  4. * 创建人：  
  5. * 版本号：  1.00
  6. * 功能：   针对一些其他外部操作，比如报警检测等等
  7. * 文件属性：公共文件
  8. * 修改历史：（每条详述）
  9. ********************************************************/
  10. #include <msp430x14x.h>
  11. #include <math.h>
  12. #include <stdlib.h>
  13. #include "Define_Bit.h"
  14. #include "Other_Define.h"
  15. #include "General.h"
  16. #include "Uart01.h"
  17. #include "W_Protocol.h"
  18. #include "D_Buffer.h"
  19. #include "SPI45DB041.h"
  20. #include "Sub_C.h"
  22. #include "TA_Uart.h"
  23. #include "M22_AT.h"
  24. #include "Do_Other.h"
  25. #include "Do_Handle.h"
  26. #include "Handle_Protocol.h"
  27. #include "Disp_Protocol.h"
  28. #include "Do_SRAM.h"
  29. #include "Record_Protocol.h"
  30. #include "Do_M22.h"
  31. /*
  32. #include "Main_Init.h"
  33. #include "Check_GSM.h"
  34. #include "Do_Reset.h"
  35. #include "Do_GPS.h"
  36. #include "Do_Disp.h"
  37. */
  38. //#define Debug_GSM_COM1
  39. unsigned int Circle_Data_GSM( unsigned char nCount,unsigned char nCommand,unsigned char nACK,unsigned int iCheckOutTemp );
  40. unsigned int Circle_Data_GSM_Sub(unsigned int iCheckOutTemp);
  41. unsigned int Dichotomy_PassData_First(unsigned int iFirst_Page,unsigned int iEnd_Page);
  43. unsigned long int Max_Result(unsigned long int x,unsigned long int y);
  44. unsigned long int Min_Result(unsigned long int x,unsigned long int y);
  45. unsigned char Check_Area_Alarm(unsigned char Num);
  46. unsigned char Account_Mid_Dot(double x1,double y1,double x2,double y2);
  47. unsigned char  Check_Line_Data(unsigned char S_Num_ID);
  49. //unsigned int ADC_NORMAIL_VCC[2]={ 0x0850,0x0EF0 };
  50. //unsigned int ADC_STOP_VCC[2]={ 0x01F0,0x02EF };
  51. /********************************************************
  52. 补充说明：ADC_NORMAIL_VCC[2]根据实际的电路(分压电阻的不同)在正常状态下检测ADC转换的数值的范围
  53.   ADC_STOP_VCC[2]根据实际电路，已经执行了制动后，检测ADC转换的数值的范围
  54. ********************************************************/
  55. void GSM_WORK_Data(void);
  56. void TCP_WORK_Data(unsigned int Timer,unsigned char nCommand);
  57. /********************************************************
  58. * 函数名：Do_Other_Module
  59. 作用域：外部文件调用
  60. * 功能：
  61. * 参数：
  62. * 返回值：
  63. * 创建人：
  64. *
  65. * 修改历史：（每条详述）
  66. ********************************************************/
  67. void Do_Other_Module(void)
  68. {
  69. static unsigned char Test_Alarm_Step=0;
  70. static unsigned char Ring_Test_Step=0;
  71. static unsigned char Test_Status_Step=0;
  72. unsigned int i=0,j=0,k=0,h=0;
  73. unsigned long int x=0,y=0;
  74. unsigned char Check_Result=0;
  75. unsigned char Area_All=0;
  76. unsigned char Check_Record=0;
  77. unsigned char Area_Out_Num=0;
  78. double Distance_Temp=0;
  79. unsigned long int Dis_Data=0;
  81. //每间隔30分钟验证存储在buffer1中的参数是否有效
  82. if(gCheck_Par_Timer>CHECK_SYS_PAR_TIME)
  83. {
  84. gCheck_Par_Timer=0;
  85. k=Check_ParNum();
  86. if( (k==0)||(k==1) )
  87. {
  88. i=Check_Vaild(GPRS_IP_ADDRESS1_2,GPRS_IP_ADDRESS1_CHECK_2);
  89. j=Check_Port();
  90. h=Check_Vaild(GPRS_APN_ADDRESS2_2,GPRS_APN_END_2);
  91. if( (i==1)||(j==1)||(h==1))
  92. {
  93. //事先得先保存短消息中心号码，防止操作擦除掉目标号码
  94. gGeneral_Buffer[CENTER_NUM_2]=SRAM_Read(CENTER_NUM_2);
  95. for(i=CENTER_NUM_2+1;i<=CENTER_NUM_CHECK_2;i++)
  96. {
  97. gGeneral_Buffer[i]=SRAM_Read(i);
  98. }
  99. OperateSPIEnd();
  100. Load_Flash_Par_Buffer1();
  101. }
  102. }
  103. if(gInternal_Flag&SET_CSCA_F_1) gTimer_CSQ=GSM_CHECKCSQ_TIME-2;
  104. }
  105. if(gCommon_Flag&ALLOW_HANGUP_PHONE_F_1)
  106. {
  107. gCommon_Flag&=~ALLOW_HANGUP_PHONE_F_1;
  108. SRAM_Init();
  109. SRAM_Write(PHONE_AT_2+0,VAILD_2);
  110. SRAM_Write(PHONE_AT_2+1,H_HUNGUP);
  111. SRAM_Write(PHONE_AT_2+2,0);
  112. Send_COM3_Load(4,MAIN_HANG_UP,0);
  113. gSys_Handle=MAIN_HANG_UP;
  114. }
  115. /********************************************************
  116. A0;增加处理在来电或者拨出状态下的超时处理
  117. ********************************************************/
  118. if(gHangUp_Timer>HANGUP_COUNT)
  119. {
  120. if( (gGeneral_Flag&RING_F_1)||(gGeneral_Flag&DAILING_UP_F_1)||(gGeneral_Flag&MONITOR_ON_F_1) )
  121. {
  122. gHangUp_Timer=0;
  123. SRAM_Init();
  124. SRAM_Write(PHONE_AT_2+0,VAILD_2);
  125. SRAM_Write(PHONE_AT_2+1,H_HUNGUP);
  126. SRAM_Write(PHONE_AT_2+2,0);
  127. Send_COM3_Load(4,MAIN_HANG_UP,0);
  128. gSys_Handle=MAIN_HANG_UP;
  129. }
  130. }
  131. /********************************************************
  132. A1;如果未接收到登陆响应，则进行再次发送登陆命令
  133. ********************************************************/
  134. if(   (gLand_Interval_Timer>M22_LAND_TIME)
  135. &&((gGeneral_Flag&LAND_TCP_SUCCESS_F_1)==0) )
  136. {
  137. gOther_Flag|=ALLOW_SENDLAND_F_1;
  138. gLand_Interval_Timer=0;
  139. gWait_Land_Echo_Count++;
  140. if(gWait_Land_Echo_Count>10)
  141. {
  142. gWait_Land_Echo_Count=0;
  143. TCP_Land_Error_Return();
  144. }
  145. }
  146. /********************************************************
  147. A2;清除相关数据
  148. ********************************************************/
  149. if( ((gGeneral_Flag&TCP_PHONE_F_1)==0)&&(gDTMF_SAVE[0]!=0 ) )
  150. {
  151. for(i=0;i<sizeof(gDTMF_SAVE);i++) gDTMF_SAVE[i]=0;
  152. }
  153. /********************************************************
  154. A2-1;上报数据的状态位,1,无周期数据，2，按时间间隔上报数据
  155. 3，按行使间隔上报数据，4，报警类型数据
  156. ********************************************************/
  157. //1,无周期数据
  158. if(gCycle_Send_Status==NOP_DATA)
  159. {
  160. gStatus3_Flag&=~M22_WORK_0_F_1;
  161. gStatus3_Flag&=~M22_WORK_1_F_1;
  162. }
  163. //2，按时间间隔上报数据
  164. else if(gCycle_Send_Status==TRACK_DATA_TIME)
  165. {
  166. gStatus3_Flag|=M22_WORK_0_F_1;
  167. gStatus3_Flag&=~M22_WORK_1_F_1;
  168. }
  169. //3，按行使间隔上报数据
  170. else if(gCycle_Send_Status==TRACK_DATA_DISTANCE)
  171. {
  172. gStatus3_Flag&=~M22_WORK_0_F_1;
  173. gStatus3_Flag|=M22_WORK_1_F_1;
  174. }
  175. //4，报警类型的上报数据
  176. else if(gCycle_Send_Status==ALARM_DATA)
  177. {
  178. gStatus3_Flag|=M22_WORK_0_F_1;
  179. gStatus3_Flag|=M22_WORK_1_F_1;
  180. }
  181. /********************************************************
  182. A2-2;进行线路报警的标志
  183. ********************************************************/
  184. if(   (gCommon_Flag&ALLOW_LINE_DATA_F_1)
  185. &&(gCommon_Flag&ALLOW_LINE_DIS_F_1)  )
  186. {
  187. gStatus3_Flag|=LINE_LIMIT_F_1;
  188. }
  189. else
  190. {
  191. gStatus3_Flag&=~LINE_LIMIT_F_1;
  192. if(gAlarm_Type==OVER_LINE_ALARM)
  193. {
  194. gAlarm_Type=NOP_ALARM;
  195. gCycle_Send_Status=NOP_DATA;
  196. gAlarm_Count=0;
  197. gStatus2_Flag&=~ROB_ALARM_F_1;
  198. gCommon_Flag&=~STOP_OVERLINE_F_1;
  199. gCircle_Timer=0;
  200. gOver_Line_Count=0;
  201. }
  202. }
  203. /********************************************************
  204. A3;每间隔3秒向显示终端发送一次系统状态（GPS的数据有效果无效，GSM的信号强度，TCP的在线状态，当前速度值）
  205. 已经转移到下面的速度处理部分，以1秒发送一个速度处理,已经放在下一个部分处理
  206. ********************************************************/
  207. /********************************************************
  208. A3-1;每间隔10秒向手柄发送一个场强信号
  209. ********************************************************/
  210. if(gHandle_Single_Count>10)
  211. {
  212. if( (gM22_Status==TCP_ONLINE_WORK)&&(gSignal<10) )  gSignal=30;
  213. gHandle_Single_Count=0;
  214. Send_Handle_Signal(gSignal);
  215. }
  216. /********************************************************
  217. A4;如果在接收记录仪大量数据的存储区中还有未发送完的数据，则在这里处理
  218. ********************************************************/
  219. if(   (gOther_Flag&RECORD_DATA_F_1)
  220. &&(gSend_RecordData_Timer>=3)
  221. &&((gOther_Flag&ALLOW_SEND_RECORD_F_1)==0)  )
  222. {
  223. gSend_RecordData_Timer=0;
  224. gOther_Flag|=ALLOW_SEND_RECORD_F_1;
  225. }
  226. /********************************************************
  227. A4;处理每一秒速度相关的处理
  228. ********************************************************/
  229. if(gDo_Speed_Count>=1)
  230. {
  231. gDo_Speed_Count=0;
  232. i=0;
  233. if( (gPublic_Flag&RECORD_NULL_F_1)==0 )
  234. {
  235. gSpeed_Disp=gSpeed_Record;
  236. gSpeed=(gSpeed_Record/3.6)+0.5;
  237. i=1;
  238. }
  239. else if(  (gPublic_Flag&RECORD_NULL_F_1)
  240. &&( (gPublic_Flag&GPS_NULL_F_1)==0) )
  241. {
  242. gSpeed_Disp=(gSpeed_Gps*3.6)+0.5;
  243. gSpeed=gSpeed_Gps;
  244. i=1;
  245. }
  246. if(i==1)
  247. {
  248. //1;判断与超速报警相关的处理
  249. if( (gSpeed>=gMAX_Speed)&&(gSpeed<80)&&(gMAX_Speed>=10) )
  250. {
  251. gOver_Speed_Count++;
  252. }
  253. else
  254. {
  255. gOver_Speed_Count=0;
  256. if(gAlarm_Type==OVER_SPEED_ALARM) gInternal_Flag|=STOP_OVERSPEED_F_1;
  257. }
  258. //2;判断关于制动方面的处理,在GPS数据有效的状态下，判断速度是否小于某一个值，并且持续5秒
  259. if( (gSpeed==0)||(gSpeed<=2) ) gSTOP_Speed_Count++;
  260. else gSTOP_Speed_Count=0;
  261. }
  263. //每秒向显示终端发送数据
  264. //===================================================
  265. if(  (gDisp_Buffer_Point+14<=sizeof(gDisp_Buffer))
  266.    &&((gCommon_Flag&ALLOW_OUT_DISP_F_1)==0)   )
  267. {
  268. gDisp_Buffer[gDisp_Buffer_Point]=14;
  269. gDisp_Buffer_Point++;
  270. gDisp_Buffer[gDisp_Buffer_Point]=0;
  271. gDisp_Buffer_Point++;
  272. gDisp_Buffer[gDisp_Buffer_Point]='@';
  273. gDisp_Buffer_Point++;
  274. gDisp_Buffer[gDisp_Buffer_Point]='%';
  275. gDisp_Buffer_Point++;
  276. gDisp_Buffer[gDisp_Buffer_Point]=12;
  277. gDisp_Buffer_Point++;
  278. gDisp_Buffer[gDisp_Buffer_Point]=DISP_MAIN_SYS_STATUS_DOWN;
  279. gDisp_Buffer_Point++;
  280. if(gGeneral_Flag&GPS_VALID_F_1)
  281. {
  282. gDisp_Buffer[gDisp_Buffer_Point]=0x01; //GPS有效
  283. }
  284. else
  285. {
  286. gDisp_Buffer[gDisp_Buffer_Point]=0x00; //GPS无效
  287. }
  288. gDisp_Buffer_Point++;
  289. gDisp_Buffer[gDisp_Buffer_Point]=gSignal; //信号强度
  290. gDisp_Buffer_Point++;
  291. if(gM22_Status==TCP_ONLINE_WORK)
  292. {
  293. gDisp_Buffer[gDisp_Buffer_Point]=1; //TCP的在线状态
  294. }
  295. else
  296. {
  297. gDisp_Buffer[gDisp_Buffer_Point]=0;
  298. }
  299. gDisp_Buffer_Point++;
  300. gDisp_Buffer[gDisp_Buffer_Point]=gSpeed_Disp; //当前速度
  301. gDisp_Buffer_Point++;
  302. gDisp_Buffer[gDisp_Buffer_Point]=gDisp_Status; //预留
  303. gDisp_Buffer_Point++;
  304. gDisp_Buffer[gDisp_Buffer_Point]=0; //预留
  305. gDisp_Buffer_Point++;
  306. gDisp_Buffer[gDisp_Buffer_Point]='$';
  307. gDisp_Buffer_Point++;
  308. gDisp_Buffer[gDisp_Buffer_Point]='&';
  309. gDisp_Buffer_Point++;
  310. }
  311. }
  312. /********************************************************
  313. A5; 判断是否产生超速度报警的条件和结束超速报警的条件
  314. ********************************************************/
  315. if( gOver_Speed_Count>4 )
  316. {
  317. gOver_Speed_Count=0;
  318. if(gAlarm_Type==NOP_ALARM)
  319. {
  320. gAlarm_Type = OVER_SPEED_ALARM;
  321. gCycle_Send_Status=ALARM_DATA;
  322. gCircle_Timer=0;
  323. gCycle_Alarm=ALARM_CIRCLE_TIME;
  324. gSMS_ACK[ALARM_ACK]=0;
  325. Circle_Data_TCP(ALARM_UP,gSMS_ACK[ALARM_ACK]);
  326. Send_Over_Alarm_to_Disp(gAlarm_Type);
  327. gInternal_Flag|=SEND_CIRCLE_F_1;
  328. Judge_SMS_Way();
  329. }
  330. }
  331. else if( (gAlarm_Type==OVER_SPEED_ALARM)&&(gInternal_Flag&STOP_OVERSPEED_F_1) )
  332. {
  333. gAlarm_Type=NOP_ALARM;
  334. gCycle_Send_Status=NOP_DATA;
  335. gAlarm_Count=0;
  336. gStatus2_Flag&=~ROB_ALARM_F_1;
  337. gInternal_Flag&=~STOP_OVERSPEED_F_1;
  338. gCircle_Timer=0;
  339. gOver_Speed_Count=0;
  340. Circle_Data_TCP(VEHICLE_RUNDATA_UP,0);
  341. gInternal_Flag|=SEND_CIRCLE_F_1;
  342. Judge_SMS_Way();
  343. }
  344. /********************************************************
  345. A6;判断是否产生疲劳驾驶报警和结束疲劳驾驶报警的条件
  346. ********************************************************/
  347. //A6-1:产生疲劳驾驶报警的条件
  348. if( gOver_Tire_Count>4 )
  349. {
  350. gOver_Speed_Count=0;
  351. if(gAlarm_Type==NOP_ALARM)
  352. {
  353. gAlarm_Type = OVER_TIRE_ALARM;
  354. gCycle_Send_Status=ALARM_DATA;
  355. gCircle_Timer=0;
  356. gCycle_Alarm=ALARM_CIRCLE_TIME;
  357. gSMS_ACK[ALARM_ACK]=0;
  358. Circle_Data_TCP(ALARM_UP,gSMS_ACK[ALARM_ACK]);
  359. Send_Over_Alarm_to_Disp(gAlarm_Type);
  360. gInternal_Flag|=SEND_CIRCLE_F_1;
  361. Judge_SMS_Way();
  362. }
  363. }
  364. //A6-2:结束疲劳驾驶报警的条件
  365. else if (gStop_Tire_Count>4)
  366. {
  367. gStop_Tire_Count=0;
  368. if(gAlarm_Type==OVER_TIRE_ALARM)
  369. {
  370. gAlarm_Type = NOP_ALARM;
  371. gCycle_Send_Status = NOP_DATA;
  372. gAlarm_Count=0;
  373. gCircle_Timer=0;
  374. gCycle_Alarm=0;
  375. Circle_Data_TCP(VEHICLE_RUNDATA_UP,0);
  376. gInternal_Flag|=SEND_CIRCLE_F_1;
  377.   Judge_SMS_Way();
  378. }
  379. }
  380. /********************************************************
  381. A7;如果ACC检测线处于开启的状态，则需要进行开启模块电源的操作
  382. 但如果处于关闭状态，则进行时间统计，如果超过48小时仍然为关闭状态，
  383. 则需要进行关闭两个模块的电源供电，以达到节省用电的目的
  384. ********************************************************/
  385. //ACC检测处于开启状态
  386. if(gStatus1_Flag&ACC_ON_F_1)
  387. {
  388. if(   (gPublic_Flag&ACCOFF_TRACK_F_1)
  389. ||(gPublic_Flag&ACCOFF_OK_F_1) )
  390. {
  391. if((gCommon_Flag&ALLOW_RESET_MCU_F_1)==0)
  392. {
  393. P6OUT&=~POWER_ON_OFF;
  394. gCommon_Flag|=ALLOW_RESET_MCU_F_1;
  395. gRload_Flash_Par_Timer=RLAOD_FLASH_TIME-5;
  396. }
  397. //      Send_COM1_String((unsigned char *)POWER_OFF,sizeof(POWER_OFF));
  398. // gOther_Flag|=RESET_PROGRAME_F_1;
  399. // while(1);
  400. }
  401. else if(gPublic_Flag&ACC_OFF_UP_F_1)
  402. {
  403. gPublic_Flag&=~ACC_OFF_UP_F_1;
  404. }
  405. }
  406. //ACC检测处于关闭状态
  407. else
  408. {
  409. //1，先发送一个信息上传
  410. if(   ((gPublic_Flag&ACC_OFF_UP_F_1)==0)
  411. &&((gPublic_Flag&ACCOFF_TRACK_F_1)==0)
  412. &&((gPublic_Flag&ACCOFF_OK_F_1)==0)
  413. &&(gCycle_Send_Status!=WATCH_DATA)
  414. &&(gCycle_Send_Status!=ALARM_DATA) )
  415. {
  416. gPublic_Flag|=ACC_OFF_UP_F_1;
  417. ACC_OFF_Timer=0;
  418. Circle_Data_TCP(VEHICLE_RUNDATA_UP,0);
  419. gInternal_Flag|=SEND_CIRCLE_F_1;
  420. Send_COM1_String( (unsigned char *)OFF_ACC,sizeof(OFF_ACC) );
  421.   Judge_SMS_Way();
  422. }
  423. //2，ACC持续关闭时间达到满足改变上传行车轨迹的时间间隔
  424. else if(  (ACC_OFF_Timer<ACC_LASTOFF_TIME)
  425.         &&(ACC_OFF_Timer>=ACC_CHANGEOFF_TIME)
  426. &&(gPublic_Flag&ACC_OFF_UP_F_1 )
  427. &&((gPublic_Flag&ACCOFF_TRACK_F_1)==0)
  428. &&((gPublic_Flag&ACCOFF_OK_F_1)==0)
  429. &&(gCycle_Send_Status!=WATCH_DATA)
  430. &&(gCycle_Send_Status!=ALARM_DATA)  )
  431. {
  432. if(   (gCycle_TCP<ACCOFF_TRACK_TIME)
  433. &&(gCycle_TCP>0) )
  434. {
  435. gCycle_TCP=ACCOFF_TRACK_TIME;
  436. }
  437. gPublic_Flag|=ACCOFF_TRACK_F_1;
  438. }
  440. //3，持续规定的一段时间后，则需要关闭模块电源
  441. else if(   (ACC_OFF_Timer>ACC_LASTOFF_TIME)
  442. &&(gPublic_Flag&ACC_OFF_UP_F_1)
  443. &&(gPublic_Flag&ACCOFF_TRACK_F_1 )
  444. &&((gPublic_Flag&ACCOFF_OK_F_1)==0)
  445. &&(gCycle_Send_Status!=WATCH_DATA)
  446. &&(gCycle_Send_Status!=ALARM_DATA)  )
  447. {
  448. P6OUT|=POWER_ON_OFF;
  449. gPublic_Flag|=ACCOFF_OK_F_1;
  450. gReset_M22_On_Setp=0;
  451. gGeneral_Flag&=~RESET_GSM_ON_F_1;
  452. gM22_Status=GSM_WORK;
  453. gGeneral_Flag&=~LAND_TCP_SUCCESS_F_1;
  454. gGSM_Oper_Type=GSM_PHONE;
  455. gInternal_Flag&=~GSM_ONEAT_SUCCESS_1;
  456. gPhone_Step=0;gTimer_GSM_AT=0;
  457. }
  459. //3，关闭模块电源
  460. else if( gPublic_Flag&ACCOFF_OK_F_1 )
  461. {
  462. P6OUT|=POWER_ON_OFF;
  463. gGeneral_Flag&=~OFF_M22_F_1;
  464. gGeneral_Flag&=~OFF_GPS_F_1;
  465. gM22_GSM_ECHO_Timer=0;
  466. gFF0D_Receive_Timer=0;
  467. gGPS_No_Output_Timer=0;
  468. gGPS_Invaild_Timer=0;
  469. gGeneral_Flag&=~RESET_GSM_ON_F_1;
  470. }
  471. }
  472. /********************************************************
  473. A8;判断是否可以执行制动或者解除制动操作,制动方面的信息不存储在Flash中
  474. ********************************************************/
  475. //1,是否允许执行制动操作
  476. /*
  477. if( (gM22_Stop_Status==ALLOW_SET_STOP)&&(gSTOP_Speed_Count>=5) )
  478. {
  479. gM22_Stop_Status=ASK_SET_STOP;
  480. P6OUT|=STOP_Q1;
  481. P6OUT|=STOP_Q2;
  483. P6OUT|=STOP_Q1;
  484. P6OUT|=STOP_Q2;
  485. gOK_Count=0;gError_Count=0;
  486. }
  487. //2,是否允许执行解除制动操作
  488. else if(gM22_Stop_Status==ALLOW_FREE_STOP)
  489. {
  490. gM22_Stop_Status=ASK_FREE_STOP;
  491. P6OUT&=~STOP_Q1;
  492. P6OUT&=~STOP_Q2;
  494. P6OUT&=~STOP_Q1;
  495. P6OUT&=~STOP_Q2;
  496. gOK_Count=0;gError_Count=0;
  497. }
  498. */
  499. /********************************************************
  500. A9; 制动结果的检测和判断
  501. ********************************************************/
  502. if(gCheck_Stop_Timer>500)
  503. {
  504. gCheck_Stop_Timer=0;
  505. /*
  506. if(   (gM22_Stop_Status==ASK_SET_STOP) //执行制动动作的状态下
  507. ||(gM22_Stop_Status==STOP_STATUS) ) //已经制动的状态下
  508. {
  509. if(P2IN&CHECK_ON_OFF) gOK_Count++;
  510. else gError_Count++;
  512. if( (gOK_Count+gError_Count)>60)
  513. {
  514. if(gOK_Count>45)
  515. {
  516. gStatus1_Flag|=STOP_SUCCESS_F_1;
  517. gM22_Stop_Status=STOP_STATUS;
  518. }
  519. else
  520. {
  521. gStatus1_Flag&=~STOP_SUCCESS_F_1;
  522. gM22_Stop_Status=NOP_READY;
  523. }
  524. gOK_Count=0;gError_Count=0;
  525. }
  526. }
  527. else if(   (gM22_Stop_Status==ASK_FREE_STOP) //执行解除制动动作的状态下
  528.  ||(gM22_Stop_Status==NOP_READY) ) //已经确定解除制动的状态下
  529. {
  530. if( (P2IN&CHECK_ON_OFF)==0 ) gOK_Count++;
  531. else gError_Count++;
  533. if( (gOK_Count+gError_Count)>60)
  534. {
  535. if(gOK_Count>45)
  536. {
  537. gStatus1_Flag&=~STOP_SUCCESS_F_1;
  538. gM22_Stop_Status=NOP_READY;
  539. }
  540. else
  541. {
  542. gStatus1_Flag|=STOP_SUCCESS_F_1;
  543. gM22_Stop_Status=STOP_STATUS;
  544. }
  545. gOK_Count=0;gError_Count=0;
  546. }
  547. }
  548. */
  549. }
  550. /********************************************************
  551. A12;判断周期数据发送的状态(这里是处理如果有行车轨迹，后来又有了类似报警，后来报警解除后的行车轨迹的继续上传的操作)
  552. ********************************************************/
  553. if( (gGeneral_Flag&TCP_IP_VALID_1)&&((gON_OFF_Temp0&TCP_LAND_ON_OFF_1)==0) )
  554. {
  555. if( (gCycle_TCP>0)&&(gCycle_Send_Status==NOP_DATA) )
  556. {
  557. gCycle_Send_Status=TRACK_DATA_TIME;gCircle_Timer=0;
  558. gInternal_Flag&=~SEND_CIRCLE_F_1;gGSM_Work_Count=0;gCheck_Data=0;
  559. }
  560. else if(    (gCycle_Distance>0)
  561.   &&(gCycle_Send_Status==NOP_DATA) )
  562. {
  563. gCycle_Send_Status=TRACK_DATA_DISTANCE;gCircle_Timer=0;
  564. gInternal_Flag&=~SEND_CIRCLE_F_1;gGSM_Work_Count=0;gCheck_Data=0;
  565. }
  566. }
  567. else
  568. {
  569. if(   (gCycle_GSM>0)
  570. &&(gCycle_Send_Status==NOP_DATA) )
  571. {
  572. gCycle_Send_Status=TRACK_DATA_TIME;gCircle_Timer=0;
  573. gInternal_Flag&=~SEND_CIRCLE_F_1;gGSM_Work_Count=0;gCheck_Data=0;
  574. }
  575. else if(   (gCycle_Distance>0)
  576.  &&(gCycle_Send_Status==NOP_DATA) )
  577. {
  578. gCycle_Send_Status=TRACK_DATA_DISTANCE;gCircle_Timer=0;
  579. gInternal_Flag&=~SEND_CIRCLE_F_1;gGSM_Work_Count=0;gCheck_Data=0;
  580. }
  581. }
  582. /********************************************************
  583. A13;在TCP在线的工作方式下，如果检测到有来电（通过管脚电平变化的检测）
  584. ********************************************************/
  585. if(gM22_Status==TCP_ONLINE_WORK)
  586. {
  587. if(Ring_Test_Step==0)
  588. {
  589. if( (P1IN&RING_TEST)==0 )
  590. {
  591. Ring_Test_Step=1;
  592. gRing_Test_Timer=0;
  593. }
  594. }
  595. else if(Ring_Test_Step==1)
  596. {
  597. if(P1IN&RING_TEST)
  598. {
  599. Ring_Test_Step=0;
  600. gRing_Test_Timer=0;
  601. }
  602. else if(gRing_Test_Timer>RING_TEST_TIME)
  603. {
  604. if( (gGeneral_Flag&TCP_PHONE_F_1)==0 )
  605. {
  606. if((gGeneral_Flag&RING_F_1)==0) gHangUp_Timer=0;
  607. gGeneral_Flag|=TCP_PHONE_F_1;
  608. gStatus1_Flag|=PHONE_ONLINE_F_1;
  609. gGeneral_Flag|=RING_F_1;
  610. }
  611. Ring_Test_Step=0;gRing_Test_Timer=0;
  612. }
  613. }
  614. else
  615. {
  616. Ring_Test_Step=0;
  617. gRing_Test_Timer=0;
  618. }
  619. }
  620. /********************************************************
  621. A14;如果判断接收驾驶员信息未成功，则需要周期向记录仪发送查询驾驶员信息。
  622. 直到设置成功为止
  623. 这里取消GPS主动查询驾驶员信息的程序操作
  624. ********************************************************/
  625. /*
  626. //1,判断是否需要查询记录仪的驾驶员信息数据
  627. if(   (gGet_Driver_Info_Count>GET_DRIVER_INFO_TIME)
  628. &&(gDriver_Info==READY_READ_DRIVER_INFO)
  629. &&(gStatus==NORMAL_TYPE)   )
  630. {
  631.      Send_COM1_Byte(gStatus);
  632.      Check_Record = gStatus;
  633.      Send_COM1_Byte(0xAA);
  634.      Check_Record ^= 0xAA;
  635.      Send_COM1_Byte(0x75);
  636.      Check_Record ^= 0x75;
  637.      Send_COM1_Byte(K_GET_DRIVEDATA_E_ECHO);
  638.      Check_Record ^= K_GET_DRIVEDATA_E_ECHO;
  639.      Send_COM1_Byte(0x00);
  640.      Check_Record ^= 0;
  641.      Send_COM1_Byte(0x00);
  642.      Check_Record ^= 0;
  643.      Send_COM1_Byte(0x00);
  644.      Check_Record ^= 0;
  645.      Send_COM1_Byte(Check_Record); //校验核
  646.      Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a); //包尾
  647.      gGet_Driver_Info_Count=0;
  648.      gDriver_Info=WAIT_RETURN_DRIVER_INFO;
  650. }
  651. //2,等待查询记录仪的驾驶员信息返回失败，则需要从新开始计算时间等下一个周期的查询
  652. else if(  (gDriver_Info==WAIT_RETURN_DRIVER_INFO)
  653. &&(gGet_Driver_Info_Count>WAIT_RETURNINFO_TIME) )
  654. {
  655. gGet_Driver_Info_Count=0;
  656. gDriver_Info=READY_READ_DRIVER_INFO;
  657. }
  658. */
  659. //3,判断是否满足需要想显示终端发送驾驶员信息的数据条件
  660. /*
  661. if(   (gGet_Driver_Info_Count>READY_SENDINFO_TIME)
  662.  &&(gDriver_Info==GET_DRIVER_INFO)
  663.  &&(gInternal_Flag&DISP_ON_F_1)     )
  664. {
  665. //发送记录仪的驾驶员当前信息给显示屏
  666. if(gDisp_Buffer_Point+37<=sizeof(gDisp_Buffer))
  667. {
  668. gDisp_Buffer[gDisp_Buffer_Point]=37;
  669. gDisp_Buffer_Point++;
  670. gDisp_Buffer[gDisp_Buffer_Point]=0;
  671. gDisp_Buffer_Point++;
  672. gDisp_Buffer[gDisp_Buffer_Point]='@';
  673. gDisp_Buffer_Point++;
  674. gDisp_Buffer[gDisp_Buffer_Point]='%';
  675. gDisp_Buffer_Point++;
  676. gDisp_Buffer[gDisp_Buffer_Point]=35;
  677. gDisp_Buffer_Point++;
  678. gDisp_Buffer[gDisp_Buffer_Point]=DISP_MAIN_IC_INFO_DOWN;
  679. gDisp_Buffer_Point++;
  680. SRAM_Init();
  681. for(i=0;i<29;i++)
  682. {
  683.   gDisp_Buffer[gDisp_Buffer_Point]=SRAM_Read(SRAM_DRIVER_INFO_CODE+i);
  684. gDisp_Buffer_Point++;
  685. }
  686. gDisp_Buffer[gDisp_Buffer_Point]='$';
  687. gDisp_Buffer_Point++;
  688. gDisp_Buffer[gDisp_Buffer_Point]='&';
  689. gDisp_Buffer_Point++;
  690. gGet_Driver_Info_Count=0;
  691. gDriver_Info=WAIT_SEND_DRIVER_INFO;
  692. }
  693. }
  694. //4，如果等待显示屏幕接收到驾驶员信息超时间无响应，则应该重新发送
  695. else if(   (gGet_Driver_Info_Count>WAIT_DISPINFO_TIME)
  696.  &&(gDriver_Info==WAIT_SEND_DRIVER_INFO)  )
  697. {
  698. gGet_Driver_Info_Count=0;
  699. gDriver_Info=GET_DRIVER_INFO;
  700. }
  701. */
  702. /********************************************************
  703. A15,判断接收记录仪是否长时间没有向主控发送数据
  704. ********************************************************/
  705. if( gRecord_Data_Timer > OVER_RECORD_DATA_TIME )
  706. {
  707. //超时，如果记录仪显示为正常状态，则认为记录仪故障
  708. if( (gStatus2_Flag&RECORD_VAILD_F_1)==0 )
  709. {
  710. gStatus2_Flag|=RECORD_VAILD_F_1;
  711. gRecord_Status=0;
  712. }
  713. }
  714. /********************************************************
  715. A16,每间隔12个小时，需要重新启动程序一次
  716. 这部分的功能已经转移到中断中去执行
  717. ********************************************************/
  718. /********************************************************
  719. A17;如果需要向记录仪发送设置间隔距离的是否成功，如果成功收到记录仪
  720. 的响应，则不需要进行此操作，如果超过5秒仍然未收到响应，则间隔发送设置命令
  721. 连续发送5次，如果仍然无响应，则停止发送
  722. ********************************************************/
  723. if(   ((gPublic_Flag&SET_DISTANCE_OK_F_1)==0)
  724. &&(gSet_Distance_Info_Count>WAIT_DISPINFO_TIME)
  725. &&(gStatus==NORMAL_TYPE)
  726. &&(gSend_Record_Count<5) )
  727. {
  728. gSend_Record_Count++;
  729.      Send_COM1_Byte(gStatus);
  730.      Check_Record = gStatus;
  731.      Send_COM1_Byte(0xAA);
  732.      Check_Record ^= 0xAA;
  733.      Send_COM1_Byte(0x75);
  734.      Check_Record ^= 0x75;
  735.      Send_COM1_Byte(K_SET_INTERDISTANCE);
  736.      Check_Record ^= K_SET_INTERDISTANCE;
  737.      Send_COM1_Byte(0x00);
  738.      Check_Record ^= 0;
  739.      Send_COM1_Byte(0x02); //长度
  740.      Check_Record ^= 0x02;
  741.      Send_COM1_Byte(0x00); //预留
  742.      Check_Record ^= 0;
  743.      Send_COM1_Byte(gCycle_Distance/0x100); //距离值的高位字节
  744.      Check_Record ^= gCycle_Distance/0x100;
  745.      Send_COM1_Byte(gCycle_Distance%0x100); //距离值的低位字节
  746.      Check_Record ^= gCycle_Distance%0x100;
  747.      Send_COM1_Byte(Check_Record); //校验核
  748.      Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a); //包尾
  749.      gSet_Distance_Info_Count=0;
  750. }
  751. /********************************************************
  752. A18;判断是否向显示屏发送显示屏上行信息的响应,
  753. ********************************************************/
  754. if(gPublic_Flag&DISP_SEND_INFO_F_1)
  755. {
  756. i=SRAM_Read(OTHER_SMS_2);
  757. if(i==VAILD_2);
  758. else
  759. {
  760. gPublic_Flag &= ~DISP_SEND_INFO_F_1;
  761. if(gDisp_Buffer_Point+7+2<=sizeof(gDisp_Buffer))
  762. {
  763. gDisp_Buffer[gDisp_Buffer_Point]=7+2;
  764. gDisp_Buffer_Point++;
  765. gDisp_Buffer[gDisp_Buffer_Point]=0;
  766. gDisp_Buffer_Point++;
  767. gDisp_Buffer[gDisp_Buffer_Point]='@';
  768. gDisp_Buffer_Point++;
  769. gDisp_Buffer[gDisp_Buffer_Point]='%';
  770. gDisp_Buffer_Point++;
  771. gDisp_Buffer[gDisp_Buffer_Point]=7;
  772. gDisp_Buffer_Point++;
  773. gDisp_Buffer[gDisp_Buffer_Point]=DISP_MAIN_INFO_ECHO_DOWN;
  774. gDisp_Buffer_Point++;
  775. gDisp_Buffer[gDisp_Buffer_Point]=COMMAND_OK;
  776. gDisp_Buffer_Point++;
  777. gDisp_Buffer[gDisp_Buffer_Point]='$';
  778. gDisp_Buffer_Point++;
  779. gDisp_Buffer[gDisp_Buffer_Point]='&';
  780. gDisp_Buffer_Point++;
  781. }
  782. }
  783. }
  784. /********************************************************
  785. B1;关于判断ACC检测和车载的空载/重载方面的程序检测
  787. 补充说明：
  788. 1， Test_Status_Step=0的时候检测ACC的检测线的状态，分为两种情况，如果此时ACC检测线处于开启状态标志或者关闭状态的标志，
  789. 则需要检测ACC检测线的实际状态量是否发生变化，如果没有，则直接设置Test_Status_Step=2，如果有则设置Test_Status_Step=1。
  790. 2，Test_Status_Step=1的时候，则说明检测到ACC的检测线实际状态量有变化，则在这个步骤中检测状态量的变化是否持续符合条件的时间
  791. 如果检测符合时间条件，则改变ACC的状态量标志，设置Test_Status_Step=0;
  792. 3，Test_Status_Step=2的时候，则说明ACC的检测无变化，则进行车载的空载/重载线的状态检测，如果分为两种情况如果此时检测空载/重载是处于空或者
  793. 重，则需要检测空载/重载线的实际状态量是否改变，如过检测到有改变则设置Test_Status_Step=3.否则设置Test_Status_Step=0
  794. 4，Test_Status_Step=3的时候，则说明空载/重载线检测到有所变化，则在这个步骤中检测状态量的变化持续时间是否符合要求，如果符合要求
  795. 则改变空载/重载线的状态量的标志。同时设置Test_Status_Step=0
  796. ********************************************************/
  797. if(Test_Status_Step==0)
  798. {
  799. //1，如果ACC检测线开启标志的状态下，检测是否ACC检测线关闭
  800. if(gStatus1_Flag&ACC_ON_F_1)
  801. {
  802. if(P3IN&ACC_TEST)
  803. {
  804. gTest_Status_Timer=0;
  805. Test_Status_Step=1;
  806. }
  807. }
  808. //2，如果已经存在ACC线关闭标志的状态下，检测是否ACC检测线开启
  809. else
  810. {
  811. if( (P3IN&ACC_TEST)==0)
  812. {
  813. gTest_Status_Timer=0;
  814. Test_Status_Step=2;
  815. }
  816. }
  817. }
  818. else if(Test_Status_Step==1)
  819. {
  820. if( (P3IN&ACC_TEST)==0 )
  821. {
  822. gTest_Status_Timer=0;
  823. Test_Status_Step=0;
  824. }
  825. //判断延迟时间内检测到，则认为ACC关闭
  826. else if(gTest_Status_Timer>TEST_ACC_TIME)
  827. {
  828. gStatus1_Flag&=~ACC_ON_F_1;
  829. gTest_Status_Timer=0;
  830. Test_Status_Step=0;
  831. }
  832. }
  833. else if(Test_Status_Step==2)
  834. {
  835. if(P3IN&ACC_TEST)
  836. {
  837. gTest_Status_Timer=0;
  838. Test_Status_Step=0;
  839. }
  840. //判断延迟时间内检测到，则认为ACC开启
  841. else if(gTest_Status_Timer>TEST_ACC_TIME)
  842. {
  843. gStatus1_Flag|=ACC_ON_F_1;
  844. gTest_Status_Timer=0;
  845. Test_Status_Step=0;
  846. }
  847. }
  848. else
  849. {
  850. gTest_Status_Timer=0;
  851. Test_Status_Step=0;
  852. }
  853. /********************************************************
  854. B3;关于判断是否被劫报警方面的程序处理
  855. ********************************************************/
  856. if(Test_Alarm_Step==0)
  857. {
  858. if((P2IN&ARALM)==0 )
  859. {
  860. Test_Alarm_Step=1;
  861. gTest_Alarm_Timer=0;
  862. }
  863. }
  864. else if(Test_Alarm_Step==1)
  865. {
  866. if(P2IN&ARALM)
  867. {
  868. Test_Alarm_Step=0;
  869. gTest_Alarm_Timer=0;
  870. }
  871. else if(gTest_Alarm_Timer>=ROB_TIME)
  872. {
  873. if(gM22_Status==GSM_WORK) gAlarm_Count=ALARM_COUNT;
  874. if( gAlarm_Type!=ROB_ALARM )
  875. {
  876. gAlarm_Type=ROB_ALARM;
  877. gStatus2_Flag|=ROB_ALARM_F_1;
  878. #ifdef Debug_GSM_COM1
  879. Send_COM1_Byte('S');Send_COM1_Byte('O');Send_COM1_Byte('S');
  880. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  881. #endif
  882. gCycle_Alarm=ALARM_CIRCLE_TIME;
  883. gCycle_Send_Status=ALARM_DATA;
  884. //被劫报警的上报的处理方式
  885. //1,组织数据包
  886. gCircle_Timer=0;
  887. Circle_Data_TCP(ALARM_UP,gSMS_ACK[ALARM_ACK]);
  888. gInternal_Flag|=SEND_CIRCLE_F_1;
  889. Judge_SMS_Way();
  890. }
  891. Test_Alarm_Step=0;
  892. gTest_Alarm_Timer=0;
  893. }
  894. }
  895. else
  896. {
  897. Test_Alarm_Step=0;
  898. gTest_Alarm_Timer=0;
  899. }
  900. /********************************************************
  901. B4;判断是否有报警报警信息的发送(暂时增加一个条件)
  902. ********************************************************/
  903. if(   (gAlarm_Type!=NOP_ALARM)
  904.     &&(gCycle_Send_Status==ALARM_DATA)
  905.     &&(gCycle_Alarm>4) )
  906. {
  907. if( gCircle_Timer>gCycle_Alarm )
  908. {
  909. gCircle_Timer=0;
  910. Circle_Data_TCP(ALARM_UP,gSMS_ACK[ALARM_ACK]);
  911. //如果属于超速报警,则同时发送一个信息给显示终端
  912. if(   (gAlarm_Type==OVER_AREA_ALARM) //区域报警
  913. ||(gAlarm_Type==OVER_SPEED_ALARM) //超速报警
  914. ||(gAlarm_Type==OVER_TIRE_ALARM) //疲劳驾驶报警
  915. ||(gAlarm_Type==OVER_LINE_ALARM) ) //线路偏移报警
  916. {
  917. Send_Over_Alarm_to_Disp(gAlarm_Type);
  918. }
  919. gInternal_Flag|=SEND_CIRCLE_F_1;
  920. if(gM22_Status==GSM_WORK)
  921. {
  922. if(gAlarm_Count==0)
  923. {
  924. gInternal_Flag&=~SEND_CIRCLE_F_1;
  925. gInternal_Flag&=~ALLOW_DATA_F_1;
  926. gCircle_Buffer_Point=0;
  927. }
  928. else
  929. {
  930. gAlarm_Count--;
  931. gInternal_Flag|=ALLOW_DATA_F_1;
  932. }
  933. }
  934. }
  935. }
  936. /********************************************************
  937. B4-1;判断是否处于重点监控的传输方式
  938. ********************************************************/
  939. if( gCycle_Send_Status==WATCH_DATA )
  940. {
  941. //1，如果处于按定时间传输数据的方式
  942. if(gWatch_Type==WATCH_TYPE_TIME)
  943. {
  944. if(gWatch_Time==0)
  945. {
  946. gWatch_Count=0;gWatch_Time=0;
  947. gCycle_Send_Status=NOP_DATA;
  948. gWatch_Type=WATCH_TYPE_NULL;
  949. Load_Buffer1_Echo(ASK_FREEWATCH_UP,gGeneral_Buffer[5]);
  950. }
  951. else
  952. {
  953. TCP_WORK_Data(gWatch_Circle,VEHICLE_WATCHECHO_UP);
  954. if(gM22_Status==GSM_WORK) gInternal_Flag|=ALLOW_DATA_F_1;
  955. }
  956. }
  957. else if(gWatch_Type==WATCH_TYPE_COUNT)
  958. {
  959. if(gWatch_Count==0)
  960. {
  961. gWatch_Count=0;gWatch_Time=0;
  962. gCycle_Send_Status=NOP_DATA;
  963. gWatch_Type=WATCH_TYPE_NULL;
  964. Load_Buffer1_Echo(ASK_FREEWATCH_UP,gGeneral_Buffer[5]);
  965. }
  966. else
  967. {
  968. TCP_WORK_Data(gWatch_Circle,VEHICLE_WATCHECHO_UP);
  969. if(   (gInternal_Flag&SEND_CIRCLE_F_1)
  970. &&( gWatch_Count>0 ) )
  971. {
  972. if(gM22_Status==GSM_WORK) gInternal_Flag|=ALLOW_DATA_F_1;
  973. }
  974. }
  975. }
  976. }
  978. /********************************************************
  979. B5;关于区域报警的检测程序
  980. 说明：区域报警方式和超速度报警方式一样，每隔5秒种进行一次区域报警的检测
  981. 累计5次，检测有效，则认为属于区域报警，一旦检测无满足条件的区域
  982. 则立刻停止区域报警。(所有的检测条件必须是在GPS数据有效的状态下判断)
  983. ********************************************************/
  984. if( (gTimer_Area_Test>INTER_ATRA_TEST)&&(gGeneral_Flag&GPS_VALID_F_1)&&(gArea_Par!=0) )
  985. {
  986. gTimer_Area_Test=0;
  987. Area_All=0;
  988. Check_Result=0;
  989. // Send_COM1_Byte('(');
  990. for(i=1;i<=4;i++)
  991. {
  992. //依次检查4个区域的数据
  993. Check_Result=Check_Area_Alarm(i);
  994. //Send_COM1_Byte(ASCII(Check_Result));
  995. //返回1，则说明当前点在禁入区域内
  996. if(Check_Result==1)
  997. {
  998. //满足条件，则跳出此循环
  999. Area_All=1;break;
  1000. }
  1001. //返回2，则说明当前点的在禁出区域内
  1002. else if(Check_Result==2)
  1003. {
  1004. Area_All=0;
  1005. //go on
  1006. }
  1007. //返回3，则说明当前点不在禁入区域内
  1008. else if(Check_Result==3)
  1009. {
  1010. //go on
  1011. }
  1012. //返回4，则说明当前点不在禁出区域内
  1013. else if(Check_Result==4)
  1014. {
  1015. //需要判断完所有的禁出区域，如果当前点只要在一个禁出区域内，则认为无满足条件
  1016. Area_Out_Num++;
  1017. }
  1018. //返回0。则说明当前判断区域数据无效
  1019. else if(Check_Result==0)
  1020. {
  1021. //go on
  1022. }
  1023. }
  1024. /*
  1025. Send_COM1_Byte(')');
  1026. Send_COM1_Byte(0x0d);Send_COM1_Byte(0x0a);
  1027. */
  1028. SRAM_Init();
  1029. j=SRAM_Read(SAREA_OUT_NUM);
  1030. if( (Area_All==0)&&(Area_Out_Num>=j)&&(j<=4)&&(j>0))
  1031. {
  1032. Area_All=1;
  1033. }
  1034. else if( (Area_All==0)&&(gAlarm_Type==OVER_AREA_ALARM))
  1035. {
  1036. gAlarm_Type=NOP_ALARM;
  1037. gCycle_Send_Status=NOP_DATA;
  1038. gAlarm_Count=0;
  1039. gCircle_Timer=0;
  1040. gArea_No_Count=0;
  1041. Circle_Data_TCP(VEHICLE_RUNDATA_UP,0);
  1042. gInternal_Flag|=SEND_CIRCLE_F_1;
  1043.   Judge_SMS_Way();
  1044. }
  1045. if( (Area_All==1)&&(gAlarm_Type==NOP_ALARM) )
  1046. {
  1047. gArea_No_Count++;
  1048. }
  1049. }
  1050. if( (gArea_No_Count>5)&&(gAlarm_Type==NOP_ALARM) )
  1051. {
  1052. gArea_No_Count=0;
  1053. gAlarm_Type = OVER_AREA_ALARM;
  1054. gCycle_Send_Status=ALARM_DATA;
  1055. gCircle_Timer=0;
  1056. gCycle_Alarm=ALARM_CIRCLE_TIME;
  1057. gSMS_ACK[ALARM_ACK]=0;
  1058. Circle_Data_TCP(ALARM_UP,gSMS_ACK[ALARM_ACK]);
  1059. Send_Over_Alarm_to_Disp(gAlarm_Type);
  1060. gInternal_Flag|=SEND_CIRCLE_F_1;
  1061. if(gM22_Status==GSM_WORK)
  1062. {
  1063. gAlarm_Count=ALARM_COUNT;
  1064. }
  1065. Judge_SMS_Way();
  1066. }
  1067. /********************************************************
  1068. B6;与行车轨迹相关的一些处理流程:
  1069. 1,先判断IP地址和开关量
  1070.  1-1：如果IP地址有效果，且开关量处于开启状态
  1071.  1-2：IP地址无效或者开关量未开启
  1072.   1-1-1：如果gCycle_GSM>4且为行车轨迹状态
  1073. ********************************************************/
  1074. //IP地址有效，开关量开启
  1075. if( (gGeneral_Flag&TCP_IP_VALID_1)&&((gON_OFF_Temp0&TCP_LAND_ON_OFF_1)==0) )
  1076. {
  1077. //如果处于GSM工作方式
  1078. if(gM22_Status==GSM_WORK)
  1079. {
  1080. //如果间隔属于大于20分钟
  1081. if( (gCycle_TCP>=TCP_TRACK_MINTIME)&&(gCycle_Send_Status==TRACK_DATA_TIME) )
  1082. {
  1083. TCP_WORK_Data(gCycle_TCP,VEHICLE_RUNDATA_UP);
  1084. }
  1085. //如果间隔属于小于20分钟
  1086. else if( (gCycle_TCP>4)&&(gCycle_TCP<TCP_TRACK_MINTIME)&&(gCycle_Send_Status==TRACK_DATA_TIME) )
  1087. {
  1088. TCP_WORK_Data(SMS_DATA_TIME,VEHICLE_RUNDATA_UP);
  1089. }
  1090. }
  1091. //如果处于TCP的工作方式
  1092. else if( gM22_Status==TCP_ONLINE_WORK )
  1093. {
  1094. if(gCycle_Send_Status==TRACK_DATA_TIME)
  1095. {
  1096. TCP_WORK_Data(gCycle_TCP,VEHICLE_RUNDATA_UP);
  1097. }
  1098. }
  1099. }
  1100. //如果IP地址无效，或者开关量关闭
  1101. else
  1102. {
  1103. if( (gCycle_GSM>4)
  1104. &&(gCycle_Send_Status==TRACK_DATA_TIME)
  1105. &&(gM22_Status==GSM_WORK) )
  1106. {
  1107. GSM_WORK_Data();
  1108. }
  1109. }
  1110. /********************************************************
  1111. ********************************************************/
  1112. /********************************************************
  1113. B7; 关于线路报警的程序部分
  1114. 说明：
  1115. ********************************************************/
  1116. if(   (gStatus3_Flag&LINE_LIMIT_F_1)
  1117. &&(gGeneral_Flag&GPS_VALID_F_1)
  1118. &&(gLine_Num>0)&&(gLine_Num<=60) )
  1119. {
  1120. if(gLine_Timer>8)
  1121. {
  1122. gLine_Timer=0;
  1123. gCommon_Flag&=~LINE_OUT_F_1;
  1124. for(i=0;i<gLine_Num-1;i++)
  1125. {
  1126. Check_Result=Check_Line_Data(i);
  1127. Clear_Exter_WatchDog();
  1128. //Send_COM1_Byte(ASCII(Check_Result%10));
  1129. //计算垂直点在当前线段内，属于需要统计计算距离
  1130. //1,返回0，则表示异常
  1131. if(Check_Result==0);
  1132. //2,返回1，则表示垂直点没落在当前线段内
  1133. else if(Check_Result==1);
  1134. //3,返回2，则说明垂直点落在当前线段内，但距离大于最大限制的值
  1135. else if(Check_Result==2)
  1136. {
  1137. gOver_Line_Count++;
  1138. gCommon_Flag|=LINE_OUT_F_1;
  1139. }
  1140. //4,返回3，说明不满足偏离线路的条件
  1141. else if(Check_Result==3)
  1142. {
  1143. gOver_Line_Count=0;
  1144. gCommon_Flag|=LINE_OUT_F_1;
  1145. if(gAlarm_Type==OVER_LINE_ALARM)
  1146. {
  1147. gCommon_Flag|=STOP_OVERLINE_F_1;
  1148. }
  1149. break;
  1150. }
  1151. }
  1152. if(   (i==gLine_Num-1)
  1153. &&((gCommon_Flag&LINE_OUT_F_1)==0) )
  1154. {
  1155. gOver_Line_Count++;
  1156. }
  1157. }
  1158. }
  1159. if(gOver_Line_Count>2)
  1160. {
  1161. //满足条件，则产生偏离报警
  1162. gOver_Line_Count=0;
  1163. if(gAlarm_Type==NOP_ALARM)
  1164. {
  1165. gAlarm_Type = OVER_LINE_ALARM;
  1166. gCycle_Send_Status=ALARM_DATA;
  1167. gCircle_Timer=0;
  1168. gCycle_Alarm=ALARM_CIRCLE_TIME;
  1169. gSMS_ACK[ALARM_ACK]=0;
  1170. Circle_Data_TCP(ALARM_UP,gSMS_ACK[ALARM_ACK]);
  1171. Send_Over_Alarm_to_Disp(gAlarm_Type);
  1172. gInternal_Flag|=SEND_CIRCLE_F_1;
  1173. if(gM22_Status==GSM_WORK)
  1174. {
  1175. gAlarm_Count=ALARM_COUNT;
  1176. }
  1177. Judge_SMS_Way();
  1178. }
  1179. }
  1180. else if( (gAlarm_Type==OVER_LINE_ALARM)&&(gCommon_Flag&STOP_OVERLINE_F_1) )
  1181. {
  1182. gAlarm_Type=NOP_ALARM;
  1183. gCycle_Send_Status=NOP_DATA;
  1184. gAlarm_Count=0;
  1185. gStatus2_Flag&=~ROB_ALARM_F_1;
  1186. gCommon_Flag&=~STOP_OVERLINE_F_1;
  1187. gCircle_Timer=0;
  1188. gOver_Line_Count=0;
  1189. Circle_Data_TCP(VEHICLE_RUNDATA_UP,0);
  1190. gInternal_Flag|=SEND_CIRCLE_F_1;
  1191. Judge_SMS_Way();
  1192. }
  1193. }
  1194. /********************************************************
  1195. 下面是程序 的子模块部分
  1196. ********************************************************/
  1197. /********************************************************
  1198. * 函数名：Circle_Data_TCP
  1199. 作用域：本地文件调用
  1200. * 功能：  在TCP的工作方式下，如果是报警，或者行车轨迹，或者监控数据，
  1201. 组织到gCircle_Buffer[]缓冲中
  1202. * 参数：
  1204. * 返回值：
  1206. * 创建人：
  1207. *
  1208. * 修改历史：（每条详述）
  1209. ********************************************************/
  1211. void Circle_Data_TCP(unsigned char nCommand,unsigned char nACK )
  1212. {
  1213. unsigned char nInput=29+4;
  1214. unsigned int iCheckOut=0;
  1215. unsigned char nFlag=0;
  1216. nFlag=gAlarm_Type;
  1218. gCircle_Buffer_Point=0;
  1219. gCircle_Buffer[gCircle_Buffer_Point]=SOH;
  1220. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1221. gCircle_Buffer_Point++;
  1222. gCircle_Buffer[gCircle_Buffer_Point]=nCommand;
  1223. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1224. gCircle_Buffer_Point++;
  1225. gCircle_Buffer[gCircle_Buffer_Point]=(char)(~nCommand);
  1226. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1227. gCircle_Buffer_Point++;
  1228. gCircle_Buffer[gCircle_Buffer_Point]=nInput-4;
  1229. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1230. gCircle_Buffer_Point++;
  1231. gCircle_Buffer[gCircle_Buffer_Point]=nACK;
  1232. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1233. gCircle_Buffer_Point++;
  1234. gCircle_Buffer[gCircle_Buffer_Point]=gKind;
  1235. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1236. gCircle_Buffer_Point++;
  1237. gCircle_Buffer[gCircle_Buffer_Point]=gGroup;
  1238. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1239. gCircle_Buffer_Point++;
  1240. gCircle_Buffer[gCircle_Buffer_Point]=gVID/0x100;
  1241. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1242. gCircle_Buffer_Point++;
  1243. gCircle_Buffer[gCircle_Buffer_Point]=gVID%0x100;
  1244. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1245. gCircle_Buffer_Point++;
  1247. gCircle_Buffer[gCircle_Buffer_Point]=gLongitude/0x1000000;
  1248. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1249. gCircle_Buffer_Point++;
  1250. gCircle_Buffer[gCircle_Buffer_Point]=gLongitude%0x1000000/0x10000;
  1251. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1252. gCircle_Buffer_Point++;
  1253. gCircle_Buffer[gCircle_Buffer_Point]=gLongitude%0x10000/0x100;
  1255. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1256. gCircle_Buffer_Point++;
  1257. gCircle_Buffer[gCircle_Buffer_Point]=gLongitude%0x100;
  1258. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1259. gCircle_Buffer_Point++;
  1261. gCircle_Buffer[gCircle_Buffer_Point]=gLatitude/0x1000000;
  1262. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1263. gCircle_Buffer_Point++;
  1264. gCircle_Buffer[gCircle_Buffer_Point]=gLatitude%0x1000000/0x10000;
  1265. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1266. gCircle_Buffer_Point++;
  1267. gCircle_Buffer[gCircle_Buffer_Point]=gLatitude%0x10000/0x100;
  1268. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1269. gCircle_Buffer_Point++;
  1270. gCircle_Buffer[gCircle_Buffer_Point]=gLatitude%0x100;
  1271. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1272. gCircle_Buffer_Point++;
  1274. gCircle_Buffer[gCircle_Buffer_Point]=gSpeed;
  1275. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1276. gCircle_Buffer_Point++;
  1277. gCircle_Buffer[gCircle_Buffer_Point]=gAzimuth;
  1278. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1279. gCircle_Buffer_Point++;
  1281. if(gGeneral_Flag&GPS_VALID_F_1) nFlag|=FLAG_GPSVAILD_1;
  1282. else nFlag&=~FLAG_GPSVAILD_1;
  1284. gCircle_Buffer[gCircle_Buffer_Point]=nFlag;
  1285. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1286. gCircle_Buffer_Point++;
  1288. gCircle_Buffer[gCircle_Buffer_Point]=gYear;
  1289. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1290. gCircle_Buffer_Point++;
  1291. gCircle_Buffer[gCircle_Buffer_Point]=gMonth;
  1292. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1293. gCircle_Buffer_Point++;
  1294. gCircle_Buffer[gCircle_Buffer_Point]=gDate;
  1295. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1296. gCircle_Buffer_Point++;
  1297. gCircle_Buffer[gCircle_Buffer_Point]=gHour;
  1298. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1299. gCircle_Buffer_Point++;
  1300. gCircle_Buffer[gCircle_Buffer_Point]=gMinute;
  1301. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1302. gCircle_Buffer_Point++;
  1303. gCircle_Buffer[gCircle_Buffer_Point]=gSecond;
  1304. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1305. gCircle_Buffer_Point++;
  1307. //增加4个状态量的发送
  1308. gCircle_Buffer[gCircle_Buffer_Point]=0;
  1309. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1310. gCircle_Buffer_Point++;
  1311. gCircle_Buffer[gCircle_Buffer_Point]=gStatus3_Flag;
  1312. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1313. gCircle_Buffer_Point++;
  1314. gCircle_Buffer[gCircle_Buffer_Point]=gStatus2_Flag;
  1315. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1316. gCircle_Buffer_Point++;
  1317. gCircle_Buffer[gCircle_Buffer_Point]=gStatus1_Flag;
  1318. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1319. gCircle_Buffer_Point++;
  1321. //增加long int型的里程数据
  1322. /*
  1323. gCircle_Buffer[gCircle_Buffer_Point]=gALL_Distance/0x1000000;
  1324. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1325. gCircle_Buffer_Point++;
  1326. gCircle_Buffer[gCircle_Buffer_Point]=gALL_Distance%0x1000000/0x10000;
  1327. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1328. gCircle_Buffer_Point++;
  1329. gCircle_Buffer[gCircle_Buffer_Point]=gALL_Distance%0x10000/0x100;
  1330. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1331. gCircle_Buffer_Point++;
  1332. gCircle_Buffer[gCircle_Buffer_Point]=gALL_Distance%0x100;
  1333. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1334. gCircle_Buffer_Point++;
  1335. */
  1336. //==================================================
  1337. gCircle_Buffer[gCircle_Buffer_Point]=iCheckOut/0x100;
  1338. gCircle_Buffer_Point++;
  1339. gCircle_Buffer[gCircle_Buffer_Point]=iCheckOut%0x100;
  1340. gCircle_Buffer_Point++;
  1341. gCircle_Buffer[gCircle_Buffer_Point]=EOT;
  1342. gCircle_Buffer_Point++;
  1343. //gCircle_Buffer_Point的值是数据区的长度
  1344. }
  1346. /********************************************************
  1347. * 函数名：Circle_Data_GSM
  1348. 作用域：本地文件调用
  1349. * 功能：  在GSM的工作方式下，如果是报警，或者行车轨迹，或者监控数据，
  1350. 组织到gCircle_Buffer[]缓冲中
  1351. * 参数：
  1353. * 返回值：
  1355. * 创建人：
  1356. *
  1357. * 修改历史：（每条详述）
  1358. AT+CMGS=045
  1359. > 001100|0D 91683196818735F4 000400 1D FF43BC19010101001018739A9A04D63C2200008003093010164306460D
  1361. ********************************************************/
  1362. unsigned int Circle_Data_GSM( unsigned char nCount,unsigned char nCommand,unsigned char nACK,unsigned int iCheckOutTemp )
  1363. {
  1364. unsigned char nInput;
  1365. unsigned int  iCheckOut;
  1366. unsigned int  i;
  1367. iCheckOut=iCheckOutTemp;
  1368. nInput=12+4+17*2;
  1369. if(nCount==1)
  1370. {
  1371. gCircle_Buffer_Point=0;
  1372. gCircle_Buffer[gCircle_Buffer_Point]=SOH;
  1373. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1374. gCircle_Buffer_Point++;
  1375. gCircle_Buffer[gCircle_Buffer_Point]=nCommand;
  1376. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1377. gCircle_Buffer_Point++;
  1378. gCircle_Buffer[gCircle_Buffer_Point]=(char)(~nCommand);
  1379. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1380. gCircle_Buffer_Point++;
  1381. gCircle_Buffer[gCircle_Buffer_Point]=nInput-4;
  1382. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1383. gCircle_Buffer_Point++;
  1384. gCircle_Buffer[gCircle_Buffer_Point]=nACK;
  1385. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1386. gCircle_Buffer_Point++;
  1387. gCircle_Buffer[gCircle_Buffer_Point]=gKind;
  1388. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1389. gCircle_Buffer_Point++;
  1390. gCircle_Buffer[gCircle_Buffer_Point]=gGroup;
  1391. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1392. gCircle_Buffer_Point++;
  1393. gCircle_Buffer[gCircle_Buffer_Point]=gVID/0x100;
  1394. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1395. gCircle_Buffer_Point++;
  1396. gCircle_Buffer[gCircle_Buffer_Point]=gVID%0x100;
  1397. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1398. gCircle_Buffer_Point++;
  1399. i=Circle_Data_GSM_Sub(iCheckOut);
  1400. return(i);
  1401. }
  1402. else if(nCount==2)
  1403. {
  1404. i=Circle_Data_GSM_Sub(iCheckOut);
  1405. return(i);
  1406. }
  1407. /*
  1408. else if(nCount==3)
  1409. {
  1410. i=Circle_Data_GSM_Sub(iCheckOut);
  1411. return(i);
  1412. }
  1413. else if(nCount==4)
  1414. {
  1415. i=Circle_Data_GSM_Sub(iCheckOut);
  1416. return(i);
  1417. }
  1418. */
  1419. else if(nCount==3)
  1420. {
  1421. i=Circle_Data_GSM_Sub(iCheckOut);
  1422. return(i);
  1423. }
  1424. else if(nCount==4)
  1425. {
  1426. /////////////////////////////////////////////////
  1427. i=Circle_Data_GSM_Sub(iCheckOut);
  1428. //增加4个车载终端的状态量
  1429. gCircle_Buffer[gCircle_Buffer_Point]=0;
  1430. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1431. gCircle_Buffer_Point++;
  1432. gCircle_Buffer[gCircle_Buffer_Point]=gStatus3_Flag;
  1433. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1434. gCircle_Buffer_Point++;
  1435. gCircle_Buffer[gCircle_Buffer_Point]=gStatus2_Flag;
  1436. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1437. gCircle_Buffer_Point++;
  1438. gCircle_Buffer[gCircle_Buffer_Point]=gStatus1_Flag;
  1439. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1440. gCircle_Buffer_Point++;
  1441. //增加long int型的里程数据
  1442. /*
  1443. gCircle_Buffer[gCircle_Buffer_Point]=gALL_Distance/0x1000000;
  1444. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1445. gCircle_Buffer_Point++;
  1446. gCircle_Buffer[gCircle_Buffer_Point]=gALL_Distance%0x1000000/0x10000;
  1447. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1448. gCircle_Buffer_Point++;
  1449. gCircle_Buffer[gCircle_Buffer_Point]=gALL_Distance%0x10000/0x100;
  1450. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1451. gCircle_Buffer_Point++;
  1452. gCircle_Buffer[gCircle_Buffer_Point]=gALL_Distance%0x100;
  1453. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1454. gCircle_Buffer_Point++;
  1455. */
  1456. //////////////////////////////////////////////
  1457. gCircle_Buffer[gCircle_Buffer_Point]=i/0x100;
  1458. gCircle_Buffer_Point++;
  1459. gCircle_Buffer[gCircle_Buffer_Point]=i%0x100;
  1460. gCircle_Buffer_Point++;
  1461. gCircle_Buffer[gCircle_Buffer_Point]=EOT;
  1462. gCircle_Buffer_Point++;
  1463. return(0);
  1464. }
  1465. else
  1466. {
  1467.   return(0);
  1468. }
  1469. }
  1470. /********************************************************
  1471. * 函数名：Circle_Data_GSM_Sub
  1472. 作用域：本地文件调用
  1473. * 功能：  在GSM的工作方式下，如果是报警，或者行车轨迹，或者监控数据，
  1474. 组织到gCircle_Buffer[]缓冲中
  1475. * 参数：
  1476. * 返回值：
  1477. * 创建人：
  1478. * 修改历史：（每条详述）
  1479. ********************************************************/
  1481. unsigned int Circle_Data_GSM_Sub(unsigned int iCheckOutTemp)
  1482. {
  1483. unsigned int iCheckOut;
  1484. unsigned char nFlag;
  1485. nFlag=gAlarm_Type;
  1486. iCheckOut=iCheckOutTemp;
  1487. gCircle_Buffer[gCircle_Buffer_Point]=gLongitude/0x1000000;
  1488. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1489. gCircle_Buffer_Point++;
  1490. gCircle_Buffer[gCircle_Buffer_Point]=gLongitude%0x1000000/0x10000;
  1491. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1492. gCircle_Buffer_Point++;
  1493. gCircle_Buffer[gCircle_Buffer_Point]=gLongitude%0x10000/0x100;
  1495. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1496. gCircle_Buffer_Point++;
  1497. gCircle_Buffer[gCircle_Buffer_Point]=gLongitude%0x100;
  1498. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1499. gCircle_Buffer_Point++;
  1501. gCircle_Buffer[gCircle_Buffer_Point]=gLatitude/0x1000000;
  1502. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1503. gCircle_Buffer_Point++;
  1504. gCircle_Buffer[gCircle_Buffer_Point]=gLatitude%0x1000000/0x10000;
  1505. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1506. gCircle_Buffer_Point++;
  1507. gCircle_Buffer[gCircle_Buffer_Point]=gLatitude%0x10000/0x100;
  1508. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1509. gCircle_Buffer_Point++;
  1510. gCircle_Buffer[gCircle_Buffer_Point]=gLatitude%0x100;
  1511. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1512. gCircle_Buffer_Point++;
  1514. gCircle_Buffer[gCircle_Buffer_Point]=gSpeed;
  1515. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1516. gCircle_Buffer_Point++;
  1517. gCircle_Buffer[gCircle_Buffer_Point]=gAzimuth;
  1518. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1519. gCircle_Buffer_Point++;
  1521. if(gGeneral_Flag&GPS_VALID_F_1) nFlag|=FLAG_GPSVAILD_1;
  1522. else nFlag&=~FLAG_GPSVAILD_1;
  1524. gCircle_Buffer[gCircle_Buffer_Point]=nFlag;
  1525. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1526. gCircle_Buffer_Point++;
  1527. gCircle_Buffer[gCircle_Buffer_Point]=gYear;
  1528. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1529. gCircle_Buffer_Point++;
  1530. gCircle_Buffer[gCircle_Buffer_Point]=gMonth;
  1531. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1532. gCircle_Buffer_Point++;
  1533. gCircle_Buffer[gCircle_Buffer_Point]=gDate;
  1534. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1535. gCircle_Buffer_Point++;
  1536. gCircle_Buffer[gCircle_Buffer_Point]=gHour;
  1537. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1538. gCircle_Buffer_Point++;
  1539. gCircle_Buffer[gCircle_Buffer_Point]=gMinute;
  1540. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1541. gCircle_Buffer_Point++;
  1542. gCircle_Buffer[gCircle_Buffer_Point]=gSecond;
  1543. iCheckOut += gCircle_Buffer[gCircle_Buffer_Point];
  1544. gCircle_Buffer_Point++;
  1545. return(iCheckOut);
  1546. }
  1548. /********************************************************
  1549. * 函数名：Dichotomy_PassData_First
  1550. 作用域：本地文件调用
  1551. * 功能：  二分法寻找历史轨迹的第一个满足条件的扇区
  1552. * 参数：
  1553. * 返回值：
  1554. * 创建人：
  1555. *
  1556. * 修改历史：（每条详述）
  1557. ********************************************************/
  1558. unsigned int Dichotomy_PassData_First(unsigned int iFirst_Page,unsigned int iEnd_Page)
  1559. {
  1560. unsigned int iMiddle_Page;
  1561. iMiddle_Page=(iFirst_Page+iEnd_Page)/2;
  1562. return(iMiddle_Page);
  1563. }
  1565. /********************************************************
  1566. * 函数名：GSM_WORK_Data
  1567. 作用域：
  1568. * 功能：
  1569. * 参数：
  1570. * 返回值：
  1571. * 创建人：
  1572. *
  1573. * 修改历史：（每条详述）
  1574. ********************************************************/
  1575. void GSM_WORK_Data(void)
  1576. {
  1577. if(gCircle_Timer>0)
  1578. {
  1579. if( (gGeneral_Flag&GPS_VALID_F_1)&&( (gInternal_Flag&LOAD_ONEVALID_F_1)==0) )
  1580. {
  1581. gInternal_Flag|=LOAD_ONEVALID_F_1;
  1582. //在0--gCycle_GSM内判断到一个有效的数据
  1583. gGSM_Work_Count++;
  1584. gCheck_Data += Circle_Data_GSM(gGSM_Work_Count,VEHICLE_RUNDATA_UP,0,gCheck_Data);
  1585. if(gGSM_Work_Count>=4)
  1586. {
  1587. gInternal_Flag|=SEND_CIRCLE_F_1;gGSM_Work_Count=0;gCheck_Data=0;
  1588. Judge_SMS_Way();
  1589. }
  1590. }
  1591. else if( gCircle_Timer>gCycle_GSM )
  1592. {
  1593. if( gInternal_Flag&LOAD_ONEVALID_F_1 )
  1594. {
  1595. gCircle_Timer=0;
  1596. gInternal_Flag&=~LOAD_ONEVALID_F_1;
  1597. }
  1598. else
  1599. {
  1600. gCircle_Timer=0;
  1601. gInternal_Flag&=~LOAD_ONEVALID_F_1;
  1602. //在0--gCycle_GSM内仍然未判断到一个有效的数据，则将这个作为一个点存储
  1603. gGSM_Work_Count++;
  1604. gCheck_Data += Circle_Data_GSM(gGSM_Work_Count,VEHICLE_RUNDATA_UP,0,gCheck_Data);
  1605. if(gGSM_Work_Count>=4)
  1606. {
  1607. gInternal_Flag|=SEND_CIRCLE_F_1;gGSM_Work_Count=0;gCheck_Data=0;
  1608. Judge_SMS_Way();
  1609. }
  1610. }
  1611. }
  1612. }
  1613. }
  1614. /********************************************************
  1615. * 函数名：TCP_WORK_Data
  1616. 作用域：
  1617. * 功能：
  1618. * 参数：
  1619. * 返回值：
  1620. * 创建人：
  1621. *
  1622. * 修改历史：（每条详述）
  1623. ********************************************************/
  1625. void TCP_WORK_Data(unsigned int Timer,unsigned char nCommand)
  1626. {
  1627. if(gCircle_Timer>0)
  1628. {
  1629. if( (gGeneral_Flag&GPS_VALID_F_1)&&( (gInternal_Flag&LOAD_ONEVALID_F_1)==0) )
  1630. {
  1631. gInternal_Flag|=LOAD_ONEVALID_F_1;
  1632. //在0--gCycle_TCP内判断到一个有效的数据
  1633. Circle_Data_TCP(nCommand,0);
  1634. gInternal_Flag|=SEND_CIRCLE_F_1;
  1635. Judge_SMS_Way();
  1636. }
  1637. else if( gCircle_Timer>Timer )
  1638. {
  1639. if( gInternal_Flag&LOAD_ONEVALID_F_1 )
  1640. {
  1641. gCircle_Timer=0;
  1642. gInternal_Flag&=~LOAD_ONEVALID_F_1;
  1643. }
  1644. else
  1645. {
  1646. gCircle_Timer=0;
  1647. gInternal_Flag&=~LOAD_ONEVALID_F_1;
  1648. //在0--gCycle_TCP内仍然未判断到一个有效的数据，则将这个作为一个点存储
  1649. Circle_Data_TCP(nCommand,0);
  1650. gInternal_Flag|=SEND_CIRCLE_F_1;
  1651. Judge_SMS_Way();
  1652. }
  1653. }
  1654. }
  1655. }
  1657. /********************************************************
  1658. * 函数名：Max_Result()
  1659. 作用域：
  1660. * 功能：
  1661. * 参数：
  1662. * 返回值：
  1663. * 创建人：
  1664. *
  1665. * 修改历史：（每条详述）
  1666. ********************************************************/
  1667. unsigned long int Max_Result(unsigned long int x,unsigned long int y)
  1668. {
  1669. if(x>y) return(x);
  1670. else return(y);
  1671. }
  1672. /********************************************************
  1673. * 函数名：Min_Result()
  1674. 作用域：
  1675. * 功能：
  1676. * 参数：
  1677. * 返回值：
  1678. * 创建人：
  1679. *
  1680. * 修改历史：（每条详述）
  1681. ********************************************************/
  1682. unsigned long int Min_Result(unsigned long int x,unsigned long int y)
  1683. {
  1684. if(x<y) return(x);
  1685. else return(y);
  1686. }
  1688. /********************************************************
  1689. * 函数名：Account_Mid_Dot()
  1690. 作用域：
  1691. * 功能：
  1692. * 参数：
  1693. * 返回值：
  1694. * 创建人：
  1695. *
  1696. ********************************************************/
  1697. unsigned char Account_Mid_Dot(double x1,double y1,double x2,double y2)
  1698. {
  1699. unsigned char Line_Flag=0;
  1700. double k,b,k1,b1;
  1701. double ak;
  1702. double Max_gLongitude=0,Max_gLatitude=0;
  1703. double Min_gLongitude=0,Min_gLatitude=0;
  1704. double Longitude_Temp=0,Latitude_Temp=0;
  1705. unsigned long int nLength=0;
  1707. //先判断当前点与判断的线段的第一个点的距离,如果此点的距离就不满足偏离条件，则返回5
  1708. //1,计算两点经度差值所表示的实际距离
  1709. nLength=labs(gLatitude-(long int)(y1*3600000) );
  1710. Latitude_Temp=(double)((nLength/1000.0)*DIS_LAT);
  1711. //2,计算两点纬度差值所表示的实际距离
  1712. nLength=labs(gLongitude-(long int)(x1*3600000) );
  1713. Longitude_Temp=(double)((nLength/1000.0)*DIS_LON);
  1715. if( (Longitude_Temp<gMax_Limit_Distance)&&(Latitude_Temp<gMax_Limit_Distance) )
  1716. {
  1717. Latitude_Temp=Latitude_Temp*Latitude_Temp+Longitude_Temp*Longitude_Temp;
  1718. Latitude_Temp=sqrt(Latitude_Temp);
  1719. if(Latitude_Temp<gMax_Limit_Distance) return(5);
  1720. }
  1721. /////////////////////////////////////////////////////////////////////
  1723. Longitude_Temp=(double)(gLongitude/3600000.0);
  1724. Latitude_Temp=(double)(gLatitude/3600000.0);
  1726. if(x1>=x2)
  1727. {
  1728. Max_gLongitude=x1;Min_gLongitude=x2;
  1729. }
  1730. else
  1731. {
  1732. Max_gLongitude=x2;Min_gLongitude=x1;
  1733. }
  1734. if(y1>=y2)
  1735. {
  1736. Max_gLatitude=y1;Min_gLatitude=y2;
  1737. }
  1738. else
  1739. {
  1740. Max_gLatitude=y2;Min_gLatitude=y1;
  1741. }
  1743. if(   ((Max_gLongitude-Min_gLongitude)<0.0003)
  1744. &&((Max_gLatitude-Min_gLatitude)>0.0003)  )
  1745. {
  1746. Line_Flag=1;
  1747. }
  1748. else if(   ((Max_gLongitude-Min_gLongitude)>0.0003)
  1749.  &&((Max_gLatitude-Min_gLatitude)<0.0003)  )
  1750. {
  1751. Line_Flag=2;
  1752. }
  1753. else if(   ((Max_gLongitude-Min_gLongitude)>0.0003)
  1754.  &&((Max_gLatitude-Min_gLatitude)>0.0003)  )
  1755. {
  1756. k=(y2-y1)/(x2-x1);
  1757. ak=fabs(k);
  1758. if(ak>1000) Line_Flag=1; //相当于垂直，相当于x相同
  1759. else if(ak<0.001) Line_Flag=2; //相当于平行，相当于y相同
  1760. else Line_Flag=0; //可以有计算的斜率
  1761. }
  1762. else //两个点重合
  1763. {
  1764. return(0);
  1765. }
  1766. /*
  1767. k=(y2-y1)/(x2-x1);
  1768. ak=fabs(k);
  1769. if(ak>100) Line_Flag=1; //相当于垂直，相当于x相同
  1770. else if(ak<0.01) Line_Flag=2; //相当于平行，相当于y相同
  1771. else Line_Flag=0; //可以有计算的斜率
  1772. */
  1773. //1，如果两个点的纬度数据相同，则判断经度，y相同，判断x
  1774. if(Line_Flag==2) //gLatitude
  1775. {
  1776. if(Longitude_Temp>Max_gLongitude) return(1);
  1777. else if(Longitude_Temp<Min_gLongitude) return(1);
  1778. else
  1779. {
  1780. gLongitude_mid=gLongitude;
  1781. gLatitude_mid=(long int)(3600000*(y1+y2)/2);
  1782. return(2);
  1783. }
  1784. }
  1785. //2，如果两个点的经度数据相同，则判断纬度，x相同，判断y
  1786. else if(Line_Flag==1) //gLongitude
  1787. {
  1788. if(Latitude_Temp>Max_gLatitude) return(1);
  1789. else if(Latitude_Temp<Min_gLatitude) return(1);
  1790. else
  1791. {
  1792. gLongitude_mid=(long int)(3600000*(x1+x2)/2); //经度,相当于y
  1793. gLatitude_mid=gLatitude; //纬度,相当于x
  1794. return(3);
  1795. }
  1796. }
  1797. //3,如果可以计算斜率
  1798. else if(Line_Flag==0)
  1799. {
  1800. b=y1-k*x1;
  1801. k1=-1/k;
  1802. b1=(double)(gLatitude/3600000.0)-k1*(double)(gLongitude/3600000.0);//b1=
  1804. Longitude_Temp=(b1-b)/(k-k1);
  1805. Latitude_Temp= k1*Longitude_Temp+b1;
  1807. gLongitude_mid=(long int)(Longitude_Temp*3600000);
  1808. gLatitude_mid=(long int)(Latitude_Temp*3600000);
  1810. if(gLongitude_mid>(long int)(Max_gLongitude*3600000)) return(1);
  1811. else if(gLongitude_mid<(long int)(Min_gLongitude*3600000)) return(1);
  1812. else if(gLatitude_mid>(long int)(Max_gLatitude*3600000)) return(1);
  1813. else if(gLatitude_mid<(long int)(Min_gLatitude*3600000)) return(1);
  1814. else
  1815. {
  1816. return(4);
  1817. }
  1818. }
  1819. return(0);
  1820. //返回0，则属于异常
  1821. //返回1，表示垂线的交点不在当前线段内，则此线段的判断结束，进行下一个线段的判断
  1822. //返回2，垂线的交点在当前线段内，但两个点的经度相同，纬度不同
  1823. //返回3，垂线的交点在当前线段内，但两个点的纬度相同，经度不同
  1824. //返回4，垂线的交点在单前线段内，并且两个点的经度，纬度君不相同
  1825. //返回5，说明当前点离线段的第一个点的距离已经不满足偏离距离的条件
  1826. }
  1827. /********************************************************
  1828. * 函数名：Check_Sram_AreaData()
  1829. 作用域：
  1830. * 功能：
  1831. * 参数：
  1832. * 返回值：
  1833. * 创建人：
  1834. *
  1835. * 修改历史：（每条详述）
  1837. ********************************************************/
  1838. /*
  1839. unsigned char Check_Sram_AreaData(void)
  1840. {
  1841. unsigned int i=0;
  1842. SRAM_Init();
  1843. if( (SRAM_Read(SAREA_DATA_FS)==0x55)&&(SRAM_Read(SAREA_DATA_FE)==0xAA) )
  1844. {
  1845. return(1);
  1846. }
  1847. else
  1848. {
  1849. return(0);
  1850. }
  1851. }
  1852. */
  1853. /********************************************************
  1854. * 函数名：Check_Area_Alarm()
  1855. 作用域：
  1856. * 功能：
  1857. * 参数：
  1858. * 返回值：
  1859. * 创建人：
  1860. *
  1861. * 修改历史：（每条详述）
  1863. ********************************************************/
  1864. unsigned char Check_Area_Alarm(unsigned char Num)
  1865. {
  1866. unsigned long int gLongitude_1=0,gLatitude_1=0;
  1867. unsigned long int gLongitude_2=0,gLatitude_2=0;
  1868. unsigned long int Max_gLongitude=0,Max_gLatitude=0;
  1869. unsigned long int Min_gLongitude=0,Min_gLatitude=0;
  1871. unsigned char Area_Flag=0;
  1872. unsigned int Area_Add=0;
  1873. unsigned int Aflag_Add=0;
  1875. Area_Add=SAREA1_LON_1_2+(Num-1)*17; //区域的首地址
  1876. Aflag_Add=Area_Add+16; //区域标志的地址
  1878. //先判断对应的Num区域是禁出还是禁入
  1879. SRAM_Init();
  1880. Area_Flag=SRAM_Read(Aflag_Add);
  1881. if( (Area_Flag!=0xaa)&&(Area_Flag!=0x55) ) return(0);
  1882. //2，第一个点的经，纬度
  1883. gLongitude_1 = SRAM_Read(Area_Add);
  1884. gLongitude_1<<=8;
  1885. gLongitude_1 += SRAM_Read(Area_Add+1);
  1886. gLongitude_1<<=8;
  1887. gLongitude_1 += SRAM_Read(Area_Add+2);
  1888. gLongitude_1<<=8;
  1889. gLongitude_1 += SRAM_Read(Area_Add+3);
  1891. gLatitude_1 = SRAM_Read(Area_Add+4);
  1892. gLatitude_1<<=8;
  1893. gLatitude_1 += SRAM_Read(Area_Add+5);
  1894. gLatitude_1<<=8;
  1895. gLatitude_1 += SRAM_Read(Area_Add+6);
  1896. gLatitude_1<<=8;
  1897. gLatitude_1 += SRAM_Read(Area_Add+7);
  1898. //3，第二个点的经，纬度
  1899. gLongitude_2 = SRAM_Read(Area_Add+8);
  1900. gLongitude_2<<=8;
  1901. gLongitude_2 += SRAM_Read(Area_Add+9);
  1902. gLongitude_2<<=8;
  1903. gLongitude_2 += SRAM_Read(Area_Add+10);
  1904. gLongitude_2<<=8;
  1905. gLongitude_2 += SRAM_Read(Area_Add+11);
  1907. gLatitude_2 = SRAM_Read(Area_Add+12);
  1908. gLatitude_2<<=8;
  1909. gLatitude_2 += SRAM_Read(Area_Add+13);
  1910. gLatitude_2<<=8;
  1911. gLatitude_2 += SRAM_Read(Area_Add+14);
  1912. gLatitude_2<<=8;
  1913. gLatitude_2 += SRAM_Read(Area_Add+15);
  1915. Max_gLongitude=Max_Result(gLongitude_1,gLongitude_2);
  1916. Max_gLatitude=Max_Result(gLatitude_1,gLatitude_2);
  1917. Min_gLongitude=Min_Result(gLongitude_1,gLongitude_2);
  1918. Min_gLatitude=Min_Result(gLatitude_1,gLatitude_2);
  1920. //判断对应点在这个区域范围内
  1921. if(   (gLongitude>Min_gLongitude)&&(gLongitude<Max_gLongitude)
  1922. &&(gLatitude>Min_gLatitude)&&(gLatitude<Max_gLatitude) )
  1923. {
  1924. //当前点在此区域范围内
  1925. //1,如果此区域属于禁入标志
  1926. if(Area_Flag==0xaa) return(1); //可以产生报警
  1927. //2,如果此区域属于禁出标志，
  1928. else if(Area_Flag==0x55) return(2); //
  1929. }
  1930. //判断这个点对应不在这个区域内
  1931. else
  1932. {
  1933. //当前点不在这个区域范围内
  1934. //1,如果此区域属于禁入标志，
  1935. if(Area_Flag==0xaa) return(3); //此区域PASS
  1936. //2,如果此区域属于禁出标志，则返回2
  1937. else if(Area_Flag==0x55) return(4); //此区域计数
  1938. }
  1939. return(0);
  1940. }
  1941. /********************************************************
  1942. * 函数名：Account_Distance()
  1943. 作用域：
  1944. * 功能：
  1945. * 参数：
  1946. * 返回值：
  1947. * 创建人：
  1948. *
  1949. * 修改历史：（每条详述）
  1950. 统计计算告诉了两个精度，两个纬度，计算出，中间点的精度，纬度值
  1951. ********************************************************/
  1953. /********************************************************
  1954. * 函数名：Send_Over_Speed_to_Disp
  1955. 作用域：
  1956. * 功能：  定期送给显示终端超速报警信息
  1957. * 参数：
  1958. * 返回值：
  1959. * 创建人：
  1960. *
  1961. * 修改历史：（每条详述）
  1962. ********************************************************/
  1963. void Send_Over_Alarm_to_Disp(unsigned char Alarm_Style)
  1964. {
  1965. if(gDisp_Buffer_Point+8+2<=sizeof(gDisp_Buffer))
  1966. {
  1967. gDisp_Buffer[gDisp_Buffer_Point]=8+2;
  1968. gDisp_Buffer_Point++;
  1969. gDisp_Buffer[gDisp_Buffer_Point]=0;
  1970. gDisp_Buffer_Point++;
  1971. gDisp_Buffer[gDisp_Buffer_Point]='@';
  1972. gDisp_Buffer_Point++;
  1973. gDisp_Buffer[gDisp_Buffer_Point]='%';
  1974. gDisp_Buffer_Point++;
  1975. gDisp_Buffer[gDisp_Buffer_Point]=8;
  1976. gDisp_Buffer_Point++;
  1977. gDisp_Buffer[gDisp_Buffer_Point]=DISP_MAIN_ARALM_DOWN;
  1978. gDisp_Buffer_Point++;
  1979. gDisp_Buffer[gDisp_Buffer_Point]=Alarm_Style;
  1980. gDisp_Buffer_Point++;
  1981. gDisp_Buffer[gDisp_Buffer_Point]=0;
  1982. gDisp_Buffer_Point++;
  1983. gDisp_Buffer[gDisp_Buffer_Point]='$';
  1984. gDisp_Buffer_Point++;
  1985. gDisp_Buffer[gDisp_Buffer_Point]='&';
  1986. gDisp_Buffer_Point++;
  1987. }
  1988. }
  1989. /********************************************************
  1990. * 函数名：Check_Line_Data
  1991. 作用域：
  1992. * 功能：  定期送给显示终端超速报警信息
  1993. * 参数：
  1994. * 返回值：
  1995. * 创建人：
  1996. *
  1997. * 修改历史：（每条详述）
  1998. S_Num_ID的值的范围为1----61
  1999. ********************************************************/
  2000. unsigned char  Check_Line_Data(unsigned char S_Num_ID)
  2001. {
  2002. unsigned long int gLatitude_1,gLatitude_2;
  2003. unsigned long int gLongitude_1,gLongitude_2;
  2004. unsigned long int nLength=0;
  2005. unsigned char nR_Value=0;
  2006. double gLat_1,gLon_1,gLat_2,gLon_2;
  2007. unsigned int SLine_Address;
  2008. double  Distance_LAT=0,Distance_LON=0;
  2010. //先根据ID号计算相邻的两个点的第一个点的在SRAM中的位置
  2011. SLine_Address=SLINE_DATA_1+8*S_Num_ID;
  2012. //依次读取数据
  2013. SRAM_Init();
  2014. //第一个点的经，纬度
  2015. gLongitude_1 = SRAM_Read(SLine_Address);
  2016. gLongitude_1<<=8;
  2017. gLongitude_1 += SRAM_Read(SLine_Address+1);
  2018. gLongitude_1<<=8;
  2019. gLongitude_1 += SRAM_Read(SLine_Address+2);
  2020. gLongitude_1<<=8;
  2021. gLongitude_1 += SRAM_Read(SLine_Address+3);
  2023. gLatitude_1 = SRAM_Read(SLine_Address+4);
  2024. gLatitude_1<<=8;
  2025. gLatitude_1 += SRAM_Read(SLine_Address+5);
  2026. gLatitude_1<<=8;
  2027. gLatitude_1 += SRAM_Read(SLine_Address+6);
  2028. gLatitude_1<<=8;
  2029. gLatitude_1 += SRAM_Read(SLine_Address+7);
  2030. //第二个点的经度，纬度
  2031. gLongitude_2 = SRAM_Read(SLine_Address+8);
  2032. gLongitude_2<<=8;
  2033. gLongitude_2 += SRAM_Read(SLine_Address+9);
  2034. gLongitude_2<<=8;
  2035. gLongitude_2 += SRAM_Read(SLine_Address+10);
  2036. gLongitude_2<<=8;
  2037. gLongitude_2 += SRAM_Read(SLine_Address+11);
  2039. gLatitude_2 = SRAM_Read(SLine_Address+12);
  2040. gLatitude_2<<=8;
  2041. gLatitude_2 += SRAM_Read(SLine_Address+13);
  2042. gLatitude_2<<=8;
  2043. gLatitude_2 += SRAM_Read(SLine_Address+14);
  2044. gLatitude_2<<=8;
  2045. gLatitude_2 += SRAM_Read(SLine_Address+15);
  2046. //==============
  2047. //==============
  2049. //开始计算两个点的相关数据
  2050. gLat_1=(double)(gLatitude_1/3600000.0);
  2051. gLon_1=(double)(gLongitude_1/3600000.0);
  2052. gLat_2=(double)(gLatitude_2/3600000.0);
  2053. gLon_2=(double)(gLongitude_2/3600000.0);
  2055. nR_Value=Account_Mid_Dot(gLon_1,gLat_1,gLon_2,gLat_2);
  2056. //1,异常
  2057. if(nR_Value==0) return(0);
  2058. //2,垂直点落在线段外
  2059. else if(nR_Value==1) return(1);
  2060. //3,当前离第一个判断点的距离就不满足偏离条件
  2061. else if(nR_Value==5) return(3);
  2062. //4,有需要进行计算距离的，计算的垂直的交点在当前线段内
  2063. else
  2064. {
  2065. //1,计算两点经度差值所表示的实际距离
  2066. nLength=labs(gLatitude_mid-gLatitude);
  2067. Distance_LAT=(double)((nLength/1000.0)*DIS_LAT);
  2068. //2,计算两点纬度差值所表示的实际距离
  2069. nLength=labs(gLongitude_mid-gLongitude);
  2070. Distance_LON=(double)((nLength/1000.0)*DIS_LON);
  2072. //A：需要计算两个点经度相同
  2073. if(nR_Value==2)
  2074. {
  2075. if(Distance_LAT>gMax_Limit_Distance) return(2);
  2076. else return(3);
  2077. }
  2078. //B：需要计算两个点纬度相同
  2079. else if(nR_Value==3)
  2080. {
  2081. if(Distance_LON>gMax_Limit_Distance) return(2);
  2082. else return(3);
  2083. }
  2084. //C：需要计算两个点的经度，纬度均不相同
  2085. else if(nR_Value==4)
  2086. {
  2087. if( (Distance_LAT>gMax_Limit_Distance)||(Distance_LON>gMax_Limit_Distance) )
  2088. {
  2089. return(2);
  2090. }
  2091. else
  2092. {
  2093. Distance_LAT=Distance_LAT*Distance_LAT+Distance_LON*Distance_LON;
  2094. Distance_LAT=sqrt(Distance_LAT);
  2095. if(Distance_LAT>gMax_Limit_Distance) return(2);
  2096. else
  2097. {
  2098. return(3);
  2099. }
  2100. //计算两点的距离
  2101. }
  2102. }
  2103. return(0);
  2104. }
  2105. }