4G_module/custom/jt808/src/jt808_set_TermParam.c

#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_fs.h"
#include "cm_sim.h"

#include "local_tts.h"
#include "control_out.h"

Term_Param_item_t jt808_term_param_item; // 终端参数项

// 控制车辆状态
void jt808_Set_CarStatus(uint8_t status){
	// (void)status;
	// TODO: 车辆控制状态
	sys_sta.O_door_lock = (status & 0x01)? 1 : 0; // 设置电门锁状态
	sys_sta.PLT_MODE = (status & 0x02)? 1 : 0; // 平台设置的模式 //1:游客模式,0:管理模式
	sys_sta.P_Radar_EN = (status & 0x04)? 1 : 0; // 1:雷达使能,0:雷达禁止
}

// 获取车辆状态
uint8_t jt808_Get_CarStatus(void){
	uint8_t status = 0;
	// TODO: 车辆控制状态
	status |= (sys_sta.O_door_lock? 0x01 : 0); // 门锁状态
	status |= (sys_sta.PLT_MODE? 0x02 : 0); // 平台设置模式 //1:游客模式,0:管理模式
	status |= (sys_sta.P_Radar_EN? 0x04 : 0); // 1:雷达使能,0:雷达禁止
	return status;
}

// 串口数据下传 
int8_t jt808_data_down_SeriaNet(uint8_t type, uint8_t *data, uint16_t len){
	// TODO: 串口数据下传
	if(type == 0x41){ // 串口1下传
		JT808_DEBUG("Serial1 data: ");
		for(uint16_t i = 0; i < len; i++){
			JT808_DEBUG_DATA("%02X ", data[i]);
		}
		JT808_DEBUG_DATA("\r\n");
	}else if(type == 0x42){ // 串口2下传
		JT808_DEBUG("Serial2 data: ");
		for(uint16_t i = 0; i < len; i++){
			JT808_DEBUG_DATA("%02X ", data[i]);
		}
		JT808_DEBUG_DATA("\r\n");
	}else{
		JT808_DEBUG("[%s,%s] type error \r\n", __FUNCTION__,__LINE__);
		return -1;
	}
	return 0;
}

// 串口数据上传 // 超时2S即发送失败，直接放弃发送
int8_t jt808_data_up_SeriaNet(uint8_t type, uint8_t *data, uint16_t len){
	uint8_t ret = 0;
	// TODO: 串口数据上传
	if(NULL != jt808_term_param_item.big_data_up_SeriaNet.Msg_Data){
		jt808_free(jt808_term_param_item.big_data_up_SeriaNet.Msg_Data);
		jt808_term_param_item.big_data_up_SeriaNet.Msg_Data = NULL;
	}
	uint8_t *up_SeriaNet_buf = (uint8_t *)jt808_malloc(len);
	if(up_SeriaNet_buf == NULL){
		JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
		return -1;
	}
	jt808_term_param_item.big_data_up_SeriaNet.Msg_type = type; // 0x41:串口1上传，0x42:串口2上传
	jt808_term_param_item.big_data_up_SeriaNet.Msg_Data_Len = len;
	memcpy(up_SeriaNet_buf, data, len); // 复制数据内容
	jt808_term_param_item.big_data_up_SeriaNet.Msg_Data = up_SeriaNet_buf; 

	ret =jt808_pkg_send(ID_Data_Up,1000/5); // 发送位置信息上报包
	return ret;
}


#define TTERMPARAM_FILE  "TermParam.txt" // 区域ID列表文件

// 获取终端参数文件状态  0:文件存在  -1:文件不存在
int jt808_get_TermParam_state(void){
	if(1 == cm_fs_exist(TTERMPARAM_FILE)){
		JT808_DEBUG("TermParam file exist\r\n");
		return 0;
	}
	return -1;
}

// 保存终端参数
static int jt808_save_TermParam(void){
	int32_t fd = cm_fs_open(TTERMPARAM_FILE, CM_FS_WB);
	if(fd < 0){
		JT808_DEBUG("open %s failed\r\n", TTERMPARAM_FILE);
		return -1;
	}
	cm_fs_write(fd, (void *)(&jt808_term_param_item.set_term_param), sizeof(set_TermParam_t));
	cm_fs_close(fd);
	JT808_DEBUG("save TermParam file size = %d == %d\r\n", sizeof(set_TermParam_t));
	for(int i = 0; i < sizeof(set_TermParam_t); i++){
		JT808_DEBUG_DATA("%02x ",*((char *)(&jt808_term_param_item.set_term_param)+i));
	}
	JT808_DEBUG_DATA("\r\n");
	return 0;
}

