kkkjtr
/
4G_module
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

添加电子围栏功能，修复超过128字节系统重启问题 zsxfly20240226

This commit is contained in:
zsx 2025-02-26 17:10:45 +08:00
parent 75c7721ef6
commit c54390661c
14 changed files with 525 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
custom/control_out/inc/control_out.h
View File

@ -2,6 +2,8 @@
#define __CONTROL_OUT_H__ #define __CONTROL_OUT_H__
#include "cm_os.h" #include "cm_os.h"
#include "cm_gpio.h" #include "cm_gpio.h"
#include "jt808_set_TermParam.h"
#define BAT_SxP1 4 // 电池四串一并 #define BAT_SxP1 4 // 电池四串一并
#define BAT_VOLT(_Volt) (_Volt * BAT_SxP1) //电压单位转换 #define BAT_VOLT(_Volt) (_Volt * BAT_SxP1) //电压单位转换
@ -56,7 +58,7 @@ typedef struct BAT_Message{
uint16_t Deep_ACC_Time; // 深踩油门时间 uint16_t Deep_ACC_Time; // 深踩油门时间
} BAT_Message_t; } BAT_Message_t;
#if 0 #if 1
#define ACC_RES_UP 10000 #define ACC_RES_UP 10000
#define ACC_RES_DOWN 3300 #define ACC_RES_DOWN 3300
@ -87,27 +89,35 @@ typedef enum{
IO_TX_BRAKE = CM_GPIO_NUM_4, // 刹车 IO_TX_BRAKE = CM_GPIO_NUM_4, // 刹车
}control_io_t; }control_io_t;
typedef struct{ // typedef struct{
union{ // union{
uint16_t VERSION; // 软件版本号 // uint16_t VERSION; // 软件版本号
struct{ // struct{
uint16_t SW_version:11; // 软件版本序号 // uint16_t SW_version:11; // 软件版本序号
uint16_t HW_version:4; // 硬件版本序号 // uint16_t HW_version:4; // 硬件版本序号
uint16_t VER_type:1; // 当前固件类型0：0x04000；1：0x20000 // uint16_t VER_type:1; // 当前固件类型0：0x04000；1：0x20000
}; // };
}; // };
uint8_t Modbus_addr; // MODBUS地址 // uint8_t Modbus_addr; // MODBUS地址
uint8_t Manager_sLim; // 管理员模式油门极限(Unit:%) // uint8_t Manager_sLim; // 管理员模式油门极限(Unit:%)
uint8_t Tourist_sLim; // 游客模式油门极限 // uint8_t Tourist_sLim; // 游客模式油门极限
uint8_t Speed_Cut_sLim; // 减速油门极限(Unit:%)(自动减速时油门极限) // uint8_t Speed_Cut_sLim; // 减速油门极限(Unit:%)(自动减速时油门极限)
uint16_t Brake_DLimit; // 刹车距离极限(前进)(Unit:mm) // uint16_t Brake_DLimit; // 刹车距离极限(前进)(Unit:mm)
uint16_t Speed_Cut_DLimit; // 减速距离极限 // uint16_t Speed_Cut_DLimit; // 减速距离极限
uint16_t Brake_DLimit_B; // 刹车距离极限(后退) // uint16_t Brake_DLimit_B; // 刹车距离极限(后退)
uint16_t Speed_Cut_DLimit_B;// 减速距离极限 // uint16_t Speed_Cut_DLimit_B;// 减速距离极限
uint16_t CRC16; // 配置信息CRC16校验码 // uint16_t CRC16; // 配置信息CRC16校验码
}SYS_CONF_t; // }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{ typedef struct{
union{// 输入输出状态 union{// 输入输出状态

39
custom/control_out/src/control_out.c
View File

@ -23,18 +23,18 @@
osThreadId_t control_out_TaskHandle = NULL; osThreadId_t control_out_TaskHandle = NULL;
SYS_CONF_t sys_conf ={ // SYS_CONF_t sys_conf ={
.SW_version = 1, // .SW_version = 1,
.HW_version = 1, // .HW_version = 1,
.VER_type = 1, // .VER_type = 1,
.Manager_sLim =100, // .Manager_sLim =100,
.Tourist_sLim =50, // .Tourist_sLim =50,
.Speed_Cut_sLim =20, // .Speed_Cut_sLim =20,
.Brake_DLimit =1200, // .Brake_DLimit =1200,
.Speed_Cut_DLimit =2000, // .Speed_Cut_DLimit =2000,
.Brake_DLimit_B =1200, // .Brake_DLimit_B =1200,
.Speed_Cut_DLimit_B =2000, // .Speed_Cut_DLimit_B =2000,
}; // };
sys_sta_t sys_sta; sys_sta_t sys_sta;
typedef enum { typedef enum {
@ -133,6 +133,8 @@ uint8_t pmu_voltage_to_percent(uint32_t volt){//电压转百分比
static uint32_t back_timecount = 0; static uint32_t back_timecount = 0;
static uint8_t door_lock_last_status = 0; static uint8_t door_lock_last_status = 0;
static uint8_t S_MODE_last_status = 1; static uint8_t S_MODE_last_status = 1;
static uint8_t P_MODE_last_status = 1;
BAT_Message_t BAT_Message; BAT_Message_t BAT_Message;
@ -241,16 +243,17 @@ void control_out_task(void *argument){
local_tts_text_play("行程结束，祝您生活愉快",0,0); 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; 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)){ // 管理模式 if((0 == sys_sta.MAG_MODE)||(0 == sys_sta.PLT_MODE)){ // 管理模式
DEBUG("\n\nMAG_MODE\r\n\n"); DEBUG("\n\nMAG_MODE\r\n\n");
// local_tts_set(5, 7, CM_LOCAL_TTS_DIGIT_AUTO); // local_tts_set(5, 7, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("管理员模式",0,1); local_tts_text_play("管理员模式",0,0);
}else{ // 退出管理员模式 }else{ // 退出管理员模式
DEBUG("\n\nPLT_MODE\r\n\n"); DEBUG("\n\nPLT_MODE\r\n\n");
// local_tts_set(10, 7, CM_LOCAL_TTS_DIGIT_AUTO); // 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; uint8_t acc_percent =0;
if((1 == sys_sta.MAG_MODE)&&(1 == sys_sta.PLT_MODE )){ // 游客模式 if((1 == sys_sta.MAG_MODE)&&(1 == sys_sta.PLT_MODE )){ // 游客模式
if(sys_sta.A_Speed_Cut){ // 自动减速 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{ }else{
acc_percent = (in_acc_percent * sys_conf.Tourist_sLim) / 100.0; acc_percent = (in_acc_percent * SYS_CONF_TOURIST_ACC) / 100.0;
} }
}else{ // 管理员模式 }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); set_out_acc_percent(acc_percent);
// DEBUG("acc_percent:%d\r\n",acc_percent); // DEBUG("acc_percent:%d\r\n",acc_percent);

29
custom/jt808/inc/jt808_electronic_fence.h Normal file
View File

@ -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

24
custom/jt808/inc/jt808_protocol.h
View File

@ -28,6 +28,8 @@ typedef enum {
ID_TxtMsgdelivery = 0x8300, // 文本信息下发 ID_TxtMsgdelivery = 0x8300, // 文本信息下发
ID_Car_Ctrl = 0x8500, // 车辆控制 ID_Car_Ctrl = 0x8500, // 车辆控制
ID_Car_CtrlResp = 0x0500, // 车辆控制应答 ID_Car_CtrlResp = 0x0500, // 车辆控制应答
ID_Set_Polygon_area = 0x8604, // 设置多边形区域
ID_Delete_Polygon_area = 0x8605, // 删除多边形区域
ID_Data_Down = 0x8900, // 数据透传下行 ID_Data_Down = 0x8900, // 数据透传下行
ID_Data_Up = 0x0900, // 数据透传上行 ID_Data_Up = 0x0900, // 数据透传上行
}MessageID_t; }MessageID_t;
@ -295,6 +297,28 @@ typedef struct {
uint8_t *TxtString; // 文本信息字符串 uint8_t *TxtString; // 文本信息字符串
}TxtMsgdelivery_t; }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） // 数据透传体（0x8900/0x0900）
typedef struct { typedef struct {
uint8_t Msg_type; // 数据类型 uint8_t Msg_type; // 数据类型

45
custom/jt808/inc/jt808_set_TermParam.h
View File

@ -2,20 +2,30 @@
#define JT808_SET_TERM_PARAM_H_ #define JT808_SET_TERM_PARAM_H_
#include "jt808_protocol.h" #include "jt808_protocol.h"
#include "jt808_config.h" #include "jt808_config.h"
#include "jt808_electronic_fence.h"
#pragma pack(1) #pragma pack(1)
// 终端参数设置项参数ID // 终端参数设置项参数ID
typedef enum { typedef enum {
HeartBeatInterval = 0x0001,// DWORD, 终端心跳发送间隔(s) ID_HeartBeatInterval = 0x0001, // DWORD, 终端心跳发送间隔(s)
MainServerAddr = 0x0013,//STRING, 主服务器地址,IP 或域名 ID_MainServerAddr = 0x0013, //STRING, 主服务器地址,IP 或域名
ServerPort = 0x0018,//DWORD, 服务器 TCP 端口 ID_ServerPort = 0x0018, //DWORD, 服务器 TCP 端口
DefaultTimeReportInterval = 0x0029,// DWORD, 缺省时间汇报间隔 ID_DefaultTimeReportInterval = 0x0029, // DWORD, 缺省时间汇报间隔
InflexionAngle = 0x0030,// DWORD, 拐点补传角度, < 180° ID_InflexionAngle = 0x0030, // DWORD, 拐点补传角度, < 180°
MaxSpeed = 0x0055,// DWORD, 最高速度, km/h. ID_MaxSpeed = 0x0055, // DWORD, 最高速度, km/h.
ProvinceID = 0x0081,// WORD, 车辆所在的省域 ID ID_ProvinceID = 0x0081, // WORD, 车辆所在的省域 ID
CityID = 0x0082,// WORD, 车辆所在的市域 ID ID_CityID = 0x0082, // WORD, 车辆所在的市域 ID
CarPlateNum = 0x0083,//STRING, 公安交通管理部门颁发的机动车号牌 ID_CarPlateNum = 0x0083, //STRING, 公安交通管理部门颁发的机动车号牌
CarPlateColor = 0x0084,//车牌颜色，按照 JT/T415-2006 的 5.4.12 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; }set_TermParamID_t;
typedef struct{ typedef struct{
uint32_t HeartBeatInterval;// DWORD, 终端心跳发送间隔(s) uint32_t HeartBeatInterval;// DWORD, 终端心跳发送间隔(s)
@ -28,6 +38,15 @@ typedef struct{
uint16_t CityID;// WORD, 车辆所在的市域 ID uint16_t CityID;// WORD, 车辆所在的市域 ID
uint8_t CarPlateNum[10];//STRING, 公安交通管理部门颁发的机动车号牌 uint8_t CarPlateNum[10];//STRING, 公安交通管理部门颁发的机动车号牌
uint8_t CarPlateColor;//车牌颜色，按照 JT/T415-2006 的 5.4.12 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; }set_TermParam_t;
// 支持的附加消息ID // 支持的附加消息ID
@ -47,6 +66,8 @@ typedef enum{
CustomInformationLengthID = 0xE0,// 后续自定义信息长度, BYTE CustomInformationLengthID = 0xE0,// 后续自定义信息长度, BYTE
BAT_VoltageID = 0xE1, // 电池电压, 0.1V WORD BAT_VoltageID = 0xE1, // 电池电压, 0.1V WORD
BAT_PercentageID = 0xE2, // 电池电量, % BYTE BAT_PercentageID = 0xE2, // 电池电量, % BYTE
Scenic_Fence_Polygon_area_ID = 0xE3, // 当前位置所在景区围栏多边形区域ID, DWORD
Ban_Fence_Polygon_area_ID = 0xE4, // 当前位置所在禁止围栏多边形区域ID, DWORD
}addi_infoID_t; }addi_infoID_t;
// big_标记的参数需以大端方式存储，需手动转换为大端 // big_标记的参数需以大端方式存储，需手动转换为大端
@ -62,6 +83,7 @@ typedef struct {// 终端参数项
Term_Upgrade_t big_upgrade_info; // 解析出的升级信息 Term_Upgrade_t big_upgrade_info; // 解析出的升级信息
LocReport_t big_loc_report; // 位置信息汇报 LocReport_t big_loc_report; // 位置信息汇报
LocTrackingCtrl_t big_loc_tracking_ctrl; // 临时位置跟踪控制 LocTrackingCtrl_t big_loc_tracking_ctrl; // 临时位置跟踪控制
fence_Polygon_area_t *fence_polygon_area; // 围栏多边形区域
Data_SeriaNet_t big_data_up_SeriaNet; // 数据上行透传 Data_SeriaNet_t big_data_up_SeriaNet; // 数据上行透传
}Term_Param_item_t; }Term_Param_item_t;
#pragma pack() #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); 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); void jt808_Autoreport_param_start(void);

10
custom/jt808/jt808.mk
View File

@ -1,19 +1,11 @@
CUSTOM_MAIN_DIR := custom/jt808 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_util.c
OC_FILES += $(CUSTOM_MAIN_DIR)/src/jt808_msg_pkg.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_msg_parse.c
OC_FILES += $(CUSTOM_MAIN_DIR)/src/jt808_pkg_transmit.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_set_TermParam.c
OC_FILES += $(CUSTOM_MAIN_DIR)/src/jt808_electronic_fence.c
INC += -I'$(CUSTOM_MAIN_DIR)/inc' INC += -I'$(CUSTOM_MAIN_DIR)/inc'

174
custom/jt808/src/jt808_electronic_fence.c Normal file
View File

@ -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;
}

42
custom/jt808/src/jt808_msg_parse.c
View File

@ -1,6 +1,7 @@
#include "jt808_msg_parse.h" #include "jt808_msg_parse.h"
#include "jt808_pkg_transmit.h" #include "jt808_pkg_transmit.h"
#include "local_tts.h" #include "local_tts.h"
#include "jt808_electronic_fence.h"
PrsResult_t PrsResult; PrsResult_t PrsResult;
@ -39,13 +40,13 @@ static int jt808_BodyParse(void *Prsmsg_body, PrsResult_t *Result){
} }
case ID_SetTermParams:{// 设置终端参数 case ID_SetTermParams:{// 设置终端参数
Result->term_param_item->big_specific_params.param_Total_num = ((uint8_t *)Prsmsg_body)[0]; // 总参数个数 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++){ 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 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 *)(Prsmsg_body + param_lenoffset + 5), // 参数值 (void *)(p_Prsmsg_body + 5), // 参数值
*((uint8_t*)(Prsmsg_body + param_lenoffset + 4))); // 参数长度 p_Prsmsg_body[4]); // 参数长度
param_lenoffset += 5 + (*((uint8_t*)(Prsmsg_body + param_lenoffset + 4))); // 参数ID(4) + 参数长度(1) + 参数值(n) p_Prsmsg_body += 5 + p_Prsmsg_body[4]; // 参数ID(4) + 参数长度(1) + 参数值(n)
} }
Result->Rsp_flow_num = Result->msg_head.msg_flow_num; Result->Rsp_flow_num = Result->msg_head.msg_flow_num;
Result->Rsp_msg_id = Result->msg_head.msg_id; 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);// 发送车辆控制应答，设置本消息无发送应答 jt808_pkg_send(ID_Car_CtrlResp, 0);// 发送车辆控制应答，设置本消息无发送应答
break; 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:{// 数据下行透传 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); // 透传数据 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; Result->Rsp_flow_num = Result->msg_head.msg_flow_num;

6
custom/jt808/src/jt808_msg_pkg.c
View File

@ -106,6 +106,7 @@ static int jt808_BodyPackage(JT808_2013_MsgFrame_t *p_MsgFrame, MessageID_t Msg_
break; break;
} }
case ID_LocReport:{ // 位置信息汇报 case ID_LocReport:{ // 位置信息汇报
jt808_LocReport_param_update(); // 更新位置信息参数
p_MsgFrame->msg_head.msgbody_attr.msgbodylen = sizeof(Loc_basic_info_t);// 消息体长度 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; Loc_addi_info_t *p_loc_addi_info = PrsResult.term_param_item->big_loc_report.addi_info;
while(p_loc_addi_info != NULL){ // 计算附加信息长度 while(p_loc_addi_info != NULL){ // 计算附加信息长度
@ -142,7 +143,7 @@ static int jt808_BodyPackage(JT808_2013_MsgFrame_t *p_MsgFrame, MessageID_t Msg_
break; break;
} }
case ID_Car_CtrlResp:{ // 车辆控制应答 case ID_Car_CtrlResp:{ // 车辆控制应答
jt808_LocReport_param_update(); // 更新位置信息参数
p_MsgFrame->msg_head.msgbody_attr.msgbodylen =2 + sizeof(Loc_basic_info_t);// 消息体长度 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; Loc_addi_info_t *p_loc_addi_info = PrsResult.term_param_item->big_loc_report.addi_info;
while(p_loc_addi_info != NULL){ // 计算附加信息长度 while(p_loc_addi_info != NULL){ // 计算附加信息长度
@ -192,10 +193,11 @@ static int jt808_BodyPackage(JT808_2013_MsgFrame_t *p_MsgFrame, MessageID_t Msg_
// JT808_DEBUG("ID_Data_Up\r\n"); // JT808_DEBUG("ID_Data_Up\r\n");
break; break;
} }
default: default:{
return -2; return -2;
break; break;
} }
}
return 0; return 0;
} }

