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

create repository

This commit is contained in:
wjw 2025-07-10 10:01:23 +08:00
parent 21790a8b22
commit 0fadd0ac31
16 changed files with 317 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
custom/GPS/inc/gps_config.h
View File

@ -6,7 +6,10 @@
typedef struct{ typedef struct{
uint16_t flow_num; // 流水号 uint16_t flow_num; // 流水号
nmeaINFO info; // GPS信息 nmeaINFO info; // GPS信息
nmeaPOS dpos; // 经纬度 //nmeaPOS dpos; // 经纬度
osMutexId_t mutex; // 互斥锁
double longitude; // 经度
double latitude; // 纬度
} gps_data_t; } gps_data_t;
extern gps_data_t gps_data; extern gps_data_t gps_data;

23
custom/GPS/src/gps_config.c
View File

@ -14,7 +14,7 @@
#include "gps_config.h" #include "gps_config.h"
#include "local_tts.h" #include "local_tts.h"
#if 0 #if 1
#include "app_uart.h" #include "app_uart.h"
#define DEBUG(fmt, args...) app_printf("[GPS]" fmt, ##args) #define DEBUG(fmt, args...) app_printf("[GPS]" fmt, ##args)
#else #else
@ -68,6 +68,15 @@ void error(const char *str, int str_size){
gps_data_t gps_data; gps_data_t gps_data;
static nmeaPARSER parser; static nmeaPARSER parser;
//将度分格式转为十进制度
double dm_to_dd(double dm) {
int deg = (int)(dm / 100);
double min = dm - deg * 100;
return deg + min/60;
}
/* 串口接收处理任务，平时使用信号量挂起，当收到接收事件后，释放信号量以触发读取任务 */ /* 串口接收处理任务，平时使用信号量挂起，当收到接收事件后，释放信号量以触发读取任务 */
static void gps_TaskHandle(void *param){ static void gps_TaskHandle(void *param){
int temp_len = 0; int temp_len = 0;
@ -90,11 +99,15 @@ static void gps_TaskHandle(void *param){
temp_len = cm_uart_read(GPS_URAT, (void*)&gps_rev_data[gps_rev_len], GPS_BUF_LEN - gps_rev_len, 1000); temp_len = cm_uart_read(GPS_URAT, (void*)&gps_rev_data[gps_rev_len], GPS_BUF_LEN - gps_rev_len, 1000);
gps_rev_len += temp_len; gps_rev_len += temp_len;
if(gps_rev_len > 370){ if(gps_rev_len > 370){
osMutexAcquire(gps_data.mutex, osWaitForever);
nmea_parse(&parser, gps_rev_data, gps_rev_len, &gps_data.info); nmea_parse(&parser, gps_rev_data, gps_rev_len, &gps_data.info);
nmea_info2pos(&gps_data.info, &gps_data.dpos); gps_data.longitude=dm_to_dd(gps_data.info.lon);
gps_data.latitude=dm_to_dd(gps_data.info.lat);
osMutexRelease(gps_data.mutex);
//nmea_info2pos(&gps_data.info, &gps_data.dpos);
gps_data.flow_num++; gps_data.flow_num++;
DEBUG("%03d,Lat:%.02f,Lon:%.02f,Sig:%d,Fix:%d,RL=%d\n", DEBUG("%03d,Lat:%.09f,Lon:%.09f,Sig:%d,Fix:%d,RL=%d\n\n",
it++, gps_data.info.lat, gps_data.info.lon, gps_data.info.sig, gps_data.info.fix, gps_rev_len it++, gps_data.latitude, gps_data.longitude, gps_data.info.sig, gps_data.info.fix, gps_rev_len
); );
if((gps_data.info.fix == 1)||(gps_data.info.sig == 0)){ // 不可用 if((gps_data.info.fix == 1)||(gps_data.info.sig == 0)){ // 不可用
@ -187,6 +200,8 @@ void gps_config_init(void){
gps_task_attr.stack_size = 4096 * 4; gps_task_attr.stack_size = 4096 * 4;
gps_task_attr.priority= osPriorityNormal; gps_task_attr.priority= osPriorityNormal;
gps_data.mutex = osMutexNew(NULL); // 创建互斥锁
GPS_ThreadId= osThreadNew(gps_TaskHandle, 0, &gps_task_attr); GPS_ThreadId= osThreadNew(gps_TaskHandle, 0, &gps_task_attr);
if(gps_uart_sem == NULL) { if(gps_uart_sem == NULL) {

17
custom/attr_broadcast/inc/attr_broadcast.h
View File

@ -4,6 +4,9 @@
#include "nmea/nmea.h" #include "nmea/nmea.h"
#define DEBUG(fmt, arg...)
// 景点信息 // 景点信息
typedef struct { typedef struct {
double longitude; // 经度 double longitude; // 经度
@ -13,6 +16,20 @@ typedef struct {
} Attraction; } Attraction;
//位置信息
typedef struct {
double longitude;
double latitude;
} Location;
extern const char *park_desc[];
//多文字tts，景区播报专用
void safe_tts_play(const char* segments[], int count);
// 初始化景点播报系统 // 初始化景点播报系统
void attr_broadcast_init(void); void attr_broadcast_init(void);

154
custom/attr_broadcast/src/attr_broadcast.c
View File

@ -3,7 +3,6 @@
#include "stdio.h" #include "stdio.h"
#include "stdlib.h" #include "stdlib.h"
#include "stdarg.h" #include "stdarg.h"
#include "stdbool.h"
#include "math.h" #include "math.h"
#include "cm_os.h" #include "cm_os.h"
#include "cm_mem.h" #include "cm_mem.h"
@ -17,9 +16,9 @@
#include "gps_config.h" #include "gps_config.h"
#include "local_tts.h" #include "local_tts.h"
#if 0 #if 1
#include "app_uart.h" #include "app_uart.h"
#define DEBUG(fmt, args...) app_printf("[GPS]" fmt, ##args) #define DEBUG(fmt, args...) app_printf("[Broadcast]" fmt, ##args)
#else #else
#include "app_uart.h" #include "app_uart.h"
#define DEBUG(fmt, ...) #define DEBUG(fmt, ...)
@ -30,17 +29,8 @@
#define DISTANCE_CHANGE_THRESHOLD 10.0 // 距离变化阈值(米) #define DISTANCE_CHANGE_THRESHOLD 10.0 // 距离变化阈值(米)
#define TTS_PRIORITY 5 // TTS播报优先级 #define TTS_PRIORITY 5 // TTS播报优先级
static osMutexId_t attractions_mutex = NULL;
static AttractionNode* attractions_head = NULL;
static BroadcastState broadcast_state = {0};
static osThreadId_t guide_task_id = NULL;
static int tts_speed = 5;
static int tts_volume = 10;
static nmeaPARSER parser; static nmeaPARSER parser;
typedef enum { false, true } bool; // 手动定义布尔类型
// 全局景点链表 // 全局景点链表
typedef struct AttractionNode { typedef struct AttractionNode {
@ -50,16 +40,55 @@ typedef struct AttractionNode {
// 播报状态 // 播报状态
typedef struct { typedef struct {
AttractionNode* last_broadcast; // 上次播报的景点 AttractionNode* last_broadcast;
double last_distance; // 上次播报时的距离 double last_distance;
uint8_t is_playing; // TTS是否正在播放 uint8_t is_playing;
double distance_threshold;
} BroadcastState; } BroadcastState;
//位置信息
typedef struct { typedef int BOOL;
double longitude; #define true 1
double latitude; #define false 0
} Location;
const char *park_desc[] = {
"尊敬的游客欢迎来到顾村公园游玩",
"顾村公园，位于上海市宝山区顾村镇沪太路4788号",
"东起沪太路，西至陈广路,北邻镜泊湖路，南靠外环",
"高速公路,占帝总面积430公顷,其中一期占帝180",
"公顷,二期占帝244.7公顷,顾村公园一期于2007年8月",
"动工建设,二期于2012年10月22日动工建设.公园",
"建设理念为“亲民人文,以生态休闲娱乐为主题.",
"集生态防护、景观观赏、休闲健身、文化娱乐旅游",
"度假等功能于一体,与传统的城市公园形成功能互补",
"并以中心河为界分两期实施。顾村公园为国家4A级",
"景区,上海市科普教育基地、上海市志愿者服务基地等。"
};
static osMutexId_t attractions_mutex = NULL;
static AttractionNode* attractions_head = NULL;
static BroadcastState broadcast_state = {0};
static int tts_speed = 5;
static int tts_volume = 10;
static osThreadId_t Attr_Broadcast_ThreadId = NULL; //串口数据接收、解析任务Handle
//多文字tts，景区播报专用
void safe_tts_play(const char* segments[], int count) {
for(int i = 0; i < count; i++) {
local_tts_text_play(segments[i], 0, 0);
// 等待当前播放完成
while(local_tts_get_play_state() != 0) {
osDelay(100); // 每100ms检查一次
}
osDelay(200); // 额外缓冲
}
}
//计算到景点的距离 //计算到景点的距离
@ -83,14 +112,14 @@ Location location_service_get_current(void) {
Location current = {0}; Location current = {0};
// 加锁保护全局数据 // 加锁保护全局数据
if (osMutexAcquire(gps_mutex, 100) == osOK) { osMutexAcquire(gps_data.mutex, osWaitForever);
// 检查数据是否有效 // 检查数据是否有效
if (gps_data.info.sig > 0 && gps_data.info.fix > 0) { if (gps_data.info.sig > 0 && gps_data.info.fix > 0) {
current.longitude = gps_data.dpos.lon; current.longitude = gps_data.longitude;
current.latitude = gps_data.dpos.lat; current.latitude = gps_data.latitude;
}
osMutexRelease(gps_mutex);
} }
osMutexRelease(gps_data.mutex);
return current; return current;
} }
@ -130,18 +159,6 @@ void attr_broadcast_set_distance_threshold(double threshold) {
} }
} }
//设置tts参数
void attr_broadcast_set_tts_params(int speed, int volume) {
tts_speed = speed;
tts_volume = volume;
if (guide_task_id != NULL) {
// 如果任务已启动，更新TTS参数
local_tts_set(tts_speed, tts_volume, CM_LOCAL_TTS_DIGIT_AUTO);
}
}
// 根据当前位置查找最近的景区节点 // 根据当前位置查找最近的景区节点
static AttractionNode* find_nearest_attraction(Location current_pos) { static AttractionNode* find_nearest_attraction(Location current_pos) {
@ -185,19 +202,36 @@ static void play_attraction_info(AttractionNode* attraction, double distance) {
attraction->attraction.description, attraction->attraction.description,
distance); distance);
broadcast_state.is_playing = 1;
// 调用TTS接口播放文本 // 调用TTS接口播放文本
local_tts_text_play(buffer, 0, 1); local_tts_text_play(buffer, 0, 1);
//等待
while(local_tts_get_play_state() != 0) {
osDelay(100);
}
// 更新播报状态 // 更新播报状态
broadcast_state.last_broadcast = attraction; broadcast_state.last_broadcast = attraction;
broadcast_state.last_distance = distance; broadcast_state.last_distance = distance;
broadcast_state.is_playing = 1;
} }
static void attr_broadcast_task(void* arg) { static void attr_broadcast_task(void* arg) {
(void)arg; // 避免未使用参数警告 (void)arg; // 避免未使用参数警告
BOOL should_play; //是否播放最后判断量
BOOL introduc=true; //是否播报景区介绍
DEBUG("task begin\r\n");
if(0)
{
safe_tts_play(park_desc,11);
introduc=false;
}
while (1) { while (1) {
// 获取当前位置 // 获取当前位置
Location current_pos = location_service_get_current(); Location current_pos = location_service_get_current();
@ -205,6 +239,9 @@ static void attr_broadcast_task(void* arg) {
// 查找最近景点 // 查找最近景点
AttractionNode* nearest = find_nearest_attraction(current_pos); AttractionNode* nearest = find_nearest_attraction(current_pos);
DEBUG("location ok\r\n");
if (nearest != NULL) { if (nearest != NULL) {
// 计算距离 // 计算距离
double distance = location_service_calculate_distance( double distance = location_service_calculate_distance(
@ -212,43 +249,72 @@ static void attr_broadcast_task(void* arg) {
current_pos current_pos
); );
DEBUG("calculate ok\r\n");
// 检查是否在有效范围内 // 检查是否在有效范围内
if (distance <= broadcast_state.distance_threshold) { if (distance <= broadcast_state.distance_threshold) {
// 检查是否需要播报 // 检查是否需要播报
bool should_play = false; should_play = false;
DEBUG("check ok:%d\r\n",should_play);
if (broadcast_state.last_broadcast == NULL) { if (broadcast_state.last_broadcast == NULL) {
should_play = true; // 首次播报 should_play = true; // 首次播报
DEBUG("check ok:%d\r\n",should_play);
} }
else if (broadcast_state.last_broadcast != nearest) { else if (broadcast_state.last_broadcast != nearest) {
should_play = true; // 新景点 should_play = true; // 新景点
}
else if (fabs(distance - broadcast_state.last_distance) > 10.0) {
should_play = true; // 同一景点但距离变化大
}
}
else if (fabs(distance - broadcast_state.last_distance) > 50.0) {
should_play = true; // 同一景点但距离变化大 是否需要播报可以商榷
}
DEBUG("stat ok:%d\r\n",should_play);
// 触发播报 // 触发播报
if (should_play && !broadcast_state.is_playing) { if (should_play && !broadcast_state.is_playing) {
DEBUG("ready to play\r\n");
play_attraction_info(nearest, distance); play_attraction_info(nearest, distance);
broadcast_state.is_playing=0;
DEBUG("play ok\r\n");
} }
} }
DEBUG("dist:%0.3f,threshold:%0.3f\r\n",distance,broadcast_state.distance_threshold);
} }
// 5秒检测一次 // 5秒检测一次
osDelay(5000); osDelay(5000/5);
} }
} }
void attr_broadcast_init(void) { void attr_broadcast_init(void) {
// 初始化互斥锁 // 初始化互斥锁
if (attractions_mutex == NULL) { if (attractions_mutex == NULL) {
attractions_mutex = osMutexNew(NULL); attractions_mutex = osMutexNew(NULL);
} }
//增加初始景点
attr_broadcast_add_attraction(121.364371, 31.343164, "2号门便民处", "测试景点，看起来应该非常的方便游客");
attr_broadcast_add_attraction(121.364270, 31.343103, "2号门归还点", "您好二号门停放点到了，您可以把我归还至这里，并在手机小程序中结束订单，如果");
attr_broadcast_add_attraction(121.364350, 31.342175, "彩虹桥", "测试景点，看起来有很多很多彩虹");
attr_broadcast_add_attraction(121.36799,31.34449, "恐龙乐园正门", "您好自然谷恐龙园到了，这是一个人工搭建的，模拟三叠纪，侏罗纪，白垩纪等时代的恐龙生活场景的乐园，在这里您可以穿梭于恐龙像群，欣赏超前的7D电影，在自然中感受野趣，在怪石和岩洞中穿行，充分体验远古时代洪荒洞窟的神奇刺激和绝妙采用，这里的各类恐龙有着高仿真，活动自如的特性，虫现远古时代恐龙生活打斗等场景，让恐龙如同真的复活，园内霸王龙，三角龙，阿马加龙，剑龙，恐爪龙等几十条恐龙与您零距离接触，带您进入远古霸主的惊险旅程");
attr_broadcast_add_attraction(121.362142,31.340588, "想家桥", "测试景点，看起来非常的让人想要回家");
attr_broadcast_add_attraction(121.362796,31.339624, "3号游船码头", "游客三号游船码头到了，顾村公园浏中湖景区有约10公顷的湖面和沿岸森林湿地");
attr_broadcast_add_attraction(121.36613,31.33925, "樱花广场", "亲爱的游客现在您看到的是顾村公园樱花广场，一寸春心十年相守，为纪念上海樱花节十周");
attr_broadcast_add_attraction(121.366656983, 31.344300423, "集装箱房间", "测试景点，看起来应该非常的方便测试");
// 初始化状态 // 初始化状态
memset(&broadcast_state, 0, sizeof(broadcast_state)); memset(&broadcast_state, 0, sizeof(broadcast_state));
broadcast_state.distance_threshold = 50.0; // 默认阈值50米 broadcast_state.distance_threshold = 50.0; // 默认阈值50米
osThreadAttr_t attr_broadcast_task_attr = {0};
attr_broadcast_task_attr.name = "attr_broadcast_task";
attr_broadcast_task_attr.stack_size = 4096 * 5;
attr_broadcast_task_attr.priority= osPriorityNormal;
Attr_Broadcast_ThreadId= osThreadNew(attr_broadcast_task, 0, &attr_broadcast_task_attr);
} }

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

@ -32,9 +32,9 @@
#define BAT_LEVEL_50PERCENT_VOLT BAT_VOLT(115) // 50% #define BAT_LEVEL_50PERCENT_VOLT BAT_VOLT(115) // 50%
#define BAT_LEVEL_60PERCENT_VOLT BAT_VOLT(117) // 60% #define BAT_LEVEL_60PERCENT_VOLT BAT_VOLT(117) // 60%
#define BAT_LEVEL_70PERCENT_VOLT BAT_VOLT(119) // 70% #define BAT_LEVEL_70PERCENT_VOLT BAT_VOLT(119) // 70%
#define BAT_LEVEL_80PERCENT_VOLT BAT_VOLT(121) // 80% #define BAT_LEVEL_80PERCENT_VOLT BAT_VOLT(123) // 80%
#define BAT_LEVEL_90PERCENT_VOLT BAT_VOLT(123) // 90% #define BAT_LEVEL_90PERCENT_VOLT BAT_VOLT(127) // 90%
#define BAT_LEVEL_100PERCENT_VOLT BAT_VOLT(144) //100% #define BAT_LEVEL_100PERCENT_VOLT BAT_VOLT(134) //100%
// 充电状态 // 充电状态
@ -54,6 +54,7 @@ typedef struct BAT_Message{
uint8_t Bat_Percent; // 42=42% uint8_t Bat_Percent; // 42=42%
uint8_t Bat_Low_Volt_count; // 低压计数 uint8_t Bat_Low_Volt_count; // 低压计数
uint16_t Bat_Voltage; // 480=48.0V uint16_t Bat_Voltage; // 480=48.0V
uint16_t Rsp_BigBat_Voltage;
uint16_t Runing_Time; // 系统运行时间 uint16_t Runing_Time; // 系统运行时间
uint16_t Deep_ACC_Time; // 深踩油门时间 uint16_t Deep_ACC_Time; // 深踩油门时间
} BAT_Message_t; } BAT_Message_t;

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

@ -67,7 +67,7 @@ int32_t get_voltage(adc_chx_t chx){
return 0; return 0;
} }
// cm_gpio_set_level(CM_GPIO_NUM_20, 1); //恢复默认状态 // cm_gpio_set_level(CM_GPIO_NUM_20, 1); //恢复默认状态
DEBUG("CH%d voltage:%d\n",chx ,voltage); // DEBUG("CH%d voltage:%d\n",chx ,voltage);
return voltage; return voltage;
} }
@ -77,10 +77,11 @@ uint32_t ACC_Dmax =(((ACC_OUT_Voltage_MAX*ACC_OUT_RES_DOWN)/(ACC_OUT_RES_UP+ACC_
// 获取输入油门百分比（unit:%)(踏板信号) // 获取输入油门百分比（unit:%)(踏板信号)
uint16_t get_in_acc_percent(void){ uint16_t get_in_acc_percent(void){
uint16_t acc_voltage =get_voltage(ADC_acc); uint16_t acc_voltage =get_voltage(ADC_acc);
DEBUG("acc_voltage:%d\n",acc_voltage); // DEBUG("acc_voltage:%d\n",acc_voltage);
if((acc_voltage < 900) || (acc_voltage > 4100)){ if(acc_voltage < 900){
return 0; return 0;
}else if(acc_voltage > 3800){ }else
if(acc_voltage > 3800){
return 100; return 100;
}else{ }else{
return ((acc_voltage-900)/29); return ((acc_voltage-900)/29);
@ -160,6 +161,9 @@ float temp_bat_voltage=0;
void control_out_task(void *argument){ void control_out_task(void *argument){
cm_gpio_level_e level = 0; cm_gpio_level_e level = 0;
BAT_Message.Bat_Voltage = get_voltage(ADC_power) / 100;
BAT_Message.Rsp_BigBat_Voltage =Swap16(BAT_Message.Bat_Voltage);
BAT_Message.Bat_Percent = pmu_voltage_to_percent(BAT_Message.Bat_Voltage);
while(1){ while(1){
uint16_t in_acc_percent= get_in_acc_percent(); uint16_t in_acc_percent= get_in_acc_percent();
@ -174,6 +178,7 @@ void control_out_task(void *argument){
Voltage_update_count++; Voltage_update_count++;
if(Voltage_update_count >= (1000/_out_UPDETE_TIME)){ // 1s if(Voltage_update_count >= (1000/_out_UPDETE_TIME)){ // 1s
BAT_Message.Bat_Voltage = temp_bat_voltage / Voltage_update_count; BAT_Message.Bat_Voltage = temp_bat_voltage / Voltage_update_count;
BAT_Message.Rsp_BigBat_Voltage =Swap16(BAT_Message.Bat_Voltage);
Voltage_update_count=0; Voltage_update_count=0;
temp_bat_voltage = 0; temp_bat_voltage = 0;
} }
@ -298,14 +303,15 @@ void control_out_task(void *argument){
acc_percent = (in_acc_percent * SYS_CONF_MANAGER_ACC) / 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("in_acc_percent:%d ,acc_percent:%d \r\n",in_acc_percent, acc_percent); // DEBUG("in_acc_percent:%d ,acc_percent:%d \r\n",in_acc_percent, acc_percent);
DEBUG("SYS_CONF_SPEED_CUT_ACC:%d,SYS_CONF_TOURIST_ACC:%d,SYS_CONF_MANAGER_ACC:%d\r\n",SYS_CONF_SPEED_CUT_ACC,SYS_CONF_TOURIST_ACC,SYS_CONF_MANAGER_ACC); // DEBUG("SYS_CONF_SPEED_CUT_ACC:%d,SYS_CONF_TOURIST_ACC:%d,SYS_CONF_MANAGER_ACC:%d\r\n",SYS_CONF_SPEED_CUT_ACC,SYS_CONF_TOURIST_ACC,SYS_CONF_MANAGER_ACC);
// DEBUG("IO_RX_back:%d,IO_TX_brake:%d,PLT_MODE:%d\r\n",sys_sta.IO_RX_back,sys_sta.IO_TX_brake,sys_sta.PLT_MODE);
}else{ }else{
cm_gpio_set_level(OUT_Door_lock, 0); // 关闭电门锁 cm_gpio_set_level(OUT_Door_lock, 0); // 关闭电门锁
set_out_acc_percent(0); set_out_acc_percent(0);
} }
osDelay(_out_UPDETE_TIME/5); // osDelay(_out_UPDETE_TIME/5);
} }
} }

1
custom/custom.mk
View File

@ -11,4 +11,5 @@ include $(CUSTOM_DIR)/tcp_client/tcp_client.mk
include $(CUSTOM_DIR)/control_out/control_out.mk include $(CUSTOM_DIR)/control_out/control_out.mk
include $(CUSTOM_DIR)/local_tts/local_tts.mk include $(CUSTOM_DIR)/local_tts/local_tts.mk
include $(CUSTOM_DIR)/radar/radar.mk include $(CUSTOM_DIR)/radar/radar.mk
include $(CUSTOM_DIR)/attr_broadcast/attr_broadcast.mk
endif endif

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

@ -23,6 +23,8 @@
#include "tcp_client.h" #include "tcp_client.h"
#include "control_out.h" #include "control_out.h"
#include "radar.h" #include "radar.h"
#include "attr_broadcast.h"
#include "local_tts.h" #include "local_tts.h"
@ -312,7 +314,9 @@ void my_appimg_enter(char *param){
jt808_init(); jt808_init();
tcp_client_init(); tcp_client_init();
gps_config_init(); gps_config_init();
attr_broadcast_init();
radar_init();// 雷达测离初始化 radar_init();// 雷达测离初始化
while(1){ while(1){
osDelay(1000/5); osDelay(1000/5);
} }

2
custom/jt808/inc/jt808_config.h
View File

@ -6,7 +6,7 @@
#include <stdlib.h> #include <stdlib.h>
#include "jt808_util.h" #include "jt808_util.h"
#define JT808_DEBUG_ENABLE 1 #define JT808_DEBUG_ENABLE 0
#if JT808_DEBUG_ENABLE #if JT808_DEBUG_ENABLE
#include "app_uart.h" #include "app_uart.h"

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

@ -98,6 +98,8 @@ extern osThreadFunc_t Autoreport_param_ThreadId;
extern uint8_t Rsp_locked_condition; // 锁车状态, BYTE extern uint8_t Rsp_locked_condition; // 锁车状态, BYTE
extern osMutexId_t Polygon_fence_mutex; // 多边形围栏互斥锁
// 控制车辆状态 // 控制车辆状态
void jt808_Set_CarStatus(uint8_t status); void jt808_Set_CarStatus(uint8_t status);

18
custom/jt808/src/jt808_electronic_fence.c
View File

@ -65,6 +65,7 @@ int jt808_add_tail_fence_Polygon_area(uint32_t area_id ,uint16_t Area_att, uint1
if(area_id == 0 || big_Area_Points == NULL || Area_Points_Num == 0){ if(area_id == 0 || big_Area_Points == NULL || Area_Points_Num == 0){
return -1; return -1;
} }
osMutexAcquire(Polygon_fence_mutex, osWaitForever);
// TODO: 增加附加信息 // TODO: 增加附加信息
fence_Polygon_area_t *p_head =jt808_term_param_item.fence_polygon_area; fence_Polygon_area_t *p_head =jt808_term_param_item.fence_polygon_area;
fence_Polygon_area_t *p_prev =NULL; fence_Polygon_area_t *p_prev =NULL;
@ -91,6 +92,7 @@ int jt808_add_tail_fence_Polygon_area(uint32_t area_id ,uint16_t Area_att, uint1
p_head = (fence_Polygon_area_t *)jt808_malloc(sizeof(fence_Polygon_area_t)); p_head = (fence_Polygon_area_t *)jt808_malloc(sizeof(fence_Polygon_area_t));
if(p_head == NULL){ if(p_head == NULL){
JT808_DEBUG("[%s,%d] malloc failed \r\n", __FUNCTION__,__LINE__); JT808_DEBUG("[%s,%d] malloc failed \r\n", __FUNCTION__,__LINE__);
osMutexRelease(Polygon_fence_mutex);
return -3; return -3;
} }
if(jt808_term_param_item.fence_polygon_area == NULL){ if(jt808_term_param_item.fence_polygon_area == NULL){
@ -109,18 +111,21 @@ int jt808_add_tail_fence_Polygon_area(uint32_t area_id ,uint16_t Area_att, uint1
p_head->Area_Points = (AreaPoint_t *)jt808_malloc(sizeof(AreaPoint_t)*Area_Points_Num);// 区域内点的坐标集合 p_head->Area_Points = (AreaPoint_t *)jt808_malloc(sizeof(AreaPoint_t)*Area_Points_Num);// 区域内点的坐标集合
if(p_head->Area_Points == NULL){ if(p_head->Area_Points == NULL){
JT808_DEBUG("[%s,%d] malloc failed \r\n", __FUNCTION__,__LINE__); JT808_DEBUG("[%s,%d] malloc failed \r\n", __FUNCTION__,__LINE__);
osMutexRelease(Polygon_fence_mutex);
return -3; return -3;
} }
for(int i = 0; i < Area_Points_Num; i++){ 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].lat = Swap32(big_Area_Points[i].lat);
p_head->Area_Points[i].lng = Swap32(big_Area_Points[i].lng); p_head->Area_Points[i].lng = Swap32(big_Area_Points[i].lng);
} }
osMutexRelease(Polygon_fence_mutex);
jt808_save_Fence_area(); jt808_save_Fence_area();
return 0; return 0;
} }
// 移除围栏区域(指定区域ID) // 移除围栏区域(指定区域ID)
int jt808_remove_fence_Polygon_area(uint32_t area_id){ int jt808_remove_fence_Polygon_area(uint32_t area_id){
osMutexAcquire(Polygon_fence_mutex, osWaitForever);
if(area_id == 0){ if(area_id == 0){
fence_Polygon_area_t *p_head =jt808_term_param_item.fence_polygon_area; fence_Polygon_area_t *p_head =jt808_term_param_item.fence_polygon_area;
fence_Polygon_area_t *p_next =NULL; fence_Polygon_area_t *p_next =NULL;
@ -133,6 +138,7 @@ int jt808_remove_fence_Polygon_area(uint32_t area_id){
p_head = p_next; p_head = p_next;
} }
jt808_term_param_item.fence_polygon_area = NULL; jt808_term_param_item.fence_polygon_area = NULL;
osMutexRelease(Polygon_fence_mutex);
jt808_save_Fence_area(); jt808_save_Fence_area();
return 0; return 0;
} }
@ -152,6 +158,7 @@ int jt808_remove_fence_Polygon_area(uint32_t area_id){
jt808_free(p_head->Area_Points); jt808_free(p_head->Area_Points);
} }
jt808_free(p_head); jt808_free(p_head);
osMutexRelease(Polygon_fence_mutex);
jt808_save_Fence_area(); jt808_save_Fence_area();
return 0; return 0;
// break; // break;
@ -159,6 +166,7 @@ int jt808_remove_fence_Polygon_area(uint32_t area_id){
p_prev = p_head; p_prev = p_head;
p_head = p_head->next; p_head = p_head->next;
} }
osMutexRelease(Polygon_fence_mutex);
return -1; return -1;
} }
@ -168,6 +176,7 @@ uint32_t Rsp_Bigban_Fence_Polygon_area_ID = 0;
// 遍历围栏区域，判断指定坐标是否在围栏内 // 遍历围栏区域，判断指定坐标是否在围栏内
// 返回区域ID // 0 未在围栏内 // Area_att == 0x0001 景区围栏，Area_att == 0x0002 禁停区围栏 // 返回区域ID // 0 未在围栏内 // Area_att == 0x0001 景区围栏，Area_att == 0x0002 禁停区围栏
uint32_t jt808_Polygon_fence_check(uint16_t Area_att, uint32_t lat, uint32_t lng){ uint32_t jt808_Polygon_fence_check(uint16_t Area_att, uint32_t lat, uint32_t lng){
osMutexAcquire(Polygon_fence_mutex, osWaitForever);
fence_Polygon_area_t *p_head =jt808_term_param_item.fence_polygon_area; fence_Polygon_area_t *p_head =jt808_term_param_item.fence_polygon_area;
while(p_head != NULL){ while(p_head != NULL){
if((p_head->Area_Points_Num == 0) || (p_head->Area_att != Area_att)){ if((p_head->Area_Points_Num == 0) || (p_head->Area_att != Area_att)){
@ -186,11 +195,13 @@ uint32_t jt808_Polygon_fence_check(uint16_t Area_att, uint32_t lat, uint32_t lng
} }
if(Polygon_fence_check((fence_point_t){.x = lat, .y = lng}, p_point, p_head->Area_Points_Num) == 1){ if(Polygon_fence_check((fence_point_t){.x = lat, .y = lng}, p_point, p_head->Area_Points_Num) == 1){
jt808_free(p_point); jt808_free(p_point);
osMutexRelease(Polygon_fence_mutex);
return p_head->Area_ID; return p_head->Area_ID;
} }
jt808_free(p_point); jt808_free(p_point);
p_head = p_head->next; p_head = p_head->next;
} }
osMutexRelease(Polygon_fence_mutex);
return 0; return 0;
} }
@ -214,6 +225,7 @@ void jt808_delete_Fence_area(void){
// 保存围栏区域 // 保存围栏区域
int jt808_save_Fence_area(void){ int jt808_save_Fence_area(void){
osMutexAcquire(Polygon_fence_mutex, osWaitForever);
uint32_t Area_Buff_Size = 0; // 区域缓存大小 uint32_t Area_Buff_Size = 0; // 区域缓存大小
uint32_t Area_Buff_count = 0; // 区域缓存计数 uint32_t Area_Buff_count = 0; // 区域缓存计数
fence_Polygon_area_t *p_head =jt808_term_param_item.fence_polygon_area; fence_Polygon_area_t *p_head =jt808_term_param_item.fence_polygon_area;
@ -231,11 +243,13 @@ int jt808_save_Fence_area(void){
JT808_DEBUG("Save: delete success\r\n"); JT808_DEBUG("Save: delete success\r\n");
} }
} }
osMutexRelease(Polygon_fence_mutex);
return 0; return 0;
} }
char *p_data = (char *)jt808_malloc(Area_Buff_Size); char *p_data = (char *)jt808_malloc(Area_Buff_Size);
if(p_data == NULL){ if(p_data == NULL){
JT808_DEBUG("[%s,%d] malloc failed \r\n", __FUNCTION__,__LINE__); JT808_DEBUG("[%s,%d] malloc failed \r\n", __FUNCTION__,__LINE__);
osMutexRelease(Polygon_fence_mutex);
return -1; return -1;
} }
p_head =jt808_term_param_item.fence_polygon_area; p_head =jt808_term_param_item.fence_polygon_area;
@ -249,6 +263,7 @@ int jt808_save_Fence_area(void){
Area_Buff_count += 8 + 8*p_head->Area_Points_Num; Area_Buff_count += 8 + 8*p_head->Area_Points_Num;
p_head = p_next; p_head = p_next;
} }
osMutexRelease(Polygon_fence_mutex);
int32_t fd = cm_fs_open(AREA_ID_LIST_FILE, CM_FS_WB); int32_t fd = cm_fs_open(AREA_ID_LIST_FILE, CM_FS_WB);
if(fd < 0){ if(fd < 0){
JT808_DEBUG("open %s failed\r\n", AREA_ID_LIST_FILE); JT808_DEBUG("open %s failed\r\n", AREA_ID_LIST_FILE);
@ -262,6 +277,7 @@ int jt808_save_Fence_area(void){
} }
JT808_DEBUG_DATA("\r\n"); JT808_DEBUG_DATA("\r\n");
jt808_free(p_data); jt808_free(p_data);
jt808_load_Fence_area();
return 0; return 0;
} }
@ -329,6 +345,7 @@ int jt808_load_Fence_area(void){
p_tail->next = NULL; p_tail->next = NULL;
} }
} }
osMutexAcquire(Polygon_fence_mutex, osWaitForever);
fence_Polygon_area_t *p_remove_head =jt808_term_param_item.fence_polygon_area; fence_Polygon_area_t *p_remove_head =jt808_term_param_item.fence_polygon_area;
fence_Polygon_area_t *p_remove_next =NULL; fence_Polygon_area_t *p_remove_next =NULL;
while(p_remove_head != NULL){ while(p_remove_head != NULL){
@ -343,6 +360,7 @@ int jt808_load_Fence_area(void){
jt808_free(p_data); jt808_free(p_data);
JT808_DEBUG("load fence area success\r\n"); JT808_DEBUG("load fence area success\r\n");
osMutexRelease(Polygon_fence_mutex);
return 0; return 0;
ERR_Loal: ERR_Loal:

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

@ -4,6 +4,7 @@
#include "jt808_msg_parse.h" #include "jt808_msg_parse.h"
#include "jt808_pkg_transmit.h" #include "jt808_pkg_transmit.h"
#include "cm_sys.h" #include "cm_sys.h"
#include "cm_os.h"
#include "cm_fs.h" #include "cm_fs.h"
#include "cm_sim.h" #include "cm_sim.h"
#include "cm_pm.h" #include "cm_pm.h"
@ -13,6 +14,9 @@
#include "control_out.h" #include "control_out.h"
Term_Param_item_t jt808_term_param_item; // 终端参数项 Term_Param_item_t jt808_term_param_item; // 终端参数项
osMutexId_t term_param_mutex = NULL; // 终端参数项互斥锁
osMutexId_t Polygon_fence_mutex = NULL; // 多边形围栏互斥锁
// 控制车辆状态 // 控制车辆状态
void jt808_Set_CarStatus(uint8_t status){ void jt808_Set_CarStatus(uint8_t status){
@ -300,7 +304,7 @@ void jt808_LocReport_add_tail_addi_info(uint8_t msg_id){
case BAT_VoltageID:{ case BAT_VoltageID:{
// 电池电压, 0.1V WORD // 电池电压, 0.1V WORD
p_head->msg_len = 2; p_head->msg_len = 2;
p_head->msg = (void *)(&BAT_Message.Bat_Voltage); p_head->msg = (void *)(&BAT_Message.Rsp_BigBat_Voltage);
break; break;
} }
case BAT_PercentageID:{ case BAT_PercentageID:{
@ -362,12 +366,17 @@ uint16_t delay_off_count = 0; // 延时关闭计数
uint8_t Rsp_locked_condition = 0; // 锁车状态, BYTE uint8_t Rsp_locked_condition = 0; // 锁车状态, BYTE
gps_data_t gps_data_msg; // GPS数据;
// 更新自动上报参数 // 更新自动上报参数
void jt808_LocReport_param_update(void){ void jt808_LocReport_param_update(void){
osMutexAcquire(term_param_mutex, osWaitForever);
nmeaTIME beiJingTime; // 北京时间 nmeaTIME beiJingTime; // 北京时间
// TODO: 自动上报参数 // TODO: 自动上报参数
// 1. 位置基本信息 // 1. 位置基本信息
GMTconvert(&gps_data.info.utc, &beiJingTime, 8, 1); GMTconvert(&gps_data_msg.info.utc, &beiJingTime, 8, 1);
if(beiJingTime.mon == 0){ if(beiJingTime.mon == 0){
beiJingTime.mon = 1; beiJingTime.mon = 1;
} }
@ -375,11 +384,11 @@ void jt808_LocReport_param_update(void){
beiJingTime.day = 1; 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_msg.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_msg.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.altitude = Swap16(gps_data_msg.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.speed = Swap16(gps_data_msg.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.direction = Swap16(gps_data_msg.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[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[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[2] = (((beiJingTime.day%100/10)&0x0F)<<4) | ((beiJingTime.day%10)&0x0F);
@ -388,7 +397,7 @@ void jt808_LocReport_param_update(void){
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.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.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.positioning = (((gps_data_msg.info.fix == 1)||(gps_data_msg.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.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.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.PLT_MODE =sys_sta.PLT_MODE; // 1:游客模式,0:管理模式
@ -406,13 +415,13 @@ void jt808_LocReport_param_update(void){
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)){ // 不可用// 未定位时发送心跳包 if((gps_data_msg.info.fix == 1)||(gps_data_msg.info.sig == 0)){ // 不可用// 未定位时发送心跳包
Rsp_Bigscenic_Fence_Polygon_area_ID = 0; Rsp_Bigscenic_Fence_Polygon_area_ID = 0;
Rsp_Bigban_Fence_Polygon_area_ID = 0; Rsp_Bigban_Fence_Polygon_area_ID = 0;
}else{ }else{
// 更新当前所在位置区域ID // 更新当前所在位置区域ID
uint32_t lat = nmea_ndeg2degree(gps_data.info.lat) * 1e6; uint32_t lat = nmea_ndeg2degree(gps_data_msg.info.lat) * 1e6;
uint32_t lng = nmea_ndeg2degree(gps_data.info.lon) * 1e6; uint32_t lng = nmea_ndeg2degree(gps_data_msg.info.lon) * 1e6;
// lat = 44939236; // lat = 44939236;
// lng = 121369446; // lng = 121369446;
// lat = 34939236; // lat = 34939236;
@ -455,6 +464,7 @@ void jt808_LocReport_param_update(void){
delay_off_count = 0; delay_off_count = 0;
} }
} }
osMutexRelease(term_param_mutex);
} }
void Autoreport_param_Task(void *arg){ void Autoreport_param_Task(void *arg){
@ -510,12 +520,18 @@ void Autoreport_param_Task(void *arg){
#endif #endif
while(1){ while(1){
osMutexAcquire(gps_data.mutex, osWaitForever);
memcpy(&gps_data_msg, &gps_data, sizeof(gps_data_t));
osMutexRelease(gps_data.mutex);
jt808_LocReport_param_update(); // 更新位置信息参数 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_msg.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_msg.info.fix == 1)||(gps_data_msg.info.sig == 0)){ // 不可用// 未定位时发送心跳包
jt808_pkg_send(ID_Term_HB,0); // 发送心跳包 // 不接收应答 jt808_pkg_send(ID_Term_HB,0); // 发送心跳包 // 不接收应答
// jt808_pkg_send(ID_LocReport,0);
// jt808_pkg_send(ID_Car_CtrlResp,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_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{ }else{
jt808_pkg_send(ID_LocReport,10000/5); // 发送位置信息上报包 jt808_pkg_send(ID_LocReport,10000/5); // 发送位置信息上报包
@ -547,9 +563,14 @@ void jt808_Autoreport_param_stop(void){
} }
} }
// 初始化终端参数 // 初始化终端参数
void jt808_set_term_param_init(void){ void jt808_set_term_param_init(void){
int ret = 0; int ret = 0;
term_param_mutex = osMutexNew(NULL); // 创建互斥锁
Polygon_fence_mutex = osMutexNew(NULL); // 创建互斥锁
memset(&jt808_term_param_item,0,sizeof(Term_Param_item_t)); memset(&jt808_term_param_item,0,sizeof(Term_Param_item_t));
// 加载围栏区域信息 // 加载围栏区域信息
if(0 == jt808_get_areafile_state()){ if(0 == jt808_get_areafile_state()){
@ -626,32 +647,39 @@ void jt808_set_term_param_init(void){
}while(0); }while(0);
do{ // 设置终端手机号 do{ // 设置终端手机号
char cm_iccid[32] = {0}; char cm_iccid[32] = {0};
char get_iccid_ok = 0; uint8_t BCD_code[13]={0};
int error_count = 0; int error_count = 0;
uint8_t operator_val=0;
while(error_count <= 20){ while(error_count <= 20){
memset(cm_iccid, 0, sizeof(cm_iccid)); memset(cm_iccid, 0, sizeof(cm_iccid));
get_iccid_ok = 0;
cm_sim_get_iccid(cm_iccid); cm_sim_get_iccid(cm_iccid);
// 统计有效字符 if((cm_iccid[0] == '8')&&(cm_iccid[1] == '9')&&(cm_iccid[2] == '8')&&(cm_iccid[3] == '6')&&(strlen(cm_iccid)>=19)){
for(int i = strlen(cm_iccid) - 1; i >= 8; i--) { operator_val =(cm_iccid[4]-'0')*10 + cm_iccid[5]-'0';
if(cm_iccid[i] >= '0' && cm_iccid[i] <= '9') { JT808_DEBUG("operator:%d,iccid:%d,:%s\n",operator_val ,strlen(cm_iccid), cm_iccid);
get_iccid_ok++;
uint8_t start_val=strlen(cm_iccid);
if((operator_val ==0)||(operator_val ==2)||(operator_val ==4)||(operator_val ==7)){ // 中国移动
start_val -= 12;
}else if((operator_val ==1)||(operator_val ==6)||(operator_val ==9)){ // 中国联通
start_val -= 12;
}else if((operator_val ==3)||(operator_val ==11)){ // 电信
start_val -= 13;
}
for(uint8_t count =0; count < 12; count++){
if(cm_iccid[start_val + count] >= '0' && cm_iccid[start_val + count] <= '9'){
BCD_code[count] =cm_iccid[start_val + count];
}else{ }else{
break; BCD_code[count] ='0';
} }
} }
JT808_DEBUG("get_iccid_ok:%d\n",get_iccid_ok); rawStrToBcd(jt808_term_param_item.phone_BCDnum, BCD_code, 12); // 终端手机号码
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; break;
}else{ }
error_count++; error_count++;
JT808_DEBUG("get iccid failed count:%d\n",error_count); JT808_DEBUG("get iccid failed, retry:%d\n", error_count);
}
osDelay(1000/5); // 根据需求设置延时 osDelay(1000/5); // 根据需求设置延时
} }
jt808_term_param_item.msg_flow_num =0; jt808_term_param_item.msg_flow_num =0;
JT808_DEBUG("phone_BCDnum:"); JT808_DEBUG("phone_BCDnum:");
for(int i=0;i<6;i++){ for(int i=0;i<6;i++){

3
custom/local_tts/inc/local_tts.h
View File

@ -25,4 +25,7 @@ void local_tts_set(int32_t speed, int32_t volume, cm_local_tts_digit_e mode);
// len=0时自动计算长度//interruptible =1时,表示允许被打断播放 // len=0时自动计算长度//interruptible =1时,表示允许被打断播放
int8_t local_tts_text_play(char *text, uint8_t len, uint8_t en_interruptible); int8_t local_tts_text_play(char *text, uint8_t len, uint8_t en_interruptible);
//获取播放状态
int local_tts_get_play_state(void);
#endif // __LOCAL_TTS_H__ #endif // __LOCAL_TTS_H__

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

@ -172,6 +172,10 @@ typedef struct {
tts_play_cfg_t tts_play_cfg; tts_play_cfg_t tts_play_cfg;
int local_tts_get_play_state(void) {
return tts_play_cfg.play_state != TTS_STATE_IDLE;
}
static void tts_play_callback(cm_local_tts_event_e event, void *param){ static void tts_play_callback(cm_local_tts_event_e event, void *param){
switch(event){ switch(event){

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

@ -21,7 +21,7 @@
#include "app_uart.h" #include "app_uart.h"
#define DEBUG(fmt, args...) app_printf("[RADAR]" fmt, ##args) #define DEBUG(fmt, args...) app_printf("[RADAR]" fmt, ##args)
#else #else
#define DEBUG(fmt, arg...) #define DEBUG(fmt, ...)
#endif #endif
static osThreadId_t os_RADAR_ThreadId; static osThreadId_t os_RADAR_ThreadId;
@ -62,7 +62,7 @@ static void radar_AUTO_BrakeORSpeedCut(uint8_t radar_id , uint16_t Car_Distance)
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){
// local_tts_set(5, 15, CM_LOCAL_TTS_DIGIT_AUTO); // local_tts_set(5, 15, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("自动刹车",0,0); local_tts_text_play("刹车",0,0);
// Time_Event_Blink(Buzzer_Event,100,100,0xffff,NULL); // Time_Event_Blink(Buzzer_Event,100,100,0xffff,NULL);
} }
sys_sta.A_brake =1;//使能自动刹车 sys_sta.A_brake =1;//使能自动刹车
@ -143,6 +143,9 @@ static void RADAR_TaskHandle(void *param){
// 根据倒车状态确定雷达ID // 根据倒车状态确定雷达ID
// DEBUG("SendCMD:ID=%#02x", (0 == sys_sta.IO_RX_back)?RADAR_ID_Back:RADAR_ID_Front); // DEBUG("SendCMD:ID=%#02x", (0 == sys_sta.IO_RX_back)?RADAR_ID_Back:RADAR_ID_Front);
radar_Sendcmd((0 == sys_sta.IO_RX_back)?RADAR_ID_Back:RADAR_ID_Front, RADAR_MODE_Real); radar_Sendcmd((0 == sys_sta.IO_RX_back)?RADAR_ID_Back:RADAR_ID_Front, RADAR_MODE_Real);
}else{
sys_sta.A_Speed_Cut =0; // 清空自动减速状态
sys_sta.A_brake =0; // 清空自动刹车状态
} }
osDelay(140/5); // 140ms osDelay(140/5); // 140ms
} }

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

@ -17,7 +17,7 @@
#include "app_uart.h" #include "app_uart.h"
#define DEBUG(fmt, args...) app_printf("[TCP]" fmt, ##args) #define DEBUG(fmt, args...) app_printf("[TCP]" fmt, ##args)
#else #else
#define DEBUG(fmt, arg...) #define DEBUG(fmt, ...)
#endif #endif
static int tcp_client_sock = -1; static int tcp_client_sock = -1;
@ -151,14 +151,13 @@ static void net_manage_task(void *arg){
cm_cereg_state_t cereg_state = {0}; cm_cereg_state_t cereg_state = {0};
uint8_t error_time_out = 0; uint8_t error_time_out = 0;
while(1){ while(1){
TCP_DISABLE:
error_time_out = 0;
do{// 连接服务器
while(1){ // 等待插入SIM卡并建立网络连接 while(1){ // 等待插入SIM卡并建立网络连接
osDelay(1000/5); osDelay(1000/5);
error_time_out++; error_time_out++;
if(error_time_out > 15){ // 超时退出 if(error_time_out > 15){ // 超时退出
DEBUG("network connect timeout!\n"); DEBUG("network connect timeout!\n");
local_tts_text_play("网络异常,5秒后重启!",0,0);
osDelay(5000/5);
cm_pm_reboot(); cm_pm_reboot();
} }
if(0 == cm_modem_get_cpin()){ // 插入SIM卡 if(0 == cm_modem_get_cpin()){ // 插入SIM卡
@ -170,9 +169,11 @@ TCP_DISABLE:
DEBUG("cereg_state:%d\n",cereg_state.state); // 注册状态 DEBUG("cereg_state:%d\n",cereg_state.state); // 注册状态
if(cereg_state.state == 1){ // 已注册 if(cereg_state.state == 1){ // 已注册
DEBUG("network ready\n"); DEBUG("network ready\n");
local_tts_text_play("网络正常!",0,0);
break; break;
}else{ }else{
DEBUG("waiting for network...\n"); DEBUG("waiting for network...\n");
// local_tts_text_play("等待网络连接!",0,0);
} }
}else{ }else{
DEBUG("cereg_get_state fail!\n\n"); DEBUG("cereg_get_state fail!\n\n");
@ -183,14 +184,23 @@ TCP_DISABLE:
// app_printf("waiting for network...\n"); // app_printf("waiting for network...\n");
// } // }
} }
TCP_DISABLE:
error_time_out = 0;
do{// 连接服务器
osDelay(1000/5);
error_time_out++;
if(error_time_out > 15){ // 超时退出
DEBUG("network connect timeout!\n");
local_tts_text_play("服务器连接失败，重连中...",0,0);
}
}while(0 != tcp_client_connect((char *)(PrsResult.term_param_item->set_term_param.MainServerAddr) , PrsResult.term_param_item->set_term_param.ServerPort)); // 连接到TCP服务器 }while(0 != tcp_client_connect((char *)(PrsResult.term_param_item->set_term_param.MainServerAddr) , PrsResult.term_param_item->set_term_param.ServerPort)); // 连接到TCP服务器
DEBUG("tcp_client_connect success!\r\n"); DEBUG("tcp_client_connect success!\r\n");
for(uint8_t i = 0; i < 3; i++){ // 发送3次注册、鉴权、参数设置、上报参数 for(uint8_t i = 0; i < 3; i++){ // 发送3次注册、鉴权、参数设置、上报参数
ret =jt808_pkg_send(ID_Term_Reg,8000/5);//注册终端 超时：8S ret =jt808_pkg_send(ID_Term_Reg,5000/5);//注册终端 超时：8S
if(0 == ret){ // 0：成功；1：车辆已被注册；2：数据库中无该车辆；3：终端已被注册；4：数据库中无该终端 if(0 == ret){ // 0：成功；1：车辆已被注册；2：数据库中无该车辆；3：终端已被注册；4：数据库中无该终端
DEBUG("send ID_Term_Reg success!\n"); DEBUG("send ID_Term_Reg success!\n");
for(uint8_t i = 0; i < 5; i++){ for(uint8_t i = 0; i < 5; i++){
ret =jt808_pkg_send(ID_Term_Auth,10000/5);//终端鉴权 超时：10S ret =jt808_pkg_send(ID_Term_Auth,5000/5);//终端鉴权 超时：10S
if(0 == ret){ if(0 == ret){
DEBUG("send ID_Term_Auth success!\n"); DEBUG("send ID_Term_Auth success!\n");
break; break;
@ -203,6 +213,8 @@ TCP_DISABLE:
} }
break; break;
}else{ }else{
local_tts_text_play("设备未绑定，注册异常",0,0);
osDelay(10000/5);
DEBUG("send ID_Term_Reg fail:%d!\n",ret); DEBUG("send ID_Term_Reg fail:%d!\n",ret);
if(ret == -1){ // 发送失败 if(ret == -1){ // 发送失败
goto TCP_DISABLE; goto TCP_DISABLE;
@ -215,14 +227,14 @@ TCP_DISABLE:
led_set_event(EVENT_NETWORK_READY); // 网络连接成功 led_set_event(EVENT_NETWORK_READY); // 网络连接成功
DEBUG("NetwarK connected!\r\n"); DEBUG("NetwarK connected!\r\n");
// local_tts_set(5, 15, CM_LOCAL_TTS_DIGIT_AUTO); // local_tts_set(5, 15, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("网络已连接",0,0); local_tts_text_play("服务器已连接",0,0);
// local_tts_text_play("欢迎使用莱昂特智能终端设备...。",0,0); // 0:表示自动计算字符串长度,10000表示最大等待时间 // local_tts_text_play("欢迎使用莱昂特智能终端设备...。",0,0); // 0:表示自动计算字符串长度,10000表示最大等待时间
osSemaphoreAcquire(netconn_disconnect_sem, osWaitForever); // 等待断开连接信号 osSemaphoreAcquire(netconn_disconnect_sem, osWaitForever); // 等待断开连接信号
jt808_Autoreport_param_stop();//停止自动上报参数设置 jt808_Autoreport_param_stop();//停止自动上报参数设置
led_set_event(EVENT_NETWORK_DISCONNECT); // 网络断开连接 led_set_event(EVENT_NETWORK_DISCONNECT); // 网络断开连接
DEBUG("NetwarK disconnected!\r\n"); DEBUG("NetwarK disconnected!\r\n");
// local_tts_set(5, 15, CM_LOCAL_TTS_DIGIT_AUTO); // local_tts_set(5, 15, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("网络信号弱",0,0); local_tts_text_play("服务器已断开",0,0);
} }
} }