// 加载终端参数
static int jt808_load_TermParam(void){
	if(1 != cm_fs_exist(TTERMPARAM_FILE)){
		JT808_DEBUG("no TermParam\r\n");
		return -1;
	}
	int32_t fd = cm_fs_open(TTERMPARAM_FILE, CM_FS_RB);
	if(fd < 0){
		JT808_DEBUG("open %s failed\r\n", TTERMPARAM_FILE);
		return -1;
	}
	int32_t file_size = cm_fs_filesize(TTERMPARAM_FILE);
	if(file_size <= 0){
		JT808_DEBUG("file size error\r\n");
		cm_fs_close(fd);
		return -2;
	}
	if(file_size != sizeof(set_TermParam_t)){
		JT808_DEBUG("file size error\r\n");
		cm_fs_close(fd);
		return -3;
	}else{
		JT808_DEBUG("load TermParam file size = %d == %d\r\n", file_size, sizeof(set_TermParam_t));
		cm_fs_read(fd, (void *)(&jt808_term_param_item.set_term_param), sizeof(set_TermParam_t));
		for(int i = 0; i < sizeof(set_TermParam_t); i++){
			JT808_DEBUG_DATA("%02x ",*((char *)(&jt808_term_param_item.set_term_param)+i));
		}
		JT808_DEBUG_DATA("\r\n");
		cm_fs_close(fd);
	}
	return 0;
}

// 设置终端参数
int jt808_setTermParam(set_TermParamID_t param_id, void *param, uint8_t param_len){
	switch(param_id){
		case ID_HeartBeatInterval:{
			jt808_term_param_item.set_term_param.HeartBeatInterval =Swap32(*(uint32_t*)param);
			break;
		}
		case ID_MainServerAddr:{
			memcpy(jt808_term_param_item.set_term_param.MainServerAddr,param,20<param_len?param_len:20);
			break;
		}
		case ID_ServerPort:{
			jt808_term_param_item.set_term_param.ServerPort =Swap32(*(uint32_t*)param);
			break;
		}
		case ID_DefaultTimeReportInterval:{
			jt808_term_param_item.set_term_param.DefaultTimeReportInterval =Swap32(*(uint32_t*)param);
			break;
		}
		case ID_InflexionAngle:{
			jt808_term_param_item.set_term_param.InflexionAngle =Swap32(*(uint32_t*)param);
			break;
		}
		case ID_MaxSpeed:{
			jt808_term_param_item.set_term_param.MaxSpeed =Swap32(*(uint32_t*)param);
			break;
		}
		case ID_ProvinceID:{
			jt808_term_param_item.set_term_param.ProvinceID =Swap16(*(uint16_t*)param);
			break;
		}
		case ID_CityID:{
			jt808_term_param_item.set_term_param.CityID =Swap16(*(uint16_t*)param);
			break;
		}
		case ID_CarPlateNum:{
			memcpy(jt808_term_param_item.set_term_param.CarPlateNum,param,10<param_len?param_len:10);
			break;
		}
		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;
		}
		case ID_Ban_Fence_Polygon_Delay_OFF:{ // 禁止围栏报警延时关闭时间, 单位秒
			jt808_term_param_item.set_term_param.Ban_Fence_Polygon_Delay_OFF =((uint8_t*)param)[0];
			break;
		}
		default:{
			// TODO: 未知参数
			return -1;
			break;
		}
	}
	jt808_save_TermParam(); // 保存终端参数

	return 0;
}

// 更新位置基本信息
int jt808_updateLocBasicInfo(Loc_basic_info_t *loc_basic_info){
	// (void *)loc_basic_info;

	return 0;
}

