diff --git a/custom/control_out/inc/control_out.h b/custom/control_out/inc/control_out.h
index 062ef6e..0b34f3c 100644
--- a/custom/control_out/inc/control_out.h
+++ b/custom/control_out/inc/control_out.h
@@ -2,6 +2,8 @@
 #define __CONTROL_OUT_H__
 #include "cm_os.h"
 #include "cm_gpio.h"
+#include "jt808_set_TermParam.h"
+
 
 #define BAT_SxP1            4 // 电池四串一并 
 #define BAT_VOLT(_Volt)     (_Volt * BAT_SxP1) //电压单位转换
@@ -56,7 +58,7 @@ typedef struct BAT_Message{
     uint16_t Deep_ACC_Time; // 深踩油门时间
 } BAT_Message_t;
 
-#if 0
+#if 1
 #define ACC_RES_UP 10000
 #define ACC_RES_DOWN 3300
 
@@ -87,27 +89,35 @@ typedef enum{
     IO_TX_BRAKE = CM_GPIO_NUM_4, // 刹车
 }control_io_t;
 
-typedef struct{
-    union{
-        uint16_t VERSION;           // 软件版本号
-        struct{
-            uint16_t SW_version:11;         // 软件版本序号
-            uint16_t HW_version:4;          // 硬件版本序号
-            uint16_t VER_type:1;        // 当前固件类型0：0x04000；1：0x20000
-        };
-    };
-    uint8_t  Modbus_addr;       // MODBUS地址
-    uint8_t  Manager_sLim;      // 管理员模式油门极限(Unit:%)
-    uint8_t  Tourist_sLim;      // 游客模式油门极限
-    uint8_t  Speed_Cut_sLim;    // 减速油门极限(Unit:%)(自动减速时油门极限)
-    uint16_t Brake_DLimit;      // 刹车距离极限(前进)(Unit:mm)
-    uint16_t Speed_Cut_DLimit;  // 减速距离极限
-    uint16_t Brake_DLimit_B;    // 刹车距离极限(后退)
-    uint16_t Speed_Cut_DLimit_B;// 减速距离极限
-    uint16_t CRC16;             // 配置信息CRC16校验码
-}SYS_CONF_t;
+// typedef struct{
+//     union{
+//         uint16_t VERSION;           // 软件版本号
+//         struct{
+//             uint16_t SW_version:11;         // 软件版本序号
+//             uint16_t HW_version:4;          // 硬件版本序号
+//             uint16_t VER_type:1;        // 当前固件类型0：0x04000；1：0x20000
+//         };
+//     };
+//     uint8_t  Modbus_addr;       // MODBUS地址
+//     uint8_t  Manager_sLim;      // 管理员模式油门极限(Unit:%)
+//     uint8_t  Tourist_sLim;      // 游客模式油门极限
+//     uint8_t  Speed_Cut_sLim;    // 减速油门极限(Unit:%)(自动减速时油门极限)
+//     uint16_t Brake_DLimit;      // 刹车距离极限(前进)(Unit:mm)
+//     uint16_t Speed_Cut_DLimit;  // 减速距离极限
+//     uint16_t Brake_DLimit_B;    // 刹车距离极限(后退)
+//     uint16_t Speed_Cut_DLimit_B;// 减速距离极限
+//     uint16_t CRC16;             // 配置信息CRC16校验码
+// }SYS_CONF_t;
 