153
custom/jt808/src/jt808_set_TermParam.c
View File

@ -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){ int jt808_setTermParam(set_TermParamID_t param_id, void *param, uint8_t param_len){
switch(param_id){ switch(param_id){
case HeartBeatInterval:{ case ID_HeartBeatInterval:{
jt808_term_param_item.set_term_param.HeartBeatInterval =Swap32(*(uint32_t*)param); jt808_term_param_item.set_term_param.HeartBeatInterval =Swap32(*(uint32_t*)param);
break; break;
} }
case MainServerAddr:{ case ID_MainServerAddr:{
memcpy(jt808_term_param_item.set_term_param.MainServerAddr,param,50<param_len?param_len:50); memcpy(jt808_term_param_item.set_term_param.MainServerAddr,param,50<param_len?param_len:50);
break; break;
} }
case ServerPort:{ case ID_ServerPort:{
jt808_term_param_item.set_term_param.ServerPort =Swap32(*(uint32_t*)param); jt808_term_param_item.set_term_param.ServerPort =Swap32(*(uint32_t*)param);
break; break;
} }
case DefaultTimeReportInterval:{ case ID_DefaultTimeReportInterval:{
jt808_term_param_item.set_term_param.DefaultTimeReportInterval =Swap32(*(uint32_t*)param); jt808_term_param_item.set_term_param.DefaultTimeReportInterval =Swap32(*(uint32_t*)param);
break; break;
} }
case InflexionAngle:{ case ID_InflexionAngle:{
jt808_term_param_item.set_term_param.InflexionAngle =Swap32(*(uint32_t*)param); jt808_term_param_item.set_term_param.InflexionAngle =Swap32(*(uint32_t*)param);
break; break;
} }
case MaxSpeed:{ case ID_MaxSpeed:{
jt808_term_param_item.set_term_param.MaxSpeed =Swap32(*(uint32_t*)param); jt808_term_param_item.set_term_param.MaxSpeed =Swap32(*(uint32_t*)param);
break; break;
} }
case ProvinceID:{ case ID_ProvinceID:{
jt808_term_param_item.set_term_param.ProvinceID =Swap16(*(uint16_t*)param); jt808_term_param_item.set_term_param.ProvinceID =Swap16(*(uint16_t*)param);
break; break;
} }
case CityID:{ case ID_CityID:{
jt808_term_param_item.set_term_param.CityID =Swap16(*(uint16_t*)param); jt808_term_param_item.set_term_param.CityID =Swap16(*(uint16_t*)param);
break; break;
} }
case CarPlateNum:{ case ID_CarPlateNum:{
memcpy(jt808_term_param_item.set_term_param.CarPlateNum,param,10<param_len?param_len:10); memcpy(jt808_term_param_item.set_term_param.CarPlateNum,param,10<param_len?param_len:10);
break; break;
} }
case CarPlateColor:{ case ID_CarPlateColor:{
jt808_term_param_item.set_term_param.CarPlateColor =((uint8_t*)param)[0]; jt808_term_param_item.set_term_param.CarPlateColor =((uint8_t*)param)[0];
break; 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:{ default:{
// TODO: 未知参数 // TODO: 未知参数
return -1; 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); p_head->msg = (void *)(&BAT_Message.Bat_Percent);
break; 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:{ default:{
// TODO: 未知消息ID // TODO: 未知消息ID
jt808_free(p_head); jt808_free(p_head);
@ -204,18 +248,18 @@ void jt808_LocReport_remove_addi_info(uint8_t msg_id){
osThreadFunc_t Autoreport_param_ThreadId; osThreadFunc_t Autoreport_param_ThreadId;
void Autoreport_param_Task(void *arg){ // 更新自动上报参数
uint32_t count_Sec = 0;// 计数器 void jt808_LocReport_param_update(void){
nmeaTIME beiJingTime; // 北京时间 nmeaTIME beiJingTime; // 北京时间
jt808_LocReport_add_tail_addi_info(BAT_VoltageID); // 增加电池电压信息
jt808_LocReport_add_tail_addi_info(BAT_PercentageID); // 增加电池电量信息
while(1){
// TODO: 自动上报参数 // TODO: 自动上报参数
// 1. 位置基本信息 // 1. 位置基本信息
GMTconvert(&gps_data.info.utc, &beiJingTime, 8, 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]格式 // 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.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.longitude = Swap32(nmea_ndeg2degree(gps_data.info.lon) * 1e6);
@ -248,13 +292,72 @@ void Autoreport_param_Task(void *arg){
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.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_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;// 计数器
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){
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:有故障 // 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(0 == (count_Sec % jt808_term_param_item.set_term_param.HeartBeatInterval)){
if((gps_data.info.fix == 1)||(gps_data.info.sig == 0)){ // 不可用// 未定位时发送心跳包 if((gps_data.info.fix == 1)||(gps_data.info.sig == 0)){ // 不可用// 未定位时发送心跳包
jt808_pkg_send(ID_Term_HB,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{ }else{
jt808_pkg_send(ID_LocReport,10000/5); // 发送位置信息上报包 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; // jt808_term_param_item.big_auth_info.str_auth_code = NULL;
}while(0); }while(0);
do{// 终端参数初始化 do{// 终端参数初始化
jt808_term_param_item.set_term_param.HeartBeatInterval = 3; // 心跳包间隔(秒) jt808_term_param_item.set_term_param.HeartBeatInterval = 30; // 心跳包间隔(秒)
char ServerAddr[] ="47.99.118.34"; // 车牌号码 char ServerAddr[] ="47.99.118.34"; // 服务器地址
uint32_t ServerPort = 5000; // 服务器端口 uint32_t ServerPort = 5000; // 服务器端口
// char ServerAddr[] ="36.137.226.30"; // 车牌号码 // char ServerAddr[] ="106.14.30.23"; // 服务器地址
// uint32_t ServerPort = 36204; // 服务器端口 // uint32_t ServerPort = 5000; // 服务器端口
// memset(jt808_term_param_item.set_term_param.MainServerAddr, 0, 50); // memset(jt808_term_param_item.set_term_param.MainServerAddr, 0, 50);
memcpy(jt808_term_param_item.set_term_param.MainServerAddr, ServerAddr, strlen(ServerAddr)+1); // 主服务器地址 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.ServerPort = ServerPort; // 服务器端口

2
custom/local_tts/src/local_tts.c
View File

@ -185,7 +185,7 @@ static osThreadFunc_t local_tts_play_task(void *arg){
// DEBUG("tts task: 1111111111\n\n"); // DEBUG("tts task: 1111111111\n\n");
// if(0 == tts_play_queue.en_interruptible){ // 不允许被打断播放 // if(0 == tts_play_queue.en_interruptible){ // 不允许被打断播放
// DEBUG("tts task: 2222222222\n\n"); // 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){ if(osOK != ret){
DEBUG("local_tts_play_ok_sem:%d\n", ret); DEBUG("local_tts_play_ok_sem:%d\n", ret);
} }

4
custom/radar/src/radar.c
View File

@ -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 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((35 < Car_Distance) && Car_Distance < Brake_Distance){//小于自动刹车距离时
if(!sys_sta.A_brake){ if(!sys_sta.A_brake){

10
custom/tcp_client/src/tcp_client.c
View File

@ -25,12 +25,14 @@ static osThreadId_t tcp_recv_ThreadId = NULL;
static osThreadId_t net_manage_ThreadId = NULL; static osThreadId_t net_manage_ThreadId = NULL;
osSemaphoreId_t netconn_disconnect_sem = NULL; // 断开连接信号量 osSemaphoreId_t netconn_disconnect_sem = NULL; // 断开连接信号量
#define RECV_MAX_LEN (1024) // 接收最大长度
// TCP接收线程 // TCP接收线程
static void tcp_recv_task(void){ static void tcp_recv_task(void){
int ret = 0; int ret = 0;
fd_set sets; fd_set sets;
struct timeval timeout; struct timeval timeout;
uint8_t buf[128] = {0}; uint8_t buf[RECV_MAX_LEN] = {0};
while(1){ while(1){
FD_ZERO(&sets); FD_ZERO(&sets);
@ -49,7 +51,10 @@ static void tcp_recv_task(void){
// app_printf("%02x ", buf[i]); // app_printf("%02x ", buf[i]);
// } // }
// app_printf("\n\n"); // 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); jt808_pkg_handle(buf, ret);
memset(buf, 0, sizeof(buf)); memset(buf, 0, sizeof(buf));
@ -205,6 +210,7 @@ TCP_DISABLE:
} }
} }
jt808_pkg_send(ID_GetTermAttrResp, 0); // 发送终端属性查询应答包
jt808_Autoreport_param_start();//开启自动上报参数设置 jt808_Autoreport_param_start();//开启自动上报参数设置
led_set_event(EVENT_NETWORK_READY); // 网络连接成功 led_set_event(EVENT_NETWORK_READY); // 网络连接成功
DEBUG("NetwarK connected!\r\n"); DEBUG("NetwarK connected!\r\n");