// 增加附加信息(队尾增加)
void jt808_LocReport_add_tail_addi_info(uint8_t msg_id){
	// TODO: 增加附加信息
	Loc_addi_info_t *p_head =jt808_term_param_item.big_loc_report.addi_info;
	while(p_head != NULL){
		if(p_head->msg_id == msg_id){
			// 已存在该消息ID
			return;
		}
		p_head = p_head->next;
	}
	// 未找到该消息ID，增加
	p_head = (Loc_addi_info_t *)jt808_malloc(sizeof(Loc_addi_info_t));
	if(p_head == NULL){
		JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
		return;
	}
	if(jt808_term_param_item.big_loc_report.addi_info == NULL){
		jt808_term_param_item.big_loc_report.addi_info = p_head;
	}else{
		Loc_addi_info_t *p_tail =jt808_term_param_item.big_loc_report.addi_info;
		while(p_tail->next != NULL){
			p_tail = p_tail->next;
		}
		p_tail->next = p_head;
	}
	p_head->msg_id = msg_id;
	p_head->next = NULL;

	// TODO: 增加附加信息
	switch(msg_id){
		case BAT_VoltageID:{
			// 电池电压, 0.1V WORD
			p_head->msg_len = 2;
			p_head->msg = (void *)(&BAT_Message.Bat_Voltage);
			break;
		}
		case BAT_PercentageID:{
			// 电池电量 , % BYTE
			p_head->msg_len = 1;
			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;
		}
		case Locked_Condition_ID:{
			// 锁车状态, BYTE
			p_head->msg_len = 1;
			p_head->msg = (void *)(&Rsp_locked_condition);
			break;
		}
		default:{
			// TODO: 未知消息ID
			jt808_free(p_head);
			break;
		}
	}
}

 // 移除附加信息(指定消息ID)
void jt808_LocReport_remove_addi_info(uint8_t msg_id){
	Loc_addi_info_t *p_head =jt808_term_param_item.big_loc_report.addi_info;
	Loc_addi_info_t *p_prev =NULL;
	while(p_head != NULL){
		if(p_head->msg_id == msg_id){
			if(p_prev == NULL){
				jt808_term_param_item.big_loc_report.addi_info = p_head->next;
			}else{
				p_prev->next = p_head->next;
			}
			jt808_free(p_head);
			break;
		}
		p_prev = p_head;
		p_head = p_head->next;
	}
}

osThreadFunc_t Autoreport_param_ThreadId;

uint16_t scenic_Fence_Polygon_count = 0;
uint16_t ban_Fence_Polygon_count = 0;
uint16_t delay_off_count = 0; // 延时关闭计数

uint8_t Rsp_locked_condition = 0; // 锁车状态, BYTE

// 更新自动上报参数
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)){ // 不可用// 未定位时发送心跳包
		Rsp_Bigscenic_Fence_Polygon_area_ID = 0;
		Rsp_Bigban_Fence_Polygon_area_ID = 0;
	}else{
		// 更新当前所在位置区域ID
		uint32_t lat = nmea_ndeg2degree(gps_data.info.lat) * 1e6;
		uint32_t lng = nmea_ndeg2degree(gps_data.info.lon) * 1e6;

		// lat = 44939236;
		// lng = 121369446;
		// lat = 34939236;
		// lng = 121369446;

		if(1 == sys_sta.O_door_lock){ // 电门锁打开,
			Rsp_locked_condition = 0; // 复位锁车状态
		}
		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));

		if(Rsp_Bigscenic_Fence_Polygon_area_ID == 0){ // 在景区围栏
			scenic_Fence_Polygon_count++;
			if(scenic_Fence_Polygon_count >= 10){
				scenic_Fence_Polygon_count = 0;
				local_tts_text_play("您已离开景区！",0,0);
			}
		}else{
			scenic_Fence_Polygon_count = 0;
		}
		if(Rsp_Bigban_Fence_Polygon_area_ID != 0){
			delay_off_count++;
			if(delay_off_count >= jt808_term_param_item.set_term_param.Ban_Fence_Polygon_Delay_OFF){ // 30S
				delay_off_count = 0;
				sys_sta.O_door_lock = 0; // 锁车
				Rsp_locked_condition = 1; // 锁车状态
				local_tts_text_play("已锁车，请联系管理员解除禁止入内限制！",0,0);
			}
			ban_Fence_Polygon_count++;
			if(ban_Fence_Polygon_count >= 10){ // 7S
				ban_Fence_Polygon_count = 0;
				local_tts_text_play("您已进入禁区,请尽快离开！",0,0);
			}
		}else{
			delay_off_count = 0;
			ban_Fence_Polygon_count = 0;
		}
	}
}