-extern SYS_CONF_t sys_conf;
+// extern SYS_CONF_t sys_conf;
+
+#define SYS_CONF_MANAGER_ACC       jt808_term_param_item.set_term_param.ManagerACC // 管理员模式油门极限(Unit:%)
+#define SYS_CONF_TOURIST_ACC       jt808_term_param_item.set_term_param.TouristACC // 游客模式油门极限
+#define SYS_CONF_SPEED_CUT_ACC     jt808_term_param_item.set_term_param.SpeedCutACC // 减速油门极限(Unit:%)(自动减速时油门极限)
+#define SYS_CONF_BRAKE_LIMIT        jt808_term_param_item.set_term_param.BrakeLimit // 刹车距离极限(前进)(Unit:mm)
+#define SYS_CONF_SPEED_CUT_LIMIT   jt808_term_param_item.set_term_param.SpeedCutLimit // 减速距离极限
+#define SYS_CONF_BRAKE_LIMIT_B     jt808_term_param_item.set_term_param.BrakeLimit_B // 刹车距离极限(后退)
+#define SYS_CONF_SPEED_CUT_LIMIT_B jt808_term_param_item.set_term_param.SpeedCutLimit_B // 减速距离极限
 
 typedef struct{
     union{// 输入输出状态
diff --git a/custom/control_out/src/control_out.c b/custom/control_out/src/control_out.c
index e88c5c9..8f65cd0 100644
--- a/custom/control_out/src/control_out.c
+++ b/custom/control_out/src/control_out.c
@@ -23,18 +23,18 @@
 
 osThreadId_t control_out_TaskHandle = NULL;
 
-SYS_CONF_t sys_conf ={
-    .SW_version = 1,
-    .HW_version = 1,
-    .VER_type = 1,
-    .Manager_sLim =100,
-    .Tourist_sLim =50,
-    .Speed_Cut_sLim =20,
-    .Brake_DLimit =1200,
-    .Speed_Cut_DLimit =2000,
-    .Brake_DLimit_B =1200,
-    .Speed_Cut_DLimit_B =2000,
-};
+// SYS_CONF_t sys_conf ={
+//     .SW_version = 1,
+//     .HW_version = 1,
+//     .VER_type = 1,
+//     .Manager_sLim =100,
+//     .Tourist_sLim =50,
+//     .Speed_Cut_sLim =20,
+//     .Brake_DLimit =1200,
+//     .Speed_Cut_DLimit =2000,
+//     .Brake_DLimit_B =1200,
+//     .Speed_Cut_DLimit_B =2000,
+// };
 sys_sta_t sys_sta;
 
 typedef enum {
@@ -133,6 +133,8 @@ uint8_t pmu_voltage_to_percent(uint32_t volt){//电压转百分比
 static uint32_t back_timecount = 0;
 static uint8_t door_lock_last_status = 0;
 static uint8_t S_MODE_last_status = 1;
+static uint8_t P_MODE_last_status = 1;
+
 
 BAT_Message_t BAT_Message;
 
@@ -241,16 +243,17 @@ void control_out_task(void *argument){
                 local_tts_text_play("行程结束，祝您生活愉快",0,0);
             }
         }
-        if((S_MODE_last_status != sys_sta.MAG_MODE) || ((0 == sys_sta.PLT_MODE)&&(1 == sys_sta.O_door_lock))){ // 管理员模式状态变化时触发
+        if((S_MODE_last_status != sys_sta.MAG_MODE)||(P_MODE_last_status != sys_sta.PLT_MODE)){ // 管理员模式状态变化时触发
             S_MODE_last_status = sys_sta.MAG_MODE;
+            P_MODE_last_status = sys_sta.PLT_MODE;
             if((0 == sys_sta.MAG_MODE)||(0 == sys_sta.PLT_MODE)){ // 管理模式
                 DEBUG("\n\nMAG_MODE\r\n\n");
                 // local_tts_set(5, 7, CM_LOCAL_TTS_DIGIT_AUTO);
-                local_tts_text_play("管理员模式",0,1);
+                local_tts_text_play("管理员模式",0,0);
             }else{ // 退出管理员模式
                 DEBUG("\n\nPLT_MODE\r\n\n");
                 // local_tts_set(10, 7, CM_LOCAL_TTS_DIGIT_AUTO);
-                local_tts_text_play("退出管理员模式",0,1);
+                local_tts_text_play("退出管理员模式",0,0);
             }
         }
 
@@ -271,12 +274,12 @@ void control_out_task(void *argument){
             uint8_t acc_percent =0;
             if((1 == sys_sta.MAG_MODE)&&(1 == sys_sta.PLT_MODE )){ // 游客模式
                 if(sys_sta.A_Speed_Cut){ // 自动减速
-                    acc_percent = (in_acc_percent * sys_conf.Speed_Cut_sLim) / 100.0;
+                    acc_percent = (in_acc_percent * SYS_CONF_SPEED_CUT_ACC) / 100.0;
                 }else{
-                    acc_percent = (in_acc_percent * sys_conf.Tourist_sLim) / 100.0;
+                    acc_percent = (in_acc_percent * SYS_CONF_TOURIST_ACC) / 100.0;
                 }
             }else{ // 管理员模式
-                acc_percent = (in_acc_percent * sys_conf.Manager_sLim) / 100.0;
+                acc_percent = (in_acc_percent * SYS_CONF_MANAGER_ACC) / 100.0;
             }
             set_out_acc_percent(acc_percent);
             // DEBUG("acc_percent:%d\r\n",acc_percent);
diff --git a/custom/custom_main/src/custom_main.c b/custom/custom_main/src/custom_main.c
index 1535d7d..1d96644 100644
--- a/custom/custom_main/src/custom_main.c
+++ b/custom/custom_main/src/custom_main.c
@@ -192,7 +192,7 @@ void  my_appimg_enter(char *param){
             local_tts_text_play("测试1",0 ,1); 
             local_tts_text_play("测试2",0 ,1); 
             cm_gpio_set_level(CM_GPIO_NUM_0, 0);
-            local_tts_text_play("测试3",0 ,0);
+            local_tts_text_play("测试3",0 ,0); 
             osDelay(5000/5);
 
             local_tts_volume(25);
diff --git a/custom/jt808/inc/jt808_electronic_fence.h b/custom/jt808/inc/jt808_electronic_fence.h
new file mode 100644
index 0000000..29a33cb
--- /dev/null
+++ b/custom/jt808/inc/jt808_electronic_fence.h
@@ -0,0 +1,29 @@
+#ifndef JT808_ELECTRONIC_FENCE_H_
+#define JT808_ELECTRONIC_FENCE_H_
+#include "jt808_protocol.h"
+#include "jt808_config.h"
+
+#pragma pack(1)
+typedef struct fence_Polygon_area_t{
+	uint32_t Area_ID; // 区域ID
+	uint16_t Area_att; // 区域属性
+	uint16_t Area_Points_Num; // 区域内点的数量
+    AreaPoint_t *Area_Points; // 区域内点的坐标集合
+	struct fence_Polygon_area_t *next; // 指向下一个区域
+}fence_Polygon_area_t;
+#pragma pack()
+
+extern uint32_t Rsp_Bigscenic_Fence_Polygon_area_ID;
+extern uint32_t Rsp_Bigban_Fence_Polygon_area_ID;
+
+// 增加围栏区域(队尾增加) // Area_att == 0x0001 景区围栏，Area_att == 0x0002 禁停区围栏
+void jt808_add_tail_fence_Polygon_area(uint32_t area_id ,uint16_t Area_att, uint16_t Area_Points_Num, AreaPoint_t *big_Area_Points);
+
+// 移除围栏区域(指定区域ID)
+void jt808_remove_fence_Polygon_area(uint32_t area_id);
+
+// 遍历围栏区域，判断指定坐标是否在围栏内
+// 返回区域ID // 0 未在围栏内 // Area_att == 0x0001 景区围栏，Area_att == 0x0002 禁停区围栏
+uint32_t jt808_Polygon_fence_check(uint16_t Area_att, uint32_t lat, uint32_t lng);
+
+#endif
\ No newline at end of file
diff --git a/custom/jt808/inc/jt808_protocol.h b/custom/jt808/inc/jt808_protocol.h
index 67449bf..4d88b28 100644
--- a/custom/jt808/inc/jt808_protocol.h
+++ b/custom/jt808/inc/jt808_protocol.h
@@ -28,6 +28,8 @@ typedef enum {
     ID_TxtMsgdelivery = 0x8300,     // 文本信息下发
     ID_Car_Ctrl = 0x8500,            // 车辆控制
     ID_Car_CtrlResp = 0x0500,        // 车辆控制应答
+    ID_Set_Polygon_area = 0x8604,    // 设置多边形区域
+    ID_Delete_Polygon_area = 0x8605, // 删除多边形区域
     ID_Data_Down = 0x8900, // 数据透传下行
     ID_Data_Up = 0x0900, // 数据透传上行
 }MessageID_t;
@@ -295,6 +297,28 @@ typedef struct {
     uint8_t *TxtString; // 文本信息字符串
 }TxtMsgdelivery_t;
 
+// 设置多边形区域体（0x8604）
+typedef struct {
+    uint32_t lat; // 纬度 以度为单位的纬度值乘以 10 的 6 次方
+    uint32_t lng; // 经度
+}AreaPoint_t;
+typedef struct {
+    uint32_t Area_ID; // 区域ID
+    uint16_t Area_att; // 区域属性
+    uint8_t Start_Time[6]; // 起始时间
+    uint8_t End_Time[6]; // 结束时间
+    uint16_t MaxSpeed; // 最大速度
+    uint8_t Overspeed_duration; // 超速持续时间
+    uint16_t Area_Points_Num; // 区域内点的数量
+    AreaPoint_t *Area_Points; // 区域内点的坐标集合
+}SetPolygonArea_t;
+
+// 删除多边形区域体（0x8605）
+typedef struct {
+    uint8_t Area_Num; // 区域数量
+    uint32_t *Area_ID_list; // 区域ID集合
+}DeletePolygonArea_t;
+
 // 数据透传体（0x8900/0x0900）
 typedef struct {
     uint8_t Msg_type; // 数据类型
diff --git a/custom/jt808/inc/jt808_set_TermParam.h b/custom/jt808/inc/jt808_set_TermParam.h
index 0c7f1d4..dc8649e 100644
--- a/custom/jt808/inc/jt808_set_TermParam.h
+++ b/custom/jt808/inc/jt808_set_TermParam.h
@@ -2,20 +2,30 @@
 #define JT808_SET_TERM_PARAM_H_
 #include "jt808_protocol.h"
 #include "jt808_config.h"
+#include "jt808_electronic_fence.h"
+
 
 #pragma pack(1)
 // 终端参数设置项参数ID
 typedef enum {
-	HeartBeatInterval = 0x0001,// DWORD, 终端心跳发送间隔(s)
-	MainServerAddr = 0x0013,//STRING, 主服务器地址,IP 或域名
-	ServerPort = 0x0018,//DWORD, 服务器 TCP 端口
-	DefaultTimeReportInterval = 0x0029,// DWORD, 缺省时间汇报间隔
-	InflexionAngle = 0x0030,// DWORD, 拐点补传角度, < 180°
-	MaxSpeed = 0x0055,// DWORD, 最高速度, km/h.
-	ProvinceID = 0x0081,// WORD, 车辆所在的省域 ID
-	CityID = 0x0082,// WORD, 车辆所在的市域 ID
-	CarPlateNum = 0x0083,//STRING, 公安交通管理部门颁发的机动车号牌
-	CarPlateColor = 0x0084,//车牌颜色，按照 JT/T415-2006 的 5.4.12
+	ID_HeartBeatInterval = 0x0001, // DWORD, 终端心跳发送间隔(s)
+	ID_MainServerAddr = 0x0013, //STRING, 主服务器地址,IP 或域名
+	ID_ServerPort = 0x0018, //DWORD, 服务器 TCP 端口
+	ID_DefaultTimeReportInterval = 0x0029, // DWORD, 缺省时间汇报间隔
+	ID_InflexionAngle = 0x0030, // DWORD, 拐点补传角度, < 180°
+	ID_MaxSpeed = 0x0055, // DWORD, 最高速度, km/h.
+	ID_ProvinceID = 0x0081, // WORD, 车辆所在的省域 ID
+	ID_CityID = 0x0082, // WORD, 车辆所在的市域 ID
+	ID_CarPlateNum = 0x0083, //STRING, 公安交通管理部门颁发的机动车号牌
+	ID_CarPlateColor = 0x0084, //车牌颜色，按照 JT/T415-2006 的 5.4.12
+	ID_RadarEN = 0xF001, // 雷达使能位, 0 代表关闭, 1 代表开启
+	ID_ManagerACC = 0xF002, // 管理员模式油门0~100%
+	ID_TouristACC = 0xF003, // 游客模式油门0~100%
+	ID_SpeedCutACC = 0xF004, // 自动减速油门0~100%
+	ID_BrakeLimit = 0xF005, //前进刹车距离
+	ID_SpeedCutLimit = 0xF006, // 前进自动减速刹车距离
+	ID_BrakeLimit_B = 0xF007, // 后退刹车距离
+	ID_SpeedCutLimit_B = 0xF008, // 后退自动减速刹车距离
 }set_TermParamID_t;
 typedef struct{
 	uint32_t HeartBeatInterval;// DWORD, 终端心跳发送间隔(s)
@@ -28,6 +38,15 @@ typedef struct{
 	uint16_t CityID;// WORD, 车辆所在的市域 ID
 	uint8_t CarPlateNum[10];//STRING, 公安交通管理部门颁发的机动车号牌
 	uint8_t CarPlateColor;//车牌颜色，按照 JT/T415-2006 的 5.4.12
+
+	uint8_t RadarEN; // 雷达使能位, 0 代表关闭, 1 代表开启
+	uint8_t ManagerACC; // 管理员模式油门0~100%
+	uint8_t TouristACC; // 游客模式油门0~100%
+	uint8_t SpeedCutACC; // 自动减速油门0~100%
+	uint16_t BrakeLimit; //前进刹车距离
+	uint16_t SpeedCutLimit; // 前进自动减速刹车距离
+	uint16_t BrakeLimit_B; // 后退刹车距离
+	uint16_t SpeedCutLimit_B; // 后退自动减速刹车距离
 }set_TermParam_t;
 
 // 支持的附加消息ID
@@ -47,6 +66,8 @@ typedef enum{
   CustomInformationLengthID = 0xE0,// 后续自定义信息长度, BYTE
   BAT_VoltageID = 0xE1, // 电池电压, 0.1V WORD
   BAT_PercentageID = 0xE2, // 电池电量, % BYTE
+  Scenic_Fence_Polygon_area_ID = 0xE3, // 当前位置所在景区围栏多边形区域ID, DWORD
+  Ban_Fence_Polygon_area_ID = 0xE4, // 当前位置所在禁止围栏多边形区域ID, DWORD
 }addi_infoID_t;
 
 // big_标记的参数需以大端方式存储，需手动转换为大端
@@ -62,6 +83,7 @@ typedef struct {// 终端参数项
     Term_Upgrade_t big_upgrade_info; // 解析出的升级信息
     LocReport_t big_loc_report; // 位置信息汇报
     LocTrackingCtrl_t big_loc_tracking_ctrl; // 临时位置跟踪控制
+	fence_Polygon_area_t *fence_polygon_area; // 围栏多边形区域
 	Data_SeriaNet_t big_data_up_SeriaNet; // 数据上行透传
 }Term_Param_item_t;
 #pragma pack()
@@ -84,6 +106,9 @@ int8_t jt808_data_up_SeriaNet(uint8_t type, uint8_t *data, uint16_t len);
 // 设置终端参数
 int jt808_setTermParam(set_TermParamID_t param_id, void *param, uint8_t param_len);
 
+// 更新自动上报参数
+void jt808_LocReport_param_update(void);
+
 // 启动自动上报参数
 void jt808_Autoreport_param_start(void);
 
diff --git a/custom/jt808/jt808.mk b/custom/jt808/jt808.mk
index 248309b..f3f99b4 100644
--- a/custom/jt808/jt808.mk
+++ b/custom/jt808/jt808.mk
@@ -1,19 +1,11 @@
 
 CUSTOM_MAIN_DIR := custom/jt808
 
-# OC_FILES += $(CUSTOM_MAIN_DIR)/src/bcd.c
-# OC_FILES += $(CUSTOM_MAIN_DIR)/src/client_manager.c
-# OC_FILES += $(CUSTOM_MAIN_DIR)/src/gbk_utf8.c
-# OC_FILES += $(CUSTOM_MAIN_DIR)/src/jt808_packager.c
-# OC_FILES += $(CUSTOM_MAIN_DIR)/src/jt808_parser.c
-# OC_FILES += $(CUSTOM_MAIN_DIR)/src/location_report.c
-# OC_FILES += $(CUSTOM_MAIN_DIR)/src/set_terminal_parameter.c
-# OC_FILES += $(CUSTOM_MAIN_DIR)/src/terminal_register.c
-# OC_FILES += $(CUSTOM_MAIN_DIR)/src/util.c
 OC_FILES += $(CUSTOM_MAIN_DIR)/src/jt808_util.c
 OC_FILES += $(CUSTOM_MAIN_DIR)/src/jt808_msg_pkg.c
 OC_FILES += $(CUSTOM_MAIN_DIR)/src/jt808_msg_parse.c
 OC_FILES += $(CUSTOM_MAIN_DIR)/src/jt808_pkg_transmit.c
 OC_FILES += $(CUSTOM_MAIN_DIR)/src/jt808_set_TermParam.c
+OC_FILES += $(CUSTOM_MAIN_DIR)/src/jt808_electronic_fence.c
 
 INC      += -I'$(CUSTOM_MAIN_DIR)/inc'
\ No newline at end of file
diff --git a/custom/jt808/src/jt808_electronic_fence.c b/custom/jt808/src/jt808_electronic_fence.c
new file mode 100644
index 0000000..53db226
--- /dev/null
+++ b/custom/jt808/src/jt808_electronic_fence.c
@@ -0,0 +1,174 @@
+#include "jt808_set_TermParam.h"
+#include "gps_config.h"
+#include "jt808_msg_pkg.h"
+#include "jt808_msg_parse.h"
+#include "jt808_pkg_transmit.h"
+#include "cm_sys.h"
+#include "cm_sim.h"
+
+#include "jt808_electronic_fence.h"
+#include "control_out.h"
+#include <stdio.h>
+#include <math.h>
+ 
+typedef struct {
+	double x;
+	double y;
+}fence_point_t;
+// 判断两个double数是否相等
+int equal(double a, double b){
+    if((fabs(a-b)) <= (1E-6)){
+        return 1;
+	}
+	return 0;
+}
+
+// 多边形围栏检测 (铅垂线内点法) // 0 点在多边形外，1 点在多边形内
+int Polygon_fence_check(fence_point_t point, fence_point_t *polygon, int polygon_num){
+	int i;
+	int next_i;
+	int crossings_count = 0;
+	double slope;
+
+	if(polygon == NULL){
+		return -1;
+	}
+	for(i = 0; i < polygon_num; i++){
+		next_i = (i + 1) % polygon_num;
+
+		// 线段的横坐标一样，表示线段竖直。这种情况，我们认为被测点引发的竖直射线不会和此类线段相、交。包括射线和线段重叠。
+		if(equal(polygon[i].x, polygon[next_i].x) == 1){ // 射线与线段竖直，跳过
+			JT808_DEBUG("point %d and point %d x is same\r\n", i, next_i);
+			continue;
+		}
+		// 判断被测点的横坐标是否在某线段两顶点的横坐标区间内。注意:当线段左边顶点的横坐标与被测点的横坐标一样时，我们以为
+		// 被测点的横坐标在线段两顶点的横坐标区间内；当线段右边顶点的横坐标与被测点的横坐标一样时，我们以为被测点的横
+		// 坐标在线段两顶点的横坐标区间外。
+		if(((polygon[i].x <= point.x) && (point.x < polygon[next_i].x)) || 
+		   ((polygon[next_i].x <= point.x) && (point.x < polygon[i].x))){ // 被测点横坐标在线段两顶点横坐标区间内
+			// 当被测点的横坐标在两顶点的横坐标区间内时，计算线段上对应被测点横坐标的纵坐标。当这个纵坐标大于被测点的纵坐标时，
+			// 我们以为射线与线段相交。
+			slope = (polygon[next_i].y - polygon[i].y) / (polygon[next_i].x - polygon[i].x);
+			if(point.y < (slope * (point.x - polygon[i].x) + polygon[i].y)){ // 射线与线段相交
+				JT808_DEBUG("crossing line num = %d\r\n", i);
+				crossings_count++;
+			}
+		}
+	}
+	JT808_DEBUG("crossings count = %d\r\n", crossings_count);
+	return ((crossings_count % 2) != 0);
+}
+
+// 增加围栏区域(队尾增加) // Area_att == 0x0001 景区围栏，Area_att == 0x0002 禁停区围栏
+void jt808_add_tail_fence_Polygon_area(uint32_t area_id ,uint16_t Area_att, uint16_t Area_Points_Num, AreaPoint_t *big_Area_Points){
+	if(area_id == 0 || big_Area_Points == NULL || Area_Points_Num == 0){
+		return;
+	}
+	// TODO: 增加附加信息
+	fence_Polygon_area_t *p_head =jt808_term_param_item.fence_polygon_area;
+	while(p_head != NULL){
+		if(p_head->Area_ID == area_id){
+			// 已存在该消息ID
+			return;
+		}
+		p_head = p_head->next;
+	}
+	// 未找到该消息ID，增加
+	p_head = (fence_Polygon_area_t *)jt808_malloc(sizeof(fence_Polygon_area_t));
+	if(p_head == NULL){
+		JT808_DEBUG("[%s,%d] malloc failed \r\n", __FUNCTION__,__LINE__);
+		return;
+	}
+	if(jt808_term_param_item.fence_polygon_area == NULL){
+		jt808_term_param_item.fence_polygon_area = p_head;
+	}else{
+		fence_Polygon_area_t *p_tail =jt808_term_param_item.fence_polygon_area;
+		while(p_tail->next != NULL){
+			p_tail = p_tail->next;
+		}
+		p_tail->next = p_head;
+	}
+	p_head->next = NULL;
+	p_head->Area_ID = area_id;
+	p_head->Area_att = Area_att; // 区域属性
+	p_head->Area_Points_Num = Area_Points_Num; // 区域内点的数量
+	p_head->Area_Points = (AreaPoint_t *)jt808_malloc(sizeof(AreaPoint_t)*Area_Points_Num);// 区域内点的坐标集合
+    if(p_head->Area_Points == NULL){
+        JT808_DEBUG("[%s,%d] malloc failed \r\n", __FUNCTION__,__LINE__);
+        return;
+    }
+	for(int i = 0; i < Area_Points_Num; i++){
+		p_head->Area_Points[i].lat = Swap32(big_Area_Points[i].lat);
+		p_head->Area_Points[i].lng = Swap32(big_Area_Points[i].lng);
+	}
+}
+
+// 移除围栏区域(指定区域ID)
+void jt808_remove_fence_Polygon_area(uint32_t area_id){
+	if(area_id == 0){
+		fence_Polygon_area_t *p_head =jt808_term_param_item.fence_polygon_area;
+		fence_Polygon_area_t *p_next =NULL;
+		while(p_head != NULL){
+			p_next = p_head->next;
+			if(p_head->Area_Points != NULL){
+				jt808_free(p_head->Area_Points);
+			}
+			jt808_free(p_head);
+			p_head = p_next;
+		}
+		return;
+	}
+	fence_Polygon_area_t *p_head =jt808_term_param_item.fence_polygon_area;
+	fence_Polygon_area_t *p_prev =NULL;
+	while(p_head != NULL){
+		if(p_head->Area_ID == area_id){
+			if(p_prev == NULL){
+				jt808_term_param_item.fence_polygon_area = p_head->next;
+			}else{
+				p_prev->next = p_head->next;
+			}
+			p_head->Area_ID = 0;
+			p_head->Area_att = 0;
+			p_head->Area_Points_Num = 0;
+			if(p_head->Area_Points != NULL){
+				jt808_free(p_head->Area_Points);
+			}
+			jt808_free(p_head);
+			break;
+		}
+		p_prev = p_head;
+		p_head = p_head->next;
+	}
+}
+
+uint32_t Rsp_Bigscenic_Fence_Polygon_area_ID = 0;
+uint32_t Rsp_Bigban_Fence_Polygon_area_ID = 0;
+
+// 遍历围栏区域，判断指定坐标是否在围栏内
+// 返回区域ID // 0 未在围栏内 // Area_att == 0x0001 景区围栏，Area_att == 0x0002 禁停区围栏
+uint32_t jt808_Polygon_fence_check(uint16_t Area_att, uint32_t lat, uint32_t lng){
+	fence_Polygon_area_t *p_head =jt808_term_param_item.fence_polygon_area;
+	while(p_head != NULL){
+		if((p_head->Area_Points_Num == 0) || (p_head->Area_att != Area_att)){
+			p_head = p_head->next;
+			continue;
+		}
+		fence_point_t *p_point = (fence_point_t *)jt808_malloc(sizeof(fence_point_t)*p_head->Area_Points_Num);
+		if(p_point == NULL){
+			JT808_DEBUG("[%s,%d] malloc failed \r\n", __FUNCTION__,__LINE__);
+			p_head = p_head->next;
+			continue;
+		}
+		for(int i = 0; i < p_head->Area_Points_Num; i++){
+			p_point[i].x = p_head->Area_Points[i].lat;
+			p_point[i].y = p_head->Area_Points[i].lng;
+		}
+		if(Polygon_fence_check((fence_point_t){.x = lat, .y = lng}, p_point, p_head->Area_Points_Num) == 1){
+			jt808_free(p_point);
+			return p_head->Area_ID;
+		}
+		jt808_free(p_point);
+		p_head = p_head->next;
+	}
+	return 0;
+}
diff --git a/custom/jt808/src/jt808_msg_parse.c b/custom/jt808/src/jt808_msg_parse.c
index 2e5ed13..a48e7e2 100644
--- a/custom/jt808/src/jt808_msg_parse.c
+++ b/custom/jt808/src/jt808_msg_parse.c
@@ -1,6 +1,7 @@
 #include "jt808_msg_parse.h"
 #include "jt808_pkg_transmit.h"
 #include "local_tts.h"
+#include "jt808_electronic_fence.h"
 
 PrsResult_t PrsResult;
 
@@ -39,13 +40,13 @@ static int jt808_BodyParse(void *Prsmsg_body, PrsResult_t *Result){
 		}
 		case ID_SetTermParams:{// 设置终端参数
 			Result->term_param_item->big_specific_params.param_Total_num = ((uint8_t *)Prsmsg_body)[0]; // 总参数个数
-			uint16_t param_lenoffset = 1;
+			uint8_t *p_Prsmsg_body = (uint8_t *)Prsmsg_body + 1;
 			for(int i = 0; i < Result->term_param_item->big_specific_params.param_Total_num; i++){
 				// 设置终端参数
-				jt808_setTermParam(Swap32(*(uint32_t *)(Prsmsg_body + param_lenoffset)), // 参数ID
-								  (void *)(Prsmsg_body + param_lenoffset + 5), // 参数值
-								  *((uint8_t*)(Prsmsg_body + param_lenoffset + 4))); // 参数长度
-				param_lenoffset += 5 + (*((uint8_t*)(Prsmsg_body + param_lenoffset + 4))); // 参数ID(4) + 参数长度(1) + 参数值(n)
+				jt808_setTermParam(((uint8_t *)(p_Prsmsg_body))[0] << 24 | ((uint8_t *)(p_Prsmsg_body))[1] << 16 | ((uint8_t *)(p_Prsmsg_body))[2] << 8 | ((uint8_t *)(p_Prsmsg_body))[3], // 参数ID
+								  (void *)(p_Prsmsg_body + 5), // 参数值
+								  p_Prsmsg_body[4]); // 参数长度
+				p_Prsmsg_body += 5 + p_Prsmsg_body[4]; // 参数ID(4) + 参数长度(1) + 参数值(n)
 			}
 			Result->Rsp_flow_num = Result->msg_head.msg_flow_num;
 			Result->Rsp_msg_id = Result->msg_head.msg_id;
@@ -128,6 +129,37 @@ static int jt808_BodyParse(void *Prsmsg_body, PrsResult_t *Result){
 			jt808_pkg_send(ID_Car_CtrlResp, 0);// 发送车辆控制应答，设置本消息无发送应答
 			break;
 		}
+		case ID_Set_Polygon_area:{// 设置多边形区域
+			uint32_t Area_ID; // 区域ID
+			uint16_t Area_att; // 区域属性
+			uint16_t Area_Points_Num; // 区域内点的数量
+			memcpy(&Area_ID, ((uint8_t *)Prsmsg_body), 4); // 区域ID
+			memcpy(&Area_att, ((uint8_t *)Prsmsg_body)+4, 2); // 区域属性
+			memcpy(&Area_Points_Num, ((uint8_t *)Prsmsg_body)+21, 2); // 区域点个数
+
+			jt808_add_tail_fence_Polygon_area(Swap32(Area_ID), // 区域ID
+										   Swap16(Area_att), // 区域属性
+										   Swap16(Area_Points_Num), // 区域点个数
+										   (AreaPoint_t *)(((uint8_t *)Prsmsg_body) + 23)); // 区域点坐标
+			Result->Rsp_flow_num = Result->msg_head.msg_flow_num;
+			Result->Rsp_msg_id = Result->msg_head.msg_id;
+			Result->Rsp_result = Msg_ok;
+			jt808_pkg_send(ID_Term_GenResp, 0);// 发送终端通用应答
+			break;
+		}
+		case ID_Delete_Polygon_area:{// 删除多边形区域
+			uint8_t Area_ID_Num = ((uint8_t *)Prsmsg_body)[0]; // 区域ID个数
+			Prsmsg_body = (void *)((uint8_t *)Prsmsg_body + 1); // 跳过1字节
+			for(int i = 0; i < Area_ID_Num; i++){
+				jt808_remove_fence_Polygon_area(((uint8_t *)Prsmsg_body)[i]<<24 | ((uint8_t *)Prsmsg_body)[i+1]<<16 | ((uint8_t *)Prsmsg_body)[i+2]<<8 | ((uint8_t *)Prsmsg_body)[i+3]);
+				// jt808_remove_fence_Polygon_area(Swap32(((uint32_t *)Prsmsg_body)[i]));
+			}
+			Result->Rsp_flow_num = Result->msg_head.msg_flow_num;
+			Result->Rsp_msg_id = Result->msg_head.msg_id;
+			Result->Rsp_result = Msg_ok;
+			jt808_pkg_send(ID_Term_GenResp, 0);// 发送终端通用应答
+			break;
+		}
 		case ID_Data_Down:{// 数据下行透传
 			jt808_data_down_SeriaNet(((uint8_t *)Prsmsg_body)[0],((uint8_t *)Prsmsg_body) + 1, Result->msg_head.msgbody_attr.msgbodylen - 1); // 透传数据
 			Result->Rsp_flow_num = Result->msg_head.msg_flow_num;
diff --git a/custom/jt808/src/jt808_msg_pkg.c b/custom/jt808/src/jt808_msg_pkg.c
index a420de3..427c286 100644
--- a/custom/jt808/src/jt808_msg_pkg.c
+++ b/custom/jt808/src/jt808_msg_pkg.c
@@ -106,6 +106,7 @@ static int jt808_BodyPackage(JT808_2013_MsgFrame_t *p_MsgFrame, MessageID_t Msg_
             break;
         }
         case ID_LocReport:{ // 位置信息汇报
+            jt808_LocReport_param_update(); // 更新位置信息参数
             p_MsgFrame->msg_head.msgbody_attr.msgbodylen = sizeof(Loc_basic_info_t);// 消息体长度
             Loc_addi_info_t *p_loc_addi_info = PrsResult.term_param_item->big_loc_report.addi_info;
             while(p_loc_addi_info != NULL){ // 计算附加信息长度
@@ -142,7 +143,7 @@ static int jt808_BodyPackage(JT808_2013_MsgFrame_t *p_MsgFrame, MessageID_t Msg_
             break;
         }
         case ID_Car_CtrlResp:{ // 车辆控制应答
-
+            jt808_LocReport_param_update(); // 更新位置信息参数
             p_MsgFrame->msg_head.msgbody_attr.msgbodylen =2 + sizeof(Loc_basic_info_t);// 消息体长度
             Loc_addi_info_t *p_loc_addi_info = PrsResult.term_param_item->big_loc_report.addi_info;
             while(p_loc_addi_info != NULL){ // 计算附加信息长度
@@ -192,9 +193,10 @@ static int jt808_BodyPackage(JT808_2013_MsgFrame_t *p_MsgFrame, MessageID_t Msg_
             // JT808_DEBUG("ID_Data_Up\r\n");
 			break;
 		}
-        default:
+        default:{
             return -2;
             break;
+        }
     }
 
     return 0;
diff --git a/custom/jt808/src/jt808_set_TermParam.c b/custom/jt808/src/jt808_set_TermParam.c
index 00d16a6..49723de 100644
--- a/custom/jt808/src/jt808_set_TermParam.c
+++ b/custom/jt808/src/jt808_set_TermParam.c
@@ -76,46 +76,78 @@ int8_t jt808_data_up_SeriaNet(uint8_t type, uint8_t *data, uint16_t len){
 // 设置终端参数
 int jt808_setTermParam(set_TermParamID_t param_id, void *param, uint8_t param_len){
 	switch(param_id){
-		case HeartBeatInterval:{
+		case ID_HeartBeatInterval:{
 			jt808_term_param_item.set_term_param.HeartBeatInterval =Swap32(*(uint32_t*)param);
 			break;
 		}
-		case MainServerAddr:{
+		case ID_MainServerAddr:{
 			memcpy(jt808_term_param_item.set_term_param.MainServerAddr,param,50<param_len?param_len:50);
 			break;
 		}
-		case ServerPort:{
+		case ID_ServerPort:{
 			jt808_term_param_item.set_term_param.ServerPort =Swap32(*(uint32_t*)param);
 			break;
 		}
-		case DefaultTimeReportInterval:{
+		case ID_DefaultTimeReportInterval:{
 			jt808_term_param_item.set_term_param.DefaultTimeReportInterval =Swap32(*(uint32_t*)param);
 			break;
 		}
-		case InflexionAngle:{
+		case ID_InflexionAngle:{
 			jt808_term_param_item.set_term_param.InflexionAngle =Swap32(*(uint32_t*)param);
 			break;
 		}
-		case MaxSpeed:{
+		case ID_MaxSpeed:{
 			jt808_term_param_item.set_term_param.MaxSpeed =Swap32(*(uint32_t*)param);
 			break;
 		}
-		case ProvinceID:{
+		case ID_ProvinceID:{
 			jt808_term_param_item.set_term_param.ProvinceID =Swap16(*(uint16_t*)param);
 			break;
 		}
-		case CityID:{
+		case ID_CityID:{
 			jt808_term_param_item.set_term_param.CityID =Swap16(*(uint16_t*)param);
 			break;
 		}
-		case CarPlateNum:{
+		case ID_CarPlateNum:{
 			memcpy(jt808_term_param_item.set_term_param.CarPlateNum,param,10<param_len?param_len:10);
 			break;
 		}
-		case CarPlateColor:{
+		case ID_CarPlateColor:{
 			jt808_term_param_item.set_term_param.CarPlateColor =((uint8_t*)param)[0];
 			break;
 		}
+		case ID_RadarEN:{// TODO: 雷达使能位
+			jt808_term_param_item.set_term_param.RadarEN =((uint8_t*)param)[0];
+			break;
+		}
+		case ID_ManagerACC:{ // 管理员模式油门0~100%
+			jt808_term_param_item.set_term_param.ManagerACC =((uint8_t*)param)[0];
+			break;
+		}
+		case ID_TouristACC:{ // 游客模式油门0~100%
+			jt808_term_param_item.set_term_param.TouristACC =((uint8_t*)param)[0];
+			break;
+		}
+		case ID_SpeedCutACC:{ // 自动减速油门0~100%
+			jt808_term_param_item.set_term_param.SpeedCutACC =((uint8_t*)param)[0];
+			break;
+		}
+		case ID_BrakeLimit:{ //前进刹车距离
+			jt808_term_param_item.set_term_param.BrakeLimit =Swap16(*(uint16_t*)param);
+			break;
+		}
+		case ID_SpeedCutLimit:{ // 前进自动减速刹车距离
+			jt808_term_param_item.set_term_param.SpeedCutLimit =Swap16(*(uint16_t*)param);
+			break;
+		}
+		case ID_BrakeLimit_B:{ // 后退刹车距离
+			jt808_term_param_item.set_term_param.BrakeLimit_B =Swap16(*(uint16_t*)param);
+			break;
+		}
+		case ID_SpeedCutLimit_B:{ // 后退自动减速刹车距离
+			jt808_term_param_item.set_term_param.SpeedCutLimit_B =Swap16(*(uint16_t*)param);
+			break;
+		}
 		default:{
 			// TODO: 未知参数
 			return -1;
@@ -175,6 +207,18 @@ void jt808_LocReport_add_tail_addi_info(uint8_t msg_id){
 			p_head->msg = (void *)(&BAT_Message.Bat_Percent);
 			break;
 		}
+		case Scenic_Fence_Polygon_area_ID:{
+			// 景区围栏多边形区域ID, DWORD
+			p_head->msg_len = 4;
+			p_head->msg = (void *)(&Rsp_Bigscenic_Fence_Polygon_area_ID);
+			break;
+		}
+		case Ban_Fence_Polygon_area_ID:{
+			// 禁止围栏多边形区域ID, DWORD
+			p_head->msg_len = 4;
+			p_head->msg = (void *)(&Rsp_Bigban_Fence_Polygon_area_ID);
+			break;
+		}
 		default:{
 			// TODO: 未知消息ID
 			jt808_free(p_head);
@@ -204,57 +248,116 @@ void jt808_LocReport_remove_addi_info(uint8_t msg_id){
 
 osThreadFunc_t Autoreport_param_ThreadId;
 
+// 更新自动上报参数
+void jt808_LocReport_param_update(void){
+	nmeaTIME beiJingTime; // 北京时间
+	// TODO: 自动上报参数
+	// 1. 位置基本信息
+	GMTconvert(&gps_data.info.utc, &beiJingTime, 8, 1);
+	if(beiJingTime.mon == 0){
+		beiJingTime.mon = 1;
+	}
+	if(beiJingTime.day == 0){
+		beiJingTime.day = 1;
+	}
+	// info.lat lon中的格式为[degree][min].[sec/60]，使用以下函数转换成[degree].[degree]格式
+	jt808_term_param_item.big_loc_report.basic_info.latitude = Swap32(nmea_ndeg2degree(gps_data.info.lat) * 1e6);
+	jt808_term_param_item.big_loc_report.basic_info.longitude = Swap32(nmea_ndeg2degree(gps_data.info.lon) * 1e6);
+	jt808_term_param_item.big_loc_report.basic_info.altitude = Swap16(gps_data.info.elv);
+	jt808_term_param_item.big_loc_report.basic_info.speed = Swap16(gps_data.info.speed * 10);
+	jt808_term_param_item.big_loc_report.basic_info.direction = Swap16(gps_data.info.direction);
+	jt808_term_param_item.big_loc_report.basic_info.BCDtime[0] =((((beiJingTime.year+1900)%2000%100/10)&0x0F)<<4) | (((beiJingTime.year+1900)%2000%10)&0x0F);
+	jt808_term_param_item.big_loc_report.basic_info.BCDtime[1] = (((beiJingTime.mon%100/10)&0x0F)<<4) | ((beiJingTime.mon%10)&0x0F);
+	jt808_term_param_item.big_loc_report.basic_info.BCDtime[2] = (((beiJingTime.day%100/10)&0x0F)<<4) | ((beiJingTime.day%10)&0x0F);
+	jt808_term_param_item.big_loc_report.basic_info.BCDtime[3] = (((beiJingTime.hour%100/10)&0x0F)<<4) | ((beiJingTime.hour%10)&0x0F);
+	jt808_term_param_item.big_loc_report.basic_info.BCDtime[4] = (((beiJingTime.min%100/10)&0x0F)<<4) | ((beiJingTime.min%10)&0x0F);
+	jt808_term_param_item.big_loc_report.basic_info.BCDtime[5] = (((beiJingTime.sec%100/10)&0x0F)<<4) | ((beiJingTime.sec%10)&0x0F);
+
+	jt808_term_param_item.big_loc_report.basic_info.status.val32 = 0; // 清除状态信息
+	jt808_term_param_item.big_loc_report.basic_info.status.positioning = (((gps_data.info.fix == 1)||(gps_data.info.sig == 0)) ? 0 : 1); // 0:未定位，1:已定位
+	jt808_term_param_item.big_loc_report.basic_info.status.acc =((1==sys_sta.O_door_lock)||(0==sys_sta.MAG_MODE)); // 1:电门锁打开,0:电门锁关闭
+	jt808_term_param_item.big_loc_report.basic_info.status.MAG_MODE =sys_sta.MAG_MODE;// 1:游客模式,0:管理模式
+	jt808_term_param_item.big_loc_report.basic_info.status.PLT_MODE =sys_sta.PLT_MODE; // 1:游客模式,0:管理模式
+	jt808_term_param_item.big_loc_report.basic_info.status.IO_RX_back =sys_sta.IO_RX_back; // 1:正常 0:倒车
+	jt808_term_param_item.big_loc_report.basic_info.status.IO_TX_brake =sys_sta.IO_TX_brake; // 1:正常 0:刹车
+	jt808_term_param_item.big_loc_report.basic_info.status.A_brake =sys_sta.A_brake; // 1:自动刹车,0:手动刹车
+	jt808_term_param_item.big_loc_report.basic_info.status.A_Speed_Cut =sys_sta.A_Speed_Cut; // 1:自动减速,0:手动减速
+	jt808_term_param_item.big_loc_report.basic_info.status.P_Radar_EN =sys_sta.P_Radar_EN; // 1:雷达使能,0:雷达禁止
+	jt808_term_param_item.big_loc_report.basic_info.status.val32 = Swap32(jt808_term_param_item.big_loc_report.basic_info.status.val32); // 状态信息（转大端）
+	
+	jt808_term_param_item.big_loc_report.basic_info.alarm_flag.val32 = 0; // 清除报警标志
+	jt808_term_param_item.big_loc_report.basic_info.alarm_flag.overspeed = 0; // bit_1 超速报警
+	jt808_term_param_item.big_loc_report.basic_info.alarm_flag.power_low = 0; // bit_7 终端主电源欠压
+	jt808_term_param_item.big_loc_report.basic_info.alarm_flag.road_deviate = 0; // bit_23 路线偏离报警 
+	jt808_term_param_item.big_loc_report.basic_info.alarm_flag.car_move = 0; // bit_28 车辆非法位移.收到应答后清零
+	jt808_term_param_item.big_loc_report.basic_info.alarm_flag.val32 = Swap32(jt808_term_param_item.big_loc_report.basic_info.alarm_flag.val32); // 报警标志（转大端）
+	
+	if((gps_data.info.fix == 1)||(gps_data.info.sig == 0)){ // 不可用// 未定位时发送心跳包
+
+	}else{
+		// 更新当前所在位置区域ID
+		uint32_t lat = nmea_ndeg2degree(gps_data.info.lat) * 1e6;
+		uint32_t lng = nmea_ndeg2degree(gps_data.info.lon) * 1e6;
+		Rsp_Bigscenic_Fence_Polygon_area_ID = Swap32(jt808_Polygon_fence_check(0x0001, lat, lng));
+		Rsp_Bigban_Fence_Polygon_area_ID = Swap32(jt808_Polygon_fence_check(0x0002, lat, lng));
+	}
+}
+
 void Autoreport_param_Task(void *arg){
 	uint32_t count_Sec = 0;// 计数器
-	nmeaTIME beiJingTime; // 北京时间
 
 	jt808_LocReport_add_tail_addi_info(BAT_VoltageID); // 增加电池电压信息
 	jt808_LocReport_add_tail_addi_info(BAT_PercentageID); // 增加电池电量信息
+	jt808_LocReport_add_tail_addi_info(Scenic_Fence_Polygon_area_ID); // 增加景区围栏多边形区域ID信息
+	jt808_LocReport_add_tail_addi_info(Ban_Fence_Polygon_area_ID); // 增加景区围栏多边形区域ID信息
+
+	// uint32_t area_ID=0;
+	// AreaPoint_t point[4] = {
+	// 	{39939236, 116369446},
+	// 	{39939236, 126379446},
+	// 	{49929236, 126379446},
+	// 	{49929236, 116369446}
+	// };
+	// for(int i=0;i<4;i++){
+	// 	point[i].lat = Swap32(point[i].lat);
+	// 	point[i].lng = Swap32(point[i].lng);
+	// }
+	// jt808_add_tail_fence_Polygon_area(0x0003, 0x0001, 4, point); // 增加景区围栏多边形区域ID信息
+
+	// area_ID = jt808_Polygon_fence_check(0x0001, 44939236, 121369446);
+	// JT808_DEBUG("area_ID0:%d\n",area_ID);
+	// area_ID = jt808_Polygon_fence_check(0x0001, 34939236, 121369446);
+	// JT808_DEBUG("area_ID1:%d\n",area_ID);
+	// jt808_remove_fence_Polygon_area(0x0003);
+	// area_ID = jt808_Polygon_fence_check(0x0001, 44939236, 121369446);
+	// JT808_DEBUG("area_ID2:%d remove\n",area_ID);
+
+	// AreaPoint_t point1[4] = {
+	// 	{69939236, 146369446},
+	// 	{69939236, 156379446},
+	// 	{79929236, 156379446},
+	// 	{79929236, 146369446}
+	// };
+	// for(int i=0;i<4;i++){
+	// 	point1[i].lat = Swap32(point1[i].lat);
+	// 	point1[i].lng = Swap32(point1[i].lng);
+	// }
+	// jt808_add_tail_fence_Polygon_area(0x0004, 0x0001, 4, point1); // 增加景区围栏多边形区域ID信息
+	// area_ID = jt808_Polygon_fence_check(0x0001, 74939236, 151369446);
+	// JT808_DEBUG("area_ID3:%d\n\n\n",area_ID);
+	// area_ID = jt808_Polygon_fence_check(0x0001, 64939236, 151369446);
+	// JT808_DEBUG("area_ID4:%d\n\n\n",area_ID);
+	// jt808_remove_fence_Polygon_area(0x0004);
+	// area_ID = jt808_Polygon_fence_check(0x0001, 74939236, 151369446);
+	// JT808_DEBUG("area_ID5:%d remove\n",area_ID);
 
 	while(1){
-		// TODO: 自动上报参数
-		// 1. 位置基本信息
-		GMTconvert(&gps_data.info.utc, &beiJingTime, 8, 1);
-		
-		// info.lat lon中的格式为[degree][min].[sec/60]，使用以下函数转换成[degree].[degree]格式
-		jt808_term_param_item.big_loc_report.basic_info.latitude = Swap32(nmea_ndeg2degree(gps_data.info.lat) * 1e6);
-		jt808_term_param_item.big_loc_report.basic_info.longitude = Swap32(nmea_ndeg2degree(gps_data.info.lon) * 1e6);
-		jt808_term_param_item.big_loc_report.basic_info.altitude = Swap16(gps_data.info.elv);
-		jt808_term_param_item.big_loc_report.basic_info.speed = Swap16(gps_data.info.speed * 10);
-		jt808_term_param_item.big_loc_report.basic_info.direction = Swap16(gps_data.info.direction);
-		jt808_term_param_item.big_loc_report.basic_info.BCDtime[0] =((((beiJingTime.year+1900)%2000%100/10)&0x0F)<<4) | (((beiJingTime.year+1900)%2000%10)&0x0F);
-		jt808_term_param_item.big_loc_report.basic_info.BCDtime[1] = (((beiJingTime.mon%100/10)&0x0F)<<4) | ((beiJingTime.mon%10)&0x0F);
-		jt808_term_param_item.big_loc_report.basic_info.BCDtime[2] = (((beiJingTime.day%100/10)&0x0F)<<4) | ((beiJingTime.day%10)&0x0F);
-		jt808_term_param_item.big_loc_report.basic_info.BCDtime[3] = (((beiJingTime.hour%100/10)&0x0F)<<4) | ((beiJingTime.hour%10)&0x0F);
-		jt808_term_param_item.big_loc_report.basic_info.BCDtime[4] = (((beiJingTime.min%100/10)&0x0F)<<4) | ((beiJingTime.min%10)&0x0F);
-		jt808_term_param_item.big_loc_report.basic_info.BCDtime[5] = (((beiJingTime.sec%100/10)&0x0F)<<4) | ((beiJingTime.sec%10)&0x0F);
-
-		jt808_term_param_item.big_loc_report.basic_info.status.val32 = 0; // 清除状态信息
-		jt808_term_param_item.big_loc_report.basic_info.status.positioning = (((gps_data.info.fix == 1)||(gps_data.info.sig == 0)) ? 0 : 1); // 0:未定位，1:已定位
-		jt808_term_param_item.big_loc_report.basic_info.status.acc =((1==sys_sta.O_door_lock)||(0==sys_sta.MAG_MODE)); // 1:电门锁打开,0:电门锁关闭
-		jt808_term_param_item.big_loc_report.basic_info.status.MAG_MODE =sys_sta.MAG_MODE;// 1:游客模式,0:管理模式
-        jt808_term_param_item.big_loc_report.basic_info.status.PLT_MODE =sys_sta.PLT_MODE; // 1:游客模式,0:管理模式
-        jt808_term_param_item.big_loc_report.basic_info.status.IO_RX_back =sys_sta.IO_RX_back; // 1:正常 0:倒车
-        jt808_term_param_item.big_loc_report.basic_info.status.IO_TX_brake =sys_sta.IO_TX_brake; // 1:正常 0:刹车
-        jt808_term_param_item.big_loc_report.basic_info.status.A_brake =sys_sta.A_brake; // 1:自动刹车,0:手动刹车
-        jt808_term_param_item.big_loc_report.basic_info.status.A_Speed_Cut =sys_sta.A_Speed_Cut; // 1:自动减速,0:手动减速
-        jt808_term_param_item.big_loc_report.basic_info.status.P_Radar_EN =sys_sta.P_Radar_EN; // 1:雷达使能,0:雷达禁止
-		jt808_term_param_item.big_loc_report.basic_info.status.val32 = Swap32(jt808_term_param_item.big_loc_report.basic_info.status.val32); // 状态信息（转大端）
-		
-		jt808_term_param_item.big_loc_report.basic_info.alarm_flag.val32 = 0; // 清除报警标志
-		jt808_term_param_item.big_loc_report.basic_info.alarm_flag.overspeed = 0; // bit_1 超速报警
-		jt808_term_param_item.big_loc_report.basic_info.alarm_flag.power_low = 0; // bit_7 终端主电源欠压
-		jt808_term_param_item.big_loc_report.basic_info.alarm_flag.road_deviate = 0; // bit_23 路线偏离报警 
-		jt808_term_param_item.big_loc_report.basic_info.alarm_flag.car_move = 0; // bit_28 车辆非法位移.收到应答后清零
-		jt808_term_param_item.big_loc_report.basic_info.alarm_flag.val32 = Swap32(jt808_term_param_item.big_loc_report.basic_info.alarm_flag.val32); // 报警标志（转大端）
+		jt808_LocReport_param_update(); // 更新位置信息参数
 
 		// jt808_term_param_item.big_loc_report.basic_info.alarm_flag.gnss_fault = 0 == gps_data.info.sig ? 1 : 0; // 0:无故障，1:有故障
 		if(0 == (count_Sec % jt808_term_param_item.set_term_param.HeartBeatInterval)){
 			if((gps_data.info.fix == 1)||(gps_data.info.sig == 0)){ // 不可用// 未定位时发送心跳包
 				jt808_pkg_send(ID_Term_HB,0); // 发送心跳包 // 不接收应答
-				// jt808_pkg_send(ID_LocReport, 0); // 发送位置信息上报包
-				// JT808_DEBUG("Bat_Percent:%d,Bat_Voltage:%d,Bat_STA:%X\r\n",BAT_Message.Bat_Percent,BAT_Message.Bat_Voltage,BAT_Message.Bat_STA);
-				// jt808_pkg_send(ID_GetTermAttrResp, 0); // 发送终端属性查询应答包
 			}else{
 				jt808_pkg_send(ID_LocReport,10000/5); // 发送位置信息上报包
 			}
@@ -378,11 +481,11 @@ void jt808_set_term_param_init(void){
 		// jt808_term_param_item.big_auth_info.str_auth_code = NULL;
 	}while(0);
 	do{// 终端参数初始化
-		jt808_term_param_item.set_term_param.HeartBeatInterval = 3; // 心跳包间隔(秒)
-		char ServerAddr[] ="47.99.118.34"; // 车牌号码
+		jt808_term_param_item.set_term_param.HeartBeatInterval = 30; // 心跳包间隔(秒)
+		char ServerAddr[] ="47.99.118.34"; // 服务器地址
 		uint32_t ServerPort = 5000; // 服务器端口
-		// char ServerAddr[] ="36.137.226.30"; // 车牌号码
-		// uint32_t ServerPort = 36204; // 服务器端口
+		// char ServerAddr[] ="106.14.30.23"; // 服务器地址
+		// uint32_t ServerPort = 5000; // 服务器端口
 		// memset(jt808_term_param_item.set_term_param.MainServerAddr, 0, 50);
 		memcpy(jt808_term_param_item.set_term_param.MainServerAddr, ServerAddr, strlen(ServerAddr)+1); // 主服务器地址
 		jt808_term_param_item.set_term_param.ServerPort = ServerPort; // 服务器端口
diff --git a/custom/local_tts/src/local_tts.c b/custom/local_tts/src/local_tts.c
index df6cf4a..9896326 100644
--- a/custom/local_tts/src/local_tts.c
+++ b/custom/local_tts/src/local_tts.c
@@ -185,7 +185,7 @@ static osThreadFunc_t local_tts_play_task(void *arg){
 			// DEBUG("tts task: 1111111111\n\n");
 			// if(0 == tts_play_queue.en_interruptible){ // 不允许被打断播放
 				// DEBUG("tts task: 2222222222\n\n");
-				ret =osSemaphoreAcquire(local_tts_play_ok_sem, (0 == tts_play_queue.en_interruptible)?(30000/5):(300/5));// 等待播放结束
+				ret =osSemaphoreAcquire(local_tts_play_ok_sem, (0 == tts_play_queue.en_interruptible)?(30000/5):(1000/5));// 等待播放结束
 				if(osOK != ret){
 					DEBUG("local_tts_play_ok_sem:%d\n", ret);
 				}
diff --git a/custom/radar/src/radar.c b/custom/radar/src/radar.c
index 5eb08fb..a44a87e 100644
--- a/custom/radar/src/radar.c
+++ b/custom/radar/src/radar.c
@@ -55,9 +55,9 @@ uint16_t crc16_modbus(uint8_t *data, uint16_t length){
 // 自动刹车或减速判断处理函数
 static void radar_AUTO_BrakeORSpeedCut(uint8_t radar_id , uint16_t Car_Distance){ //距离数据30~4500mm
     // 自动刹车距离
-    uint16_t Brake_Distance     = ((radar_id == RADAR_ID_Back )? sys_conf.Brake_DLimit_B : sys_conf.Brake_DLimit);
+    uint16_t Brake_Distance     = ((radar_id == RADAR_ID_Back )? SYS_CONF_BRAKE_LIMIT_B : SYS_CONF_BRAKE_LIMIT);
     // 自动减速距离
-    uint16_t Speed_Cut_Distance = ((radar_id == RADAR_ID_Back )? sys_conf.Speed_Cut_DLimit_B : sys_conf.Speed_Cut_DLimit);
+    uint16_t Speed_Cut_Distance = ((radar_id == RADAR_ID_Back )? SYS_CONF_SPEED_CUT_LIMIT_B : SYS_CONF_SPEED_CUT_LIMIT);
 
     if((35 < Car_Distance) && Car_Distance < Brake_Distance){//小于自动刹车距离时
         if(!sys_sta.A_brake){
diff --git a/custom/tcp_client/src/tcp_client.c b/custom/tcp_client/src/tcp_client.c
index 9edc81a..2a3b6e2 100644
--- a/custom/tcp_client/src/tcp_client.c
+++ b/custom/tcp_client/src/tcp_client.c
@@ -25,12 +25,14 @@ static osThreadId_t tcp_recv_ThreadId = NULL;
 static osThreadId_t net_manage_ThreadId = NULL;
 osSemaphoreId_t netconn_disconnect_sem = NULL; // 断开连接信号量
 
+#define RECV_MAX_LEN  (1024) // 接收最大长度
+
 // TCP接收线程
 static void tcp_recv_task(void){
     int ret = 0;
     fd_set sets;
     struct timeval timeout;
-    uint8_t buf[128] = {0};
+    uint8_t buf[RECV_MAX_LEN] = {0};
 
     while(1){
         FD_ZERO(&sets);
@@ -49,7 +51,10 @@ static void tcp_recv_task(void){
                     //     app_printf("%02x ", buf[i]);
                     // }
                     // app_printf("\n\n");
-
+                    if(ret > RECV_MAX_LEN){
+                        DEBUG("tcp_read recv too long:%d\n", ret);
+                        ret = RECV_MAX_LEN;
+                    }
                     // 处理接收到的数据
                     jt808_pkg_handle(buf, ret);
                     memset(buf, 0, sizeof(buf));
@@ -204,7 +209,8 @@ TCP_DISABLE:
                 }
             }
         }
-
+        
+        jt808_pkg_send(ID_GetTermAttrResp, 0); // 发送终端属性查询应答包
         jt808_Autoreport_param_start();//开启自动上报参数设置
         led_set_event(EVENT_NETWORK_READY); // 网络连接成功
         DEBUG("NetwarK connected!\r\n");