void Autoreport_param_Task(void *arg){
	uint32_t count_Sec = 0;// 计数器

	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信息
	jt808_LocReport_add_tail_addi_info(Locked_Condition_ID);

#if 0 // 测试用
	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信息
	jt808_add_tail_fence_Polygon_area(0x0004, 0x0002, 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);
#endif

	while(1){
		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_DEBUG("Bat_Percent:%d,Bat_Voltage:%d,Bat_STA:%X\r\n",BAT_Message.Bat_Percent,BAT_Message.Bat_Voltage,BAT_Message.Bat_STA);
			}else{
				jt808_pkg_send(ID_LocReport,10000/5); // 发送位置信息上报包
			}
		}
		count_Sec++;
		osDelay(1000/5); // 1S
	}
}

// 启动自动上报参数
void jt808_Autoreport_param_start(void){
	if(Autoreport_param_ThreadId == NULL){
		osThreadAttr_t Autoreport_param_task_attr = {
			.name  = "Autoreport_param_Task",
			.stack_size = 4096*4,
			.priority = osPriorityNormal,
		};
		Autoreport_param_ThreadId = osThreadNew((osThreadFunc_t)Autoreport_param_Task, 0, &Autoreport_param_task_attr);
	}else{
		osThreadResume(Autoreport_param_ThreadId); //恢复线程
	}
}

// 停止自动上报参数
void jt808_Autoreport_param_stop(void){
	if(Autoreport_param_ThreadId != NULL){
        osThreadSuspend(Autoreport_param_ThreadId); //挂起线程
    }
}

// 初始化终端参数
void jt808_set_term_param_init(void){
	int ret = 0;
	memset(&jt808_term_param_item,0,sizeof(Term_Param_item_t));
	// 加载围栏区域信息
	if(0 == jt808_get_areafile_state()){
		ret = jt808_load_Fence_area(); 
		JT808_DEBUG("load fence area ret:%d\n", ret);
	}
	do{ // 终端属性参数初始化
		jt808_term_param_item.big_term_attr_resp.term_type = Swap16(0); // 终端类型
		memcpy(jt808_term_param_item.big_term_attr_resp.manufacturer_id, "LAT01", 5); // 制造商ID
		memcpy(jt808_term_param_item.big_term_attr_resp.term_model, jt808_term_param_item.big_reg_info.term_model, 20); // 终端型号
		memcpy(jt808_term_param_item.big_term_attr_resp.term_id, jt808_term_param_item.big_reg_info.term_id, 7); // 终端ID
		memcpy(jt808_term_param_item.big_term_attr_resp.term_ICCID+4, jt808_term_param_item.phone_BCDnum, 6); // 终端手机号码

		char str_hw_ver[] = "1.0.0"; // 硬件版本
		char str_fw_ver[] = "1.0.0"; // 固件版本
		jt808_term_param_item.big_term_attr_resp.hw_ver_len = strlen(str_hw_ver); // 硬件版本长度
		jt808_term_param_item.big_term_attr_resp.fw_ver_len = strlen(str_fw_ver); // 固件版本长度
		memcpy(jt808_term_param_item.big_term_attr_resp.str_hw_ver, str_hw_ver, strlen(str_hw_ver)); // 硬件版本
		memcpy(jt808_term_param_item.big_term_attr_resp.str_fw_ver, str_fw_ver, strlen(str_fw_ver)); // 固件版本
		jt808_term_param_item.big_term_attr_resp.GnssModule_attr = 0x03; // GNSS模块属性
		jt808_term_param_item.big_term_attr_resp.CommModule_attr = 0x01; // 通信模块属性
	}while(0);
	do{// 授权信息初始化
		char str_auth[]="auth code error..."; // 授权码
		jt808_term_param_item.big_auth_info.str_auth_code = jt808_malloc(strlen(str_auth)+1); // 授权码
		if(jt808_term_param_item.big_auth_info.str_auth_code == NULL){
			JT808_DEBUG("malloc auth_code failed\r\n");
		}
		memcpy(jt808_term_param_item.big_auth_info.str_auth_code, str_auth, strlen(str_auth)+1); // 授权码
		JT808_DEBUG("auth_code:%d,%s\r\n",strlen(jt808_term_param_item.big_auth_info.str_auth_code), jt808_term_param_item.big_auth_info.str_auth_code);
		// jt808_free(jt808_term_param_item.big_auth_info.str_auth_code);
		// jt808_term_param_item.big_auth_info.str_auth_code = NULL;
	}while(0);
	do{// 终端参数初始化
		if(0 == jt808_get_TermParam_state()){
			ret = jt808_load_TermParam(); // 加载终端参数
			JT808_DEBUG("load term param ret:%d\n", ret);
		}else{
			jt808_term_param_item.set_term_param.HeartBeatInterval = 30; // 心跳包间隔(秒)
#if 1
			char ServerAddr[] ="47.99.118.34"; // 测试服务器地址
			uint32_t ServerPort = 5000; // 服务器端口
#else
			char ServerAddr[] ="106.14.30.23"; // 生产服务器地址
			uint32_t ServerPort = 5000; // 服务器端口
#endif
			// 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; // 服务器端口
			jt808_term_param_item.set_term_param.DefaultTimeReportInterval = 60; // 默认时间上报间隔(秒)
			jt808_term_param_item.set_term_param.InflexionAngle = 0; // 俯仰角(度)
			jt808_term_param_item.set_term_param.MaxSpeed = 0; // 最大速度(km/h)
			jt808_term_param_item.set_term_param.ProvinceID = 0; // 省域ID
			jt808_term_param_item.set_term_param.CityID = 0; // 市域ID
			jt808_term_param_item.set_term_param.CarPlateNum[0] = 0; // 车牌号码
			jt808_term_param_item.set_term_param.CarPlateColor = 0; // 车牌颜色

			jt808_term_param_item.set_term_param.RadarEN =1; // 雷达使能位, 0 代表关闭, 1 代表开启
			jt808_term_param_item.set_term_param.ManagerACC =100; // 管理员模式油门0~100%
			jt808_term_param_item.set_term_param.TouristACC =50; // 游客模式油门0~100%
			jt808_term_param_item.set_term_param.SpeedCutACC =20; // 自动减速油门0~100%
			jt808_term_param_item.set_term_param.BrakeLimit =1200; //前进刹车距离
			jt808_term_param_item.set_term_param.SpeedCutLimit =2000; // 前进自动减速刹车距离
			jt808_term_param_item.set_term_param.BrakeLimit_B =1200; // 后退刹车距离
			jt808_term_param_item.set_term_param.SpeedCutLimit_B =2000; // 后退自动减速刹车距离
			jt808_term_param_item.set_term_param.Ban_Fence_Polygon_Delay_OFF =30; // 禁止围栏延时锁车时间
			jt808_save_TermParam(); // 保存终端参数
		}
	}while(0);
	do{// 位置信息上报初始化
		memset(&jt808_term_param_item.big_loc_report.basic_info,0,sizeof(Loc_basic_info_t));
		jt808_term_param_item.big_loc_report.basic_info.status.val32 = 0; // 状态信息
		jt808_term_param_item.big_loc_report.basic_info.alarm_flag.val32 = 0; // 报警标志
	}while(0);
	do{ // 设置终端手机号
		char cm_iccid[32] = {0};
		char get_iccid_ok = 0;
		int error_count = 0;
		while(error_count <= 20) {
			memset(cm_iccid, 0, sizeof(cm_iccid));
			get_iccid_ok = 0;
			cm_sim_get_iccid(cm_iccid);
			// 统计有效字符
			for(int i = strlen(cm_iccid) - 1; i >= 8; i--) {
				if(cm_iccid[i] >= '0' && cm_iccid[i] <= '9') {
					get_iccid_ok++;
				}else{
					break;
				}
			}
			JT808_DEBUG("get_iccid_ok:%d\n",get_iccid_ok);
			if(get_iccid_ok == 12){ // IC CID 获取成功
				JT808_DEBUG("iccid:%d,:%s\n",strlen(cm_iccid), cm_iccid);
				rawStrToBcd(jt808_term_param_item.phone_BCDnum, (uint8_t *)(cm_iccid+8), 12); // 终端手机号码
				break; 
			}else{
				error_count++;
				JT808_DEBUG("get iccid failed count:%d\n",error_count);
			}
			osDelay(1000 / 5);  // 根据需求设置延时
		}

		jt808_term_param_item.msg_flow_num =0;
		JT808_DEBUG("phone_BCDnum:");
		for(int i=0;i<6;i++){
			JT808_DEBUG_DATA("%02X ",jt808_term_param_item.phone_BCDnum[i]);
		}
		JT808_DEBUG_DATA("\n");
	}while(0);
	do{// 注册信息初始化
		char read_buf[35] = {0};
		
		jt808_term_param_item.big_reg_info.province_id = Swap16(0); // 省域ID
		jt808_term_param_item.big_reg_info.city_id = Swap16(0); // 市域ID
		memcpy(jt808_term_param_item.big_reg_info.manufacturer_id, "LAT01", 5); // 制造商ID
		
		while(0 != cm_sys_get_sn(read_buf)){
			JT808_DEBUG("get sn failed\n");
			osDelay(1000/5);
		}
		JT808_DEBUG("SN:%s\n", read_buf);
		memcpy(jt808_term_param_item.big_reg_info.term_model, read_buf, 20); // 终端型号

		while(0 != cm_sys_get_imei(read_buf)){
			JT808_DEBUG("get imei failed\n");
			osDelay(1000/5);
		}
		JT808_DEBUG("IMEI:%s\n", read_buf);
		memcpy(jt808_term_param_item.big_reg_info.term_id, read_buf, 7); // 终端ID

		jt808_term_param_item.big_reg_info.car_plate_color = blue_plate; // 车牌颜色

		char CarPlateNum[] ="京A12345"; // 车牌号码
		memcpy(jt808_term_param_item.big_reg_info.car_plate_num, CarPlateNum, strlen(CarPlateNum)); // 车牌号码
	}while(0);
	PrsResult.term_param_item =&jt808_term_param_item;// 全局变量指针指向终端参数项

	// JT808_DEBUG("auth_code:%s\r\n",PrsResult.term_param_item->big_auth_info.str_auth_code);
}

// 释放终端参数
void jt808_set_term_param_free(void){
	if(jt808_term_param_item.big_auth_info.str_auth_code != NULL){ // 释放授权码
		jt808_free(jt808_term_param_item.big_auth_info.str_auth_code);
		jt808_term_param_item.big_auth_info.str_auth_code = NULL;
	}
	if(jt808_term_param_item.big_specific_params.param_id_list != NULL){ // 释放特定参数列表
		jt808_free(jt808_term_param_item.big_specific_params.param_id_list);
		jt808_term_param_item.big_specific_params.param_id_list = NULL;
	}
	if(jt808_term_param_item.big_ctrl_info.str_cmd_params != NULL){ // 释放控制命令参数
		jt808_free(jt808_term_param_item.big_ctrl_info.str_cmd_params);
		jt808_term_param_item.big_ctrl_info.str_cmd_params = NULL;
	}
	if(jt808_term_param_item.big_upgrade_info.str_upgrade_pkg != NULL){ // 释放残留升级包内存
		jt808_free(jt808_term_param_item.big_upgrade_info.str_upgrade_pkg);
		jt808_term_param_item.big_upgrade_info.str_upgrade_pkg = NULL;
	}
	if(jt808_term_param_item.big_upgrade_info.str_ver != NULL){ // 释放升级版本号
		jt808_free(jt808_term_param_item.big_upgrade_info.str_ver);
		jt808_term_param_item.big_upgrade_info.str_ver = NULL;
	}
	Loc_addi_info_t *p_addi_info; // 附加信息
	Loc_addi_info_t *p_addi_info_next; // 附加信息下一个节点
	p_addi_info = jt808_term_param_item.big_loc_report.addi_info;
	p_addi_info_next =  p_addi_info->next;
	while(p_addi_info != NULL){ // 释放附加信息列表
		jt808_free(p_addi_info);
		p_addi_info = p_addi_info_next;
		if(p_addi_info != NULL){
			p_addi_info_next =  p_addi_info->next;
		}
	}
	PrsResult.term_param_item = NULL;
}