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

临时提交，TTS语音功能异常 zsxfly20241123

This commit is contained in:
zsx 2024-11-23 16:22:04 +08:00
parent edda19ce55
commit d8a6bc7f2a
24 changed files with 1113 additions and 484 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -33,7 +33,7 @@ static void* gps_uart_sem = NULL; //串口数据接收、解析任务信号量
*/ */
void trace(const char *str, int str_size){ void trace(const char *str, int str_size){
// app_printf("\r\nTrace: "); // app_printf("\r\nTrace: ");
// cm_uart_write(CM_UART_DEV_0, (void*)str, str_size, 1000); // uart0_send_msg((uint8_t*)str, str_size, 0);
} }
/** /**
@ -150,7 +150,7 @@ void gps_config_init(void){
CM_UART_PARITY_NONE, CM_UART_PARITY_NONE,
CM_UART_STOP_BIT_ONE, CM_UART_STOP_BIT_ONE,
CM_UART_FLOW_CTRL_NONE, CM_UART_FLOW_CTRL_NONE,
CM_UART_BAUDRATE_9600, CM_UART_BAUDRATE_115200,
0 //配置为普通串口模式，若要配置为低功耗模式可改为1 0 //配置为普通串口模式，若要配置为低功耗模式可改为1
}; };
// 开启串口 // 开启串口

6
custom/adc_dac/adc_dac.mk
View File

@ -1,6 +0,0 @@
CUSTOM_MAIN_DIR := custom/adc_dac
OC_FILES += $(CUSTOM_MAIN_DIR)/src/adc_dac.c
INC += -I'$(CUSTOM_MAIN_DIR)/inc'

8
custom/adc_dac/inc/adc_dac.h
View File

@ -1,8 +0,0 @@
#ifndef __ADC_DAC_H__
#define __ADC_DAC_H__
#include "cm_os.h"
void adc_dac_init(void);
#endif //__ADC_DAC_H__

81
custom/adc_dac/src/adc_dac.c
View File

@ -1,81 +0,0 @@
#include "adc_dac.h"
#include <stdint.h>
#include "cm_adc.h"
#include "cm_gpio.h"
#include "cm_iomux.h"
#include "cm_pwm.h"
#define ADC_DAC_DEBUG_ENABLE 1
#if ADC_DAC_DEBUG_ENABLE
#include "app_uart.h"
#define DEBUG(fmt, args...) app_printf("[ADC]" fmt, ##args)
#else
#define DEBUG(fmt, arg...)
#endif
#define PWM0_IOMUX CM_IOMUX_PIN_74, CM_IOMUX_FUNC_FUNCTION1
#define PWM1_IOMUX CM_IOMUX_PIN_75, CM_IOMUX_FUNC_FUNCTION1
#define PWM2_IOMUX CM_IOMUX_PIN_21, CM_IOMUX_FUNC_FUNCTION2
#define PWM3_IOMUX 0, 0
osThreadId_t adc_dac_TaskHandle = NULL;
typedef enum {
ADC_power = 0,
ADC_acc = 1,
}adc_chx_t;
int32_t get_voltage(adc_chx_t chx){
int32_t voltage = 0;
if(chx == ADC_acc){
cm_gpio_set_level(CM_GPIO_NUM_20, 1);
}else if(chx == ADC_power){
cm_gpio_set_level(CM_GPIO_NUM_20, 0);
}else{
return 0;
}
osDelay(1);//5ms
if(0 != cm_adc_read(CM_ADC_0,&voltage)){
DEBUG("ADC read fail\r\n");
voltage = 0;
}
// cm_gpio_set_level(CM_GPIO_NUM_20, 1); //恢复默认状态
return voltage;
}
void adc_dac_task(void *argument){
while(1){
DEBUG("ADC_acc:%d\r\n",get_voltage(ADC_acc));
DEBUG("ADC_power:%d\r\n\n",get_voltage(ADC_power));
osDelay(500/5);
}
}
void adc_dac_init(void){
cm_gpio_cfg_t cfg = {0};
cfg.direction = CM_GPIO_DIRECTION_OUTPUT;
cfg.pull = CM_GPIO_PULL_UP;
cm_iomux_set_pin_func(CM_IOMUX_PIN_86, CM_IOMUX_FUNC_FUNCTION2);//初始化之前一定要先设置引脚复用
cm_gpio_init(CM_GPIO_NUM_20, &cfg);
cm_gpio_set_level(CM_GPIO_NUM_20, 1);
// pwm init
cm_iomux_set_pin_func(PWM0_IOMUX);
if(0 != cm_pwm_set_clk(CM_PWM_DEV_0, CM_PWM_CLK_12800K)){//时钟源选择需要放在open之前
DEBUG("pwm0 set clk fail\r\n");
return;
}
if(0 != cm_pwm_open_ns(CM_PWM_DEV_0, 100000,30000)){ //设置频率为10KHz，占空比为30%
DEBUG("pwm0 open error\n");
}
osThreadAttr_t adc_dac_task_attr = {0};
adc_dac_task_attr.name = "adc_dac_task";
adc_dac_task_attr.stack_size = 1024;
adc_dac_task_attr.priority = osPriorityNormal;
adc_dac_TaskHandle = osThreadNew((osThreadFunc_t)adc_dac_task,0,&adc_dac_task_attr);
}

6
custom/control_out/control_out.mk Normal file
View File

@ -0,0 +1,6 @@
CUSTOM_MAIN_DIR := custom/control_out
OC_FILES += $(CUSTOM_MAIN_DIR)/src/control_out.c
INC += -I'$(CUSTOM_MAIN_DIR)/inc'

73
custom/control_out/inc/control_out.h Normal file
View File

@ -0,0 +1,73 @@
#ifndef __CONTROL_OUT_H__
#define __CONTROL_OUT_H__
#include "cm_os.h"
#include "cm_gpio.h"
#define ACC_RES_UP 10000
#define ACC_RES_DOWN 3300
#define VIN_RES_UP 240000
#define VIN_RES_DOWN 3300
// ACC 输出设置
#define ACC_OUT_RES_UP 5100
#define ACC_OUT_RES_DOWN 3300
#define ACC_OUT_PERIOD_US 1000000
#define ACC_OUT_Voltage_MAX 3820
#define ACC_OUT_Voltage_MIN 880
// #define ACC_Dmin (((880*ACC_OUT_RES_DOWN)/(ACC_OUT_RES_UP+ACC_OUT_RES_DOWN))*(ACC_OUT_PERIOD_US/(1800)))
// #define ACC_Dmax (((3820*ACC_OUT_RES_DOWN)/(ACC_OUT_RES_UP+ACC_OUT_RES_DOWN))*(ACC_OUT_PERIOD_US/(1800)))
typedef enum{
OUT_Door_lock = CM_GPIO_NUM_21, // 门锁
IO_MANAGER_MODE = CM_GPIO_NUM_12, // 管理模式
IO_RX_BACK = CM_GPIO_NUM_3, // 倒车
IO_TX_BRAKE = CM_GPIO_NUM_4, // 刹车
}control_io_t;
typedef struct{
union{
uint16_t VERSION; // 软件版本号
struct{
uint16_t SW_version:11; // 软件版本序号
uint16_t HW_version:4; // 硬件版本序号
uint16_t VER_type:1; // 当前固件类型0：0x04000；1：0x20000
};
};
uint8_t Modbus_addr; // MODBUS地址
uint8_t Manager_sLim; // 管理员模式油门极限(Unit:%)
uint8_t Tourist_sLim; // 游客模式油门极限
uint8_t Speed_Cut_sLim; // 减速油门极限(Unit:%)(自动减速时油门极限)
uint16_t Brake_DLimit; // 刹车距离极限(前进)(Unit:mm)
uint16_t Speed_Cut_DLimit; // 减速距离极限
uint16_t Brake_DLimit_B; // 刹车距离极限(后退)
uint16_t Speed_Cut_DLimit_B;// 减速距离极限
uint16_t CRC16; // 配置信息CRC16校验码
}SYS_CONF_t;
extern SYS_CONF_t sys_conf;
typedef struct{
union{// 输入输出状态
struct{
uint8_t O_door_lock :1; // 1:电门锁打开,0:电门锁关闭
uint8_t MAG_MODE :1; // 1:游客模式,0:管理模式
uint8_t PLT_MODE :1; // 1:游客模式,0:管理模式
uint8_t IO_RX_back :1; // 1:正常 0:倒车
uint8_t IO_TX_brake :1; // 1:正常 0:刹车
uint8_t A_brake :1; // 1:自动刹车,0:手动刹车
uint8_t A_Speed_Cut :1; // 1:自动减速,0:手动减速
uint8_t P_Radar_EN :1; // 1:雷达使能,0:雷达禁止
};
uint8_t IO_STA;
};
} sys_sta_t;
extern sys_sta_t sys_sta;
void control_out_init(void);
#endif //__CONTROL_OUT_H__

258
custom/control_out/src/control_out.c Normal file
View File

@ -0,0 +1,258 @@
#include <stdint.h>
#include "cm_adc.h"
#include "cm_gpio.h"
#include "cm_iomux.h"
#include "cm_pwm.h"
#include "local_tts.h"
#include "control_out.h"
#define ADC_DAC_DEBUG_ENABLE 1
#if ADC_DAC_DEBUG_ENABLE
#include "app_uart.h"
#define DEBUG(fmt, args...) app_printf("[CONTROL_OUT]" fmt, ##args)
#else
#define DEBUG(fmt, arg...)
#endif
#define PWM0_IOMUX CM_IOMUX_PIN_74, CM_IOMUX_FUNC_FUNCTION1
#define PWM1_IOMUX CM_IOMUX_PIN_75, CM_IOMUX_FUNC_FUNCTION1
#define PWM2_IOMUX CM_IOMUX_PIN_21, CM_IOMUX_FUNC_FUNCTION2
#define PWM3_IOMUX 0, 0
osThreadId_t control_out_TaskHandle = NULL;
SYS_CONF_t sys_conf ={
.SW_version = 1,
.HW_version = 1,
.VER_type = 1,
.Manager_sLim =100,
.Tourist_sLim =50,
.Speed_Cut_sLim =20,
.Brake_DLimit =1200,
.Speed_Cut_DLimit =2000,
.Brake_DLimit_B =1200,
.Speed_Cut_DLimit_B =2000,
};
sys_sta_t sys_sta;
typedef enum {
ADC_power = 0,
ADC_acc = 1,
}adc_chx_t;
int32_t get_voltage(adc_chx_t chx){
int32_t voltage = 0;
if(chx == ADC_acc){
cm_gpio_set_level(CM_GPIO_NUM_20, 0);
}else if(chx == ADC_power){
cm_gpio_set_level(CM_GPIO_NUM_20, 1);
}else{
return 0;
}
osDelay(1);//5ms
if(0 != cm_adc_read(CM_ADC_0,&voltage)){
DEBUG("ADC read fail\r\n");
voltage = 0;
}
if(chx == ADC_acc){
voltage = voltage * ((ACC_RES_UP+ACC_RES_DOWN) / ACC_RES_DOWN); //转化为电压值
cm_gpio_set_level(CM_GPIO_NUM_20, 1);
}else if(chx == ADC_power){
voltage = voltage * ((VIN_RES_UP+VIN_RES_DOWN) / VIN_RES_DOWN); //转化为电压值
cm_gpio_set_level(CM_GPIO_NUM_20, 0);
}else{
return 0;
}
// cm_gpio_set_level(CM_GPIO_NUM_20, 1); //恢复默认状态
return voltage;
}
uint32_t ACC_Dmin =(((ACC_OUT_Voltage_MIN*ACC_OUT_RES_DOWN)/(ACC_OUT_RES_UP+ACC_OUT_RES_DOWN))*(ACC_OUT_PERIOD_US/(1800)));
uint32_t ACC_Dmax =(((ACC_OUT_Voltage_MAX*ACC_OUT_RES_DOWN)/(ACC_OUT_RES_UP+ACC_OUT_RES_DOWN))*(ACC_OUT_PERIOD_US/(1800)));
// 获取输入油门百分比（unit:%)(踏板信号)
uint16_t get_in_acc_percent(void){
uint16_t acc_voltage =get_voltage(ADC_acc);
if(acc_voltage < 900){
return 0;
}else if(acc_voltage > 3800){
return 100;
}else{
return ((acc_voltage-900)/29);
// return (100*(acc_voltage - 900)/(3800-900));
}
}
// 设置输出油门大小
void set_out_acc_percent(uint8_t percent){//1000000设置频率为10KHz
if(0 != cm_pwm_open_ns(CM_PWM_DEV_0,ACC_OUT_PERIOD_US,(ACC_Dmin+((ACC_Dmax-ACC_Dmin)*(percent))/100))){
DEBUG("pwm0 open error\n");
}
}
#define _out_UPDETE_TIME 10
static uint32_t back_timecount = 0;
static uint8_t door_lock_last_status = 0;
static uint8_t S_MODE_last_status = 1;
void control_out_task(void *argument){
cm_gpio_level_e level = 0;
while(1){
// DEBUG("ADC_acc:%dmV\r\n",get_voltage(ADC_acc));
// DEBUG("ADC_power:%dmV\r\n\n",get_voltage(ADC_power));
// 系统模式状态
if(0 ==cm_gpio_get_level(IO_MANAGER_MODE, &level)){ // 更新系统模式
sys_sta.MAG_MODE = level; // 1:游客模式,0:管理模式
// DEBUG("IO_SYS_MODE:%d\r\n",level);
}
// 倒车状态
if(0 ==cm_gpio_get_level(IO_RX_BACK, &level)){ // 更新倒车模式
sys_sta.IO_RX_back = level; // 0:倒车模式,1:正常模式
// DEBUG("IO_RX_back:%d\r\n",level);
}
// 刹车状态
if(1 == sys_sta.A_brake){ // 自动刹车触发
cm_gpio_set_direction(IO_TX_BRAKE, CM_GPIO_DIRECTION_OUTPUT);
cm_gpio_set_level(IO_TX_BRAKE, 0); // 打开刹车
// DEBUG("auto brake\r\n");
}else{
cm_gpio_set_direction(IO_TX_BRAKE, CM_GPIO_DIRECTION_INPUT);
cm_gpio_set_pull(IO_TX_BRAKE, CM_GPIO_PULL_UP); // 关闭刹车
cm_gpio_set_level(IO_TX_BRAKE, 1);
// DEBUG("close brake\r\n");
}
if(0 ==cm_gpio_get_level(IO_TX_BRAKE, &level)){ // 更新刹车状态
// if(level != sys_sta.IO_TX_brake && level == 0){
// local_tts_text_play("刹车",0,0);
// }
sys_sta.IO_TX_brake = level; // 0:刹车模式,1:正常模式
// DEBUG("IO_TX_brake:%d\r\n",level);
if(level == 0){
sys_sta.O_door_lock = 1; // 电门锁打开
sys_sta.PLT_MODE = 1; //
}else{
sys_sta.O_door_lock = 0; // 电门锁打开
sys_sta.PLT_MODE = 1; //
}
}
// 动作语音提示
if((door_lock_last_status != sys_sta.O_door_lock) && (1 == sys_sta.MAG_MODE )){ // 游客模式下，电门锁状态变化时触发
door_lock_last_status = sys_sta.O_door_lock;
if(1 == sys_sta.O_door_lock){ // 电门锁打开
// DEBUG("\n\ndoor lock open\r\n\n");
// local_tts_set(5, 15, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("欢迎使用游园猫",0,1,0);
}else{ // 电门锁关闭
// DEBUG("\n\ndoor lock close\r\n\n");
// local_tts_set(5, 15, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("行程结束，祝您生活愉快",0,1,0);
}
}
if((S_MODE_last_status != sys_sta.MAG_MODE) || ((0 == sys_sta.PLT_MODE)&&(1 == sys_sta.O_door_lock))){ // 管理员模式状态变化时触发
S_MODE_last_status = sys_sta.MAG_MODE;
if((0 == sys_sta.MAG_MODE)||(0 == sys_sta.PLT_MODE)){ // 管理模式
DEBUG("\n\nMAG_MODE\r\n\n");
local_tts_set(5, 15, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("管理员模式",0,1,0);
}else{ // 退出管理员模式
DEBUG("\n\nPLT_MODE\r\n\n");
local_tts_set(10, 15, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("退出管理员模式",0,1,0);
}
}
if((sys_sta.IO_RX_back == 0)&&((1 == sys_sta.O_door_lock) || (0 == sys_sta.MAG_MODE ))){ // 倒车模式
back_timecount++;
// DEBUG("back_timecount:%d\r\n\n",back_timecount);
if(back_timecount > _out_UPDETE_TIME*10){ // 3秒播报倒车提示语一次
back_timecount = 0;
DEBUG("\n\n>>>>>>>>>>>>back time play.......... \r\n\n");
// local_tts_set(5, 15, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("倒车，请注意！",0,0,0); // 忙时自动取消倒车提示语
}
}
//油门控制
if((1 == sys_sta.O_door_lock) || (0 == sys_sta.MAG_MODE )){
cm_gpio_set_level(OUT_Door_lock, 1); // 打开电门锁
uint8_t acc_percent =0;
if((1 == sys_sta.MAG_MODE)||(1 == sys_sta.PLT_MODE )){ // 游客模式
if(sys_sta.A_Speed_Cut){ // 自动减速
acc_percent = (get_in_acc_percent() * sys_conf.Speed_Cut_sLim) / 100.0;
}else{
acc_percent = (get_in_acc_percent() * sys_conf.Tourist_sLim) / 100.0;
}
}else{ // 管理员模式
acc_percent = (get_in_acc_percent() * sys_conf.Manager_sLim) / 100.0;
}
set_out_acc_percent(acc_percent);
// DEBUG("acc_percent:%d\r\n",acc_percent);
}else{
cm_gpio_set_level(OUT_Door_lock, 0); // 关闭电门锁
set_out_acc_percent(0);
}
osDelay(_out_UPDETE_TIME/5);
}
}
void control_out_init(void){
cm_gpio_cfg_t cfg = {0};
// SW_ADC
cfg.direction = CM_GPIO_DIRECTION_OUTPUT;
cfg.pull = CM_GPIO_PULL_UP;
cm_iomux_set_pin_func(CM_IOMUX_PIN_86, CM_IOMUX_FUNC_FUNCTION2);//初始化之前一定要先设置引脚复用
cm_gpio_init(CM_GPIO_NUM_20, &cfg);
cm_gpio_set_level(CM_GPIO_NUM_20, 1);
// 电门锁IO初始化 (输出)
cfg.direction = CM_GPIO_DIRECTION_OUTPUT;
cfg.pull = CM_GPIO_PULL_UP;
cm_iomux_set_pin_func(CM_IOMUX_PIN_87, CM_IOMUX_FUNC_FUNCTION2);
cm_gpio_init(OUT_Door_lock, &cfg);
cm_gpio_set_level(OUT_Door_lock, 0);//默认关闭
// 管理员模式IO初始化 (输入)
cfg.direction = CM_GPIO_DIRECTION_INPUT;
cfg.pull = CM_GPIO_PULL_UP;
cm_iomux_set_pin_func(CM_IOMUX_PIN_76, CM_IOMUX_FUNC_FUNCTION2);
cm_gpio_init(IO_MANAGER_MODE, &cfg);
// cm_gpio_set_level(IO_MANAGER_MODE, 0);
// 倒车IO初始化 (输入)
cfg.direction = CM_GPIO_DIRECTION_INPUT;
cfg.pull = CM_GPIO_PULL_UP;
cm_iomux_set_pin_func(CM_IOMUX_PIN_50, CM_IOMUX_FUNC_FUNCTION2);
cm_gpio_init(IO_RX_BACK, &cfg);
// cm_gpio_set_level(IO_RX_BACK, 0);
// 刹车IO初始化 (输入输出)
cfg.direction = CM_GPIO_DIRECTION_INPUT;
cfg.pull = CM_GPIO_PULL_UP;
cm_iomux_set_pin_func(CM_IOMUX_PIN_51, CM_IOMUX_FUNC_FUNCTION2);
cm_gpio_init(IO_TX_BRAKE, &cfg);
// cm_gpio_set_level(IO_TX_BRAKE, 0);
// pwm init
cm_iomux_set_pin_func(PWM0_IOMUX);
if(0 != cm_pwm_set_clk(CM_PWM_DEV_0, CM_PWM_CLK_12800K)){//时钟源选择需要放在open之前
DEBUG("pwm0 set clk fail\r\n");
return;
}
set_out_acc_percent(0); // 设置输出油门大小为0%
osThreadAttr_t control_out_task_attr = {0};
control_out_task_attr.name = "control_out_task";
control_out_task_attr.stack_size = 4096;
control_out_task_attr.priority = osPriorityNormal;
control_out_TaskHandle = osThreadNew((osThreadFunc_t)control_out_task,0,&control_out_task_attr);
}

3
custom/custom.mk
View File

@ -8,6 +8,7 @@ include $(CUSTOM_DIR)/nmealib/nmealib.mk
include $(CUSTOM_DIR)/GPS/gps.mk include $(CUSTOM_DIR)/GPS/gps.mk
include $(CUSTOM_DIR)/jt808/jt808.mk include $(CUSTOM_DIR)/jt808/jt808.mk
include $(CUSTOM_DIR)/tcp_client/tcp_client.mk include $(CUSTOM_DIR)/tcp_client/tcp_client.mk
include $(CUSTOM_DIR)/adc_dac/adc_dac.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
endif endif

4
custom/custom_main/inc/app_uart.h
View File

@ -24,8 +24,10 @@ typedef struct
void app_uart_init(void); void app_uart_init(void);
void app_uart_close(void);
// 发送数据
int8_t uart0_send_msg(uint8_t *msg_data, uint16_t msg_data_len, uint32_t timeout);
void uart0_printf(char *str, ...);
void app_printf (char *str, ...); void app_printf (char *str, ...);

206
custom/custom_main/src/app_uart.c
View File

@ -39,100 +39,109 @@
#endif #endif
typedef struct{
int msg_type;
} uart_event_msg_t;
#define UART_BUF_LEN 1024 #define UART_BUF_LEN 1024
static int rx_rev_len = 0; static int rx_rev_len = 0;
static char rx_rev_data[UART_BUF_LEN] = {0}; static char rx_rev_data[UART_BUF_LEN] = {0};
static osThreadId_t os_UART_ThreadId = NULL; //串口数据接收、解析任务Handle static osThreadId_t os_UART_RX_ThreadId = NULL; //串口数据接收、解析任务Handle
static osThreadId_t uart_event_thread = NULL; static osSemaphoreId_t uart_rx_sem = NULL; // 接收数据信号量
static void* g_uart_sem = NULL; static osThreadId_t os_UART_TX_ThreadId = NULL; //串口数据发送任务Handle
static osMessageQueueId_t uart_event_queue = NULL; static osMessageQueueId_t uart_tx_msg_queue = NULL; // 发送消息队列
static osSemaphoreId_t uart_tx_ack_sem = NULL; // 发送成功应答信号量
// 用于测试串口事件，用户可参考
static void uart_event_task(void *arg){
uart_event_msg_t msg = {0};
while (1) {
if (osMessageQueueGet(uart_event_queue, &msg, NULL, osWaitForever) == osOK) {
//cm_log_printf(0, "uart event msg type = %d\n", msg.msg_type);
if (CM_UART_EVENT_TYPE_RX_OVERFLOW & msg.msg_type){
app_printf("CM_UART_EVENT_TYPE_RX_OVERFLOW... ...\r\n");
cm_uart_read(APP_URAT, (void*)&rx_rev_data[0], UART_BUF_LEN, 1000);
cm_uart_read(APP_URAT, (void*)&rx_rev_data[0], UART_BUF_LEN, 1000);
cm_uart_read(APP_URAT, (void*)&rx_rev_data[0], UART_BUF_LEN, 1000);
cm_uart_read(APP_URAT, (void*)&rx_rev_data[0], UART_BUF_LEN, 1000);
}
}
}
}
// 用于测试串口事件，用户可参考
static int uart_event_task_create(void){
if (uart_event_queue == NULL){
uart_event_queue = osMessageQueueNew(10, sizeof(uart_event_msg_t), NULL);
}
if (uart_event_thread == NULL) {
osThreadAttr_t attr1 = {
.name = "uart_event",
.priority = APP_UART_TASK_PRIORITY,
.stack_size = 1024,
};
uart_event_thread = osThreadNew(uart_event_task, NULL, (const osThreadAttr_t*)&attr1);
}
return 0;
}
typedef struct{
uint16_t msg_data_len; // 发送数据长度
uint8_t *msg_data; // 发送数据缓存
}uart_tx_msg_t;
/* 串口接收示例，平时使用信号量挂起，当收到接收事件后，释放信号量以触发读取任务 */ /* 串口接收示例，平时使用信号量挂起，当收到接收事件后，释放信号量以触发读取任务 */
static void Uart_TaskHandle(void *param){ static void Uart_RX_TaskHandle(void *param){
int temp_len = 0; int temp_len = 0;
while (1){ while (1){
if (g_uart_sem != NULL){ if (uart_rx_sem != NULL){
osSemaphoreAcquire(g_uart_sem, osWaitForever);//阻塞 osSemaphoreAcquire(uart_rx_sem, osWaitForever);//阻塞
} }
if (rx_rev_len < UART_BUF_LEN){ temp_len = cm_uart_read(APP_URAT, (void*)&rx_rev_data[rx_rev_len], UART_BUF_LEN, 1000);
temp_len = cm_uart_read(APP_URAT, (void*)&rx_rev_data[rx_rev_len], UART_BUF_LEN - rx_rev_len, 1000); rx_rev_len += temp_len;
rx_rev_len += temp_len; if (rx_rev_len < UART_BUF_LEN){ // 处理数据
}
app_printf("uart rev data len = %d\n", rx_rev_len);
/* 后续用于SDK测试，用户可酌情参考*/ memset((void*)rx_rev_data, 0, rx_rev_len);
if (g_uart_sem != NULL && (strstr(rx_rev_data, "\r\n"))){ temp_len = 0;
//处理收到数据事件
cm_uart_write(APP_URAT, rx_rev_data, rx_rev_len, 1000);
memset((void*)rx_rev_data, 0, sizeof(rx_rev_data));
rx_rev_len = 0; rx_rev_len = 0;
} }
// app_printf("uart rev data len = %d\n", rx_rev_len);
// if (uart_rx_sem != NULL && (strstr(rx_rev_data, "\r\n"))){
// //处理收到数据事件
// cm_uart_write(APP_URAT, rx_rev_data, rx_rev_len, 1000);
// memset((void*)rx_rev_data, 0, sizeof(rx_rev_data));
// rx_rev_len = 0;
// }
} }
} }
// 发送数据
int8_t uart0_send_msg(uint8_t *msg_data, uint16_t msg_data_len, uint32_t timeout){
uart_tx_msg_t tx_msg={0};
if(msg_data_len > UART_BUF_LEN){
cm_uart_write(APP_URAT, "msg_data_len too long\r\n", 23, 1000);
return -3; //数据长度过长
}
uint8_t *p_data =cm_malloc(msg_data_len);
if(p_data == NULL){
cm_uart_write(APP_URAT, "malloc error\r\n", 14, 1000);
return -2;//内存不足
}
memcpy(p_data, msg_data, msg_data_len);
tx_msg.msg_data_len = msg_data_len;
tx_msg.msg_data = p_data;
if(osOK == osMessageQueuePut(uart_tx_msg_queue, &tx_msg, 0, 20)){ // 发送消息队列满时，阻塞100ms
osSemaphoreAcquire(uart_tx_ack_sem, timeout);
}else{
cm_free(tx_msg.msg_data);
tx_msg.msg_data = NULL;
cm_uart_write(APP_URAT, "send msg queue full\r\n", 22, 1000);
return -1;
}
return 0;
}
static void Uart_TX_TaskHandle(void *param){
uart_tx_msg_t send_msg={0};
uint16_t temp_len = 0;
while(1){
if(osOK == osMessageQueueGet(uart_tx_msg_queue, &send_msg, NULL, osWaitForever)){
temp_len =cm_uart_write(APP_URAT, (void*)send_msg.msg_data, send_msg.msg_data_len, 1000);
if(temp_len == send_msg.msg_data_len){
osSemaphoreRelease(uart_tx_ack_sem); //发送成功，释放信号量
}else{
// app_printf("uart tx send error,len=%d\n", temp_len);
}
send_msg.msg_data_len = 0;
if(send_msg.msg_data != NULL){
cm_free(send_msg.msg_data);
send_msg.msg_data = NULL;
}
}
}
}
// 串口事件回调函数// 回调函数中不可输出LOG、串口打印、执行复杂任务或消耗过多资源，建议以信号量或消息队列形式控制其他线程执行任务 // 串口事件回调函数// 回调函数中不可输出LOG、串口打印、执行复杂任务或消耗过多资源，建议以信号量或消息队列形式控制其他线程执行任务
static void app_uart_event_callback(void *param, uint32_t type){ static void app_uart_event_callback(void *param, uint32_t type){
uart_event_msg_t msg = {0};
if (CM_UART_EVENT_TYPE_RX_ARRIVED & type){ if (CM_UART_EVENT_TYPE_RX_ARRIVED & type){
/* 收到接收事件，触发其他线程执行读取数据 */ /* 收到接收事件，触发其他线程执行读取数据 */
osSemaphoreRelease(g_uart_sem); osSemaphoreRelease(uart_rx_sem);
} }
if (CM_UART_EVENT_TYPE_RX_OVERFLOW & type){ if (CM_UART_EVENT_TYPE_RX_OVERFLOW & type){
/* 收到溢出事件，触发其他线程处理溢出事件 */ /* 收到溢出事件，触发其他线程处理溢出事件 */
msg.msg_type = type; osSemaphoreRelease(uart_rx_sem); // 触发读取任务
if (uart_event_queue != NULL){//向队列发送数据
osMessageQueuePut(uart_event_queue, &msg, 0, 0);
}
} }
} }
@ -179,30 +188,56 @@ void app_uart_init(void){
// cm_iomux_set_pin_cmd(APP_UARTRX_IOMUX , CM_IOMUX_PINCMD1_LPMEDEG, CM_IOMUX_PINCMD1_FUNC1_LPM_EDGE_RISE); // cm_iomux_set_pin_cmd(APP_UARTRX_IOMUX , CM_IOMUX_PINCMD1_LPMEDEG, CM_IOMUX_PINCMD1_FUNC1_LPM_EDGE_RISE);
// 串口接收处理任务 // 串口接收处理任务
osThreadAttr_t uart_task_attr = {0}; osThreadAttr_t uart_rx_task_attr = {
uart_task_attr.name = "uart_task"; .name = "uart_rx_task",
uart_task_attr.stack_size = 2048; .stack_size = 4096,
uart_task_attr.priority= APP_UART_TASK_PRIORITY; .priority= APP_UART_TASK_PRIORITY
};
os_UART_RX_ThreadId= osThreadNew(Uart_RX_TaskHandle, 0, &uart_rx_task_attr);
os_UART_ThreadId= osThreadNew(Uart_TaskHandle, 0, &uart_task_attr); if (uart_rx_sem == NULL) {
uart_rx_sem = osSemaphoreNew(1, 0, NULL);
if (g_uart_sem == NULL) {
g_uart_sem = osSemaphoreNew(1, 0, NULL);
} }
uart_event_task_create();
if(uart_tx_msg_queue == NULL){
uart_tx_msg_queue = osMessageQueueNew(10, sizeof(uart_tx_msg_t), NULL);
}
if (uart_tx_ack_sem == NULL) {
uart_tx_ack_sem = osSemaphoreNew(1, 0, NULL);
}
osThreadAttr_t uart_tx_task_attr = {
.name = "uart_tx_task",
.stack_size = 2048,
.priority= APP_UART_TASK_PRIORITY
};
os_UART_TX_ThreadId= osThreadNew(Uart_TX_TaskHandle, 0, &uart_tx_task_attr);
} }
/* 关闭串口 */ // /* 关闭串口 */
void app_uart_close(void){ // void app_uart_close(void){
cm_uart_dev_e dev = CM_UART_DEV_0; // cm_uart_dev_e dev = CM_UART_DEV_0;
if (0 == cm_uart_close(dev)){ // if (0 == cm_uart_close(dev)){
app_printf("uart%d close is ok\n", dev); // app_printf("uart%d close is ok\n", dev);
}else{ // }else{
app_printf("uart%d close is error\n", dev); // app_printf("uart%d close is error\n", dev);
// }
// }
void uart0_printf(char *str, ...){
static char s[600]; //This needs to be large enough to store the string TODO Change magic number
va_list args;
int len;
if ((str == NULL) || (strlen(str) == 0)){
return;
} }
}
va_start(args, str);
len = vsnprintf((char*)s, 600, str, args);
va_end(args);
uart0_send_msg((uint8_t*)s, len, 0);
}
void app_printf(char *str, ...){ void app_printf(char *str, ...){
static char s[600]; //This needs to be large enough to store the string TODO Change magic number static char s[600]; //This needs to be large enough to store the string TODO Change magic number
@ -217,5 +252,6 @@ void app_printf(char *str, ...){
va_start(args, str); va_start(args, str);
len = vsnprintf((char*)s, 600, str, args); len = vsnprintf((char*)s, 600, str, args);
va_end(args); va_end(args);
cm_uart_write(APP_URAT, s, len, 1000); // cm_uart_write(APP_URAT, s, len, 1000);
uart0_send_msg((uint8_t*)s, len, 0);
} }

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

@ -21,122 +21,12 @@
#include "jt808_msg_parse.h" #include "jt808_msg_parse.h"
#include "jt808_pkg_transmit.h" #include "jt808_pkg_transmit.h"
#include "tcp_client.h" #include "tcp_client.h"
#include "control_out.h"
#include "local_tts.h" #include "local_tts.h"
#define SECOND_OF_DAY (24*60*60)
typedef struct cm_tm {
int tm_sec; /* 秒 – 取值区间为[0,59] */
int tm_min; /* 分 - 取值区间为[0,59] */
int tm_hour; /* 时 - 取值区间为[0,23] */
int tm_mday; /* 一个月中的日期 - 取值区间为[1,31] */
int tm_mon; /* 月份 */
int tm_year; /* 年份 */
}cm_tm_t;
// static const char * weekday[] = {"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};
// static const char DayOfMon[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
osThreadId_t OC_APP_TaskHandle; osThreadId_t OC_APP_TaskHandle;
// void oc_ring_cb(unsigned char *param)
// {
// if(0 == strncmp((char *)param, "\r\nRING",6))//来电提示
// {
// app_printf("oc_ring_cb:%s\n",param);
// }
// else if (0 == strncmp((char *)param, "\r\n+CLCC:",8)) //来电信息
// {
// app_printf("oc_ring_cb:%s\n",param);
// }
// else if(0 == strncmp((char *)param, "\r\nNO CARRIER",12))//对方挂断
// {
// app_printf("oc_ring_cb:%s\n",param);
// }
// if (0 == strncmp((char *)param, "\r\n+CMTI:",8))//短信信息
// {
// app_printf("message:%s\n",param);
// }
// }
// static void cm_sec_to_date(long lSec, cm_tm_t *tTime)
// {
// unsigned short i,j,iDay;
// unsigned long lDay;
// lDay = lSec / SECOND_OF_DAY;
// lSec = lSec % SECOND_OF_DAY;
// i = 1970;
// while(lDay > 365)
// {
// if(((i%4==0)&&(i%100!=0)) || (i%400==0))
// {
// lDay -= 366;
// }
// else
// {
// lDay -= 365;
// }
// i++;
// }
// if((lDay == 365) && !(((i%4==0)&&(i%100!=0)) || (i%400==0)))
// {
// lDay -= 365;
// i++;
// }
// tTime->tm_year = i;
// for(j=0;j<12;j++)
// {
// if((j==1) && (((i%4==0)&&(i%100!=0)) || (i%400==0)))
// {
// iDay = 29;
// }
// else
// {
// iDay = DayOfMon[j];
// }
// if(lDay >= iDay) lDay -= iDay;
// else break;
// }
// tTime->tm_mon = j+1;
// tTime->tm_mday = lDay+1;
// tTime->tm_hour = ((lSec / 3600))%24;//这里注意，世界时间已经加上北京时间差8，
// tTime->tm_min = (lSec % 3600) / 60;
// tTime->tm_sec = (lSec % 3600) % 60;
// }
// static uint8_t cm_time_to_weekday(cm_tm_t *t)
// {
// uint32_t u32WeekDay = 0;
// uint32_t u32Year = t->tm_year;
// uint8_t u8Month = t->tm_mon;
// uint8_t u8Day = t->tm_mday;
// if(u8Month < 3U)
// {
// /*D = { [(23 x month) / 9] + day + 4 + year + [(year - 1) / 4] - [(year - 1) / 100] + [(year - 1) / 400] } mod 7*/
// u32WeekDay = (((23U * u8Month) / 9U) + u8Day + 4U + u32Year + ((u32Year - 1U) / 4U) - ((u32Year - 1U) / 100U) + ((u32Year - 1U) / 400U)) % 7U;
// }
// else
// {
// /*D = { [(23 x month) / 9] + day + 4 + year + [year / 4] - [year / 100] + [year / 400] - 2 } mod 7*/
// u32WeekDay = (((23U * u8Month) / 9U) + u8Day + 4U + u32Year + (u32Year / 4U) - (u32Year / 100U) + (u32Year / 400U) - 2U ) % 7U;
// }
// if (0U == u32WeekDay)
// {
// u32WeekDay = 7U;
// }
// return (uint8_t)u32WeekDay;
// }
void print_network_info(void){ void print_network_info(void){
cm_cereg_state_t cereg_state = {0}; cm_cereg_state_t cereg_state = {0};
@ -157,11 +47,11 @@ void print_network_info(void){
} }
} }
led_status_t led_status = {0}; led_status_t led_status = {0};
osEventFlagsId_t LED_EventFlags = NULL; osEventFlagsId_t LED_EventFlags = NULL;
void my_appimg_enter(char *param){ void my_appimg_enter(char *param){
// cm_gpio_level_e level = 0;
LED_EventFlags =osEventFlagsNew(NULL); LED_EventFlags =osEventFlagsNew(NULL);
if(NULL == LED_EventFlags){ if(NULL == LED_EventFlags){
@ -175,35 +65,10 @@ void my_appimg_enter(char *param){
cm_gpio_init(CM_GPIO_NUM_0, &cfg); cm_gpio_init(CM_GPIO_NUM_0, &cfg);
cm_gpio_set_level(CM_GPIO_NUM_0, 0); cm_gpio_set_level(CM_GPIO_NUM_0, 0);
// cm_iomux_set_pin_func(CM_IOMUX_PIN_77, CM_IOMUX_FUNC_FUNCTION2);//初始化之前一定要先设置引脚复用
// cm_gpio_init(CM_GPIO_NUM_13, &cfg);
// cm_gpio_set_level(CM_GPIO_NUM_13, 0);
app_uart_init(); app_uart_init();
app_printf("Hello, world!\r\n");
// adc_dac_init();
local_tts_init();
local_tts_mute(0);// 取消静音
local_tts_volume(10); // 设置音量为5
local_tts_set(8, 15, CM_LOCAL_TTS_DIGIT_AUTO);
while(1){
cm_gpio_set_level(CM_GPIO_NUM_0, 1);
local_tts_text_play("欢迎使用莱昂特智能终端设备...。",0 ,osWaitForever); // 0:表示自动计算字符串长度,10000表示最大等待时间
// osDelay(3000/5);
cm_gpio_set_level(CM_GPIO_NUM_0, 0);
// osDelay(3000/5);
local_tts_text_play("欢迎使用游园猫，您的专属智能向导。",0 ,osWaitForever); // 0:表示自动计算字符串长度,10000表示最大等待时间
}
//-------------------------------------------- //--------------------------------------------
{ {
// cm_tm_t t;
// int i;
int ret;
char buf[CM_VER_LEN] = {0}; char buf[CM_VER_LEN] = {0};
int pdp_time_out=0;
cm_fs_system_info_t info = {0, 0}; cm_fs_system_info_t info = {0, 0};
cm_heap_stats_t stats = {0}; cm_heap_stats_t stats = {0};
app_printf("\n\n\n\n\n"); app_printf("\n\n\n\n\n");
@ -214,23 +79,46 @@ void my_appimg_enter(char *param){
cm_mem_get_heap_stats(&stats); cm_mem_get_heap_stats(&stats);
app_printf("fs total:%d,remain:%d\n", info.total_size, info.free_size); app_printf("fs total:%d,remain:%d\n", info.total_size, info.free_size);
app_printf("heap total:%d,remain:%d\n",stats.total_size,stats.free); app_printf("heap total:%d,remain:%d\n",stats.total_size,stats.free);
// app_printf("waiting for network...\n");
// while(1){
// if(pdp_time_out>10){
// app_printf("network timeout\n");
// break;
// }
// if(cm_modem_get_pdp_state(1) == 1){
// app_printf("network ready\n");
// break;
// }
// osDelay(200);
// pdp_time_out++;
// }
} }
// ----------------------------------------------------- // -----------------------------------------------------
local_tts_init();
local_tts_mute(0);// 取消静音
// local_tts_volume(100); // 设置音量为5
// local_tts_set(6, 15, CM_LOCAL_TTS_DIGIT_AUTO);
// osDelay(300/5); // 等待初始化完成
control_out_init();
// /*
while(1){
// // cm_gpio_set_level(CM_GPIO_NUM_0, 1);
// cm_gpio_set_pull(CM_GPIO_NUM_0, CM_GPIO_PULL_UP);
// cm_gpio_set_direction(CM_GPIO_NUM_0, CM_GPIO_DIRECTION_INPUT);
// // app_printf("set_level 1\r\n");
// if(0 ==cm_gpio_get_level(CM_GPIO_NUM_0, &level)){ // 更新状态
// // app_printf("gpio_get_level:%d\r\n",level);
// }
// osDelay(800/5);
// cm_gpio_set_direction(CM_GPIO_NUM_0, CM_GPIO_DIRECTION_OUTPUT);
// cm_gpio_set_level(CM_GPIO_NUM_0, 0);
// // cm_gpio_set_pull(CM_GPIO_NUM_0, CM_GPIO_PULL_DOWN);
// // app_printf("set_level 0\r\n");
// if(0 ==cm_gpio_get_level(CM_GPIO_NUM_0, &level)){ // 更新状态
// // app_printf("gpio_get_level:%d\r\n",level);
// }
// osDelay(800/5);
cm_gpio_set_level(CM_GPIO_NUM_0, 1);
local_tts_text_play("欢迎使用...。",0 ,1,osWaitForever);
// osDelay(1000/5);
local_tts_text_play("测试1...。",0 ,0,0);
local_tts_text_play("测试2...。",0 ,1,0);
// osDelay(100/5);
cm_gpio_set_level(CM_GPIO_NUM_0, 0);
// osDelay(300/5);
local_tts_text_play("测试3",0 ,1,osWaitForever);
osDelay(5000/5);
}
// */
jt808_set_term_param_init(); jt808_set_term_param_init();
jt808_init(); jt808_init();
tcp_client_init(); tcp_client_init();
@ -289,7 +177,6 @@ void led_set_event(led_event_t event){
osEventFlagsSet(LED_EventFlags, event); osEventFlagsSet(LED_EventFlags, event);
} }
int cm_opencpu_entry(char * param) int cm_opencpu_entry(char * param)
{ {
osThreadAttr_t app_task_attr = {0}; osThreadAttr_t app_task_attr = {0};

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

@ -28,10 +28,19 @@ typedef enum {
ID_TxtMsgdelivery = 0x8300, // 文本信息下发 ID_TxtMsgdelivery = 0x8300, // 文本信息下发
ID_Car_Ctrl = 0x8500, // 车辆控制 ID_Car_Ctrl = 0x8500, // 车辆控制
ID_Car_CtrlResp = 0x0500, // 车辆控制应答 ID_Car_CtrlResp = 0x0500, // 车辆控制应答
} MessageID_t; ID_Data_Down = 0x8900, // 数据透传下行
ID_Data_Up = 0x0900, // 数据透传上行
}MessageID_t;
#pragma pack(1) #pragma pack(1)
// ----------------------------- 协议消息体结构体定义 ---------- // ----------------------------- 协议消息体结构体定义 ----------
typedef enum{
Msg_ok = 0, // 成功
Msg_err = 1, // 失败
Msg_invalid = 2, // 消息有误//无效
Msg_no_support = 3, // 不支持
}Msg_result_t;
// 终端通用应答体（0x0001） // 终端通用应答体（0x0001）
typedef struct { typedef struct {
uint16_t msg_flow_num; // 对应的平台消息的流水号 uint16_t msg_flow_num; // 对应的平台消息的流水号
@ -287,6 +296,18 @@ typedef struct {
uint32_t eff_time; // 追踪有效时间，单位为秒（s） uint32_t eff_time; // 追踪有效时间，单位为秒（s）
}LocTrackingCtrl_t; }LocTrackingCtrl_t;
// 文本信息下发体（0x8300）
typedef struct {
uint8_t flag_bit; // 标志位
uint8_t *TxtString; // 文本信息字符串
}TxtMsgdelivery_t;
// 数据透传体（0x8900/0x0900）
typedef struct {
uint8_t Msg_type; // 数据类型
uint8_t *Msg_Data; // 数据内容
uint16_t Msg_Data_Len; // 数据长度
}Data_SeriaNet_t;
// ------------------------------ 协议帧结构体定义 ---------- // ------------------------------ 协议帧结构体定义 ----------
// 转义相关标识 // 转义相关标识
typedef enum { typedef enum {

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

@ -42,6 +42,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; // 临时位置跟踪控制
Data_SeriaNet_t big_data_up_SeriaNet; // 数据上行透传
}Term_Param_item_t; }Term_Param_item_t;
#pragma pack() #pragma pack()
@ -55,6 +56,11 @@ void jt808_Set_CarStatus(uint8_t status);
// 获取车辆状态 // 获取车辆状态
uint8_t jt808_Get_CarStatus(void); uint8_t jt808_Get_CarStatus(void);
// 串口数据下传
int8_t jt808_data_down_SeriaNet(uint8_t type, uint8_t *data, uint16_t len);
// 串口数据上传
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);

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

@ -1,17 +1,18 @@
#include "jt808_msg_parse.h" #include "jt808_msg_parse.h"
#include "jt808_pkg_transmit.h" #include "jt808_pkg_transmit.h"
#include "local_tts.h"
PrsResult_t PrsResult; PrsResult_t PrsResult;
// 消息体解析 // 消息体解析
static int jt808_BodyParse(void *Prsmsg_body, PrsResult_t *PrsResult){ static int jt808_BodyParse(void *Prsmsg_body, PrsResult_t *Result){
switch (PrsResult->msg_head.msg_id){ switch (Result->msg_head.msg_id){
case ID_Plat_GenResp:{// 平台通用应答 case ID_Plat_GenResp:{// 平台通用应答
memcpy(&(PrsResult->Rsp_flow_num), Prsmsg_body, sizeof(Plat_GenResp_t)); memcpy(&(Result->Rsp_flow_num), Prsmsg_body, sizeof(Plat_GenResp_t));
// 转小端 // 转小端
PrsResult->Rsp_flow_num = Swap16(PrsResult->Rsp_flow_num); Result->Rsp_flow_num = Swap16(Result->msg_head.msg_flow_num);
PrsResult->Rsp_msg_id = Swap16(PrsResult->Rsp_msg_id); Result->Rsp_msg_id = Swap16(Result->msg_head.msg_id);
// PrsResult->Rsp_result = PrsResult->Rsp_result; // Result->Rsp_result = Result->Rsp_result;
break; break;
} }
case ID_FillPktReq:{// 补传分包请求 case ID_FillPktReq:{// 补传分包请求
@ -19,34 +20,36 @@ static int jt808_BodyParse(void *Prsmsg_body, PrsResult_t *PrsResult){
break; break;
} }
case ID_Term_RegResp:{// 终端注册应答 case ID_Term_RegResp:{// 终端注册应答
PrsResult->Rsp_flow_num = (uint16_t)(((uint8_t *)Prsmsg_body)[0] << 8) | (((uint8_t *)Prsmsg_body)[1]); Result->Rsp_flow_num = (uint16_t)(((uint8_t *)Prsmsg_body)[0] << 8) | (((uint8_t *)Prsmsg_body)[1]);
PrsResult->Rsp_result = ((uint8_t *)Prsmsg_body)[2]; Result->Rsp_result = ((uint8_t *)Prsmsg_body)[2];
if(PrsResult->Rsp_result == 0){ // 成功时，读取鉴权码 if(Result->Rsp_result == Msg_ok){ // 成功时，读取鉴权码
if(PrsResult->term_param_item->big_auth_info.str_auth_code != NULL){ if(Result->term_param_item->big_auth_info.str_auth_code != NULL){
jt808_free(PrsResult->term_param_item->big_auth_info.str_auth_code); jt808_free(Result->term_param_item->big_auth_info.str_auth_code);
PrsResult->term_param_item->big_auth_info.str_auth_code = NULL; Result->term_param_item->big_auth_info.str_auth_code = NULL;
} }
PrsResult->term_param_item->big_auth_info.str_auth_code = (char *)jt808_malloc(PrsResult->msg_head.msgbody_attr.msgbodylen - 3 +1); // 加1是为了加上结束符 Result->term_param_item->big_auth_info.str_auth_code = (char *)jt808_malloc(Result->msg_head.msgbody_attr.msgbodylen - 3 +1); // 加1是为了加上结束符
if(PrsResult->term_param_item->big_auth_info.str_auth_code == NULL){ if(Result->term_param_item->big_auth_info.str_auth_code == NULL){
JT808_DEBUG("[%s,%s] malloc failed\r\n", __FUNCTION__,__LINE__); JT808_DEBUG("[%s,%s] malloc failed\r\n", __FUNCTION__,__LINE__);
return -1; return -1;
} }
memset(PrsResult->term_param_item->big_auth_info.str_auth_code, 0, PrsResult->msg_head.msgbody_attr.msgbodylen - 3 +1); memset(Result->term_param_item->big_auth_info.str_auth_code, 0, Result->msg_head.msgbody_attr.msgbodylen - 3 +1);
memcpy(PrsResult->term_param_item->big_auth_info.str_auth_code, Prsmsg_body + 3 , PrsResult->msg_head.msgbody_attr.msgbodylen - 3); memcpy(Result->term_param_item->big_auth_info.str_auth_code, Prsmsg_body + 3 , Result->msg_head.msgbody_attr.msgbodylen - 3);
} }
break; break;
} }
case ID_SetTermParams:{// 设置终端参数 case ID_SetTermParams:{// 设置终端参数
PrsResult->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; uint16_t param_lenoffset = 1;
for(int i = 0; i < PrsResult->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(Swap32(*(uint32_t *)(Prsmsg_body + param_lenoffset)), // 参数ID
(void *)(Prsmsg_body + param_lenoffset + 5), // 参数值 (void *)(Prsmsg_body + param_lenoffset + 5), // 参数值
*((uint8_t*)(Prsmsg_body + param_lenoffset + 4))); // 参数长度 *((uint8_t*)(Prsmsg_body + param_lenoffset + 4))); // 参数长度
param_lenoffset += 5 + (*((uint8_t*)(Prsmsg_body + param_lenoffset + 4))); // 参数ID(4) + 参数长度(1) + 参数值(n) param_lenoffset += 5 + (*((uint8_t*)(Prsmsg_body + param_lenoffset + 4))); // 参数ID(4) + 参数长度(1) + 参数值(n)
} }
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);// 发送终端通用应答 jt808_pkg_send(ID_Term_GenResp, 0);// 发送终端通用应答
break; break;
} }
@ -78,11 +81,55 @@ static int jt808_BodyParse(void *Prsmsg_body, PrsResult_t *PrsResult){
break; break;
} }
case ID_Car_Ctrl:{// 车辆控制 case ID_TxtMsgdelivery:{// 文本信息下发
uint8_t device_volume, speed, volume, mode;
device_volume =10*(((uint8_t *)Prsmsg_body)[0]-'0') + (((uint8_t *)Prsmsg_body)[1]-'0');
speed =10*(((uint8_t *)Prsmsg_body)[3]-'0') + (((uint8_t *)Prsmsg_body)[4]-'0');
volume =10*(((uint8_t *)Prsmsg_body)[6]-'0') + (((uint8_t *)Prsmsg_body)[7]-'0');
mode = ((uint8_t *)Prsmsg_body)[9]-'0';
Result->Rsp_result = Msg_ok;
if((((uint8_t *)Prsmsg_body)[2] == ',')&&(((uint8_t *)Prsmsg_body)[5] == ',')&&(((uint8_t *)Prsmsg_body)[8] == ',')&&(((uint8_t *)Prsmsg_body)[10] == ';')){ // 文本信息下发
if(speed > 0 && speed <= 15 && volume > 0 && volume <= 15 && mode >= 0 && mode <= 2){ // 速度、音量、模式有效
local_tts_volume(device_volume); // 设置音量大小
local_tts_set(speed, volume, mode);
}else{
JT808_DEBUG("error speed or volume or mode\r\n");
local_tts_volume(80); // 设置音量大小
local_tts_set(7, 15, CM_LOCAL_TTS_DIGIT_AUTO);
Result->Rsp_result = Msg_invalid;//消息有误
}
}else{
JT808_DEBUG("error speed or volume or mode\r\n");
local_tts_volume(80); // 设置音量大小
local_tts_set(7, 15, CM_LOCAL_TTS_DIGIT_AUTO);
Result->Rsp_result = Msg_invalid;//消息有误
}
local_tts_text_play((char *)Prsmsg_body + 11, Result->msg_head.msgbody_attr.msgbodylen -11,1,0); // 开始播放文本信息//不等待播放完成
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_Car_Ctrl:{// 车辆控制
jt808_Set_CarStatus(((uint8_t *)Prsmsg_body)[0]); // 设置车辆状态
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_Car_CtrlResp, 0);// 发送车辆控制应答，设置本消息无发送应答 jt808_pkg_send(ID_Car_CtrlResp, 0);// 发送车辆控制应答，设置本消息无发送应答
break; break;
} }
case ID_Data_Down:{// 数据下行透传
jt808_data_down_SeriaNet(((uint8_t *)Prsmsg_body)[0],((uint8_t *)Prsmsg_body) + 1, Result->msg_head.msgbody_attr.msgbodylen - 1); // 透传数据
Result->Rsp_flow_num = Result->msg_head.msg_flow_num;
Result->Rsp_msg_id = Result->msg_head.msg_id;
Result->Rsp_result = Msg_ok;
jt808_pkg_send(ID_Term_GenResp, 0);// 发送终端通用应答
// JT808_DEBUG("ID_Data_Down\r\n");
break;
}
default:{ default:{
return -2; // 没有对应的消息体解析函数 return -2; // 没有对应的消息体解析函数
break; break;
@ -92,7 +139,7 @@ static int jt808_BodyParse(void *Prsmsg_body, PrsResult_t *PrsResult){
} }
// jt808协议包处理 // jt808协议包处理
int jt808_msg_parse(const uint8_t *BufferReceive, uint16_t length, PrsResult_t *PrsResult){ int jt808_msg_parse(const uint8_t *BufferReceive, uint16_t length, PrsResult_t *Result){
uint8_t *raw_Buffer = (uint8_t *)jt808_malloc(length * sizeof(uint8_t)); uint8_t *raw_Buffer = (uint8_t *)jt808_malloc(length * sizeof(uint8_t));
if(raw_Buffer == NULL){ if(raw_Buffer == NULL){
JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__); JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
@ -160,17 +207,21 @@ int jt808_msg_parse(const uint8_t *BufferReceive, uint16_t length, PrsResult_t *
jt808_free(para_Buffer); jt808_free(para_Buffer);
return -1; return -1;
} }
// 解析消息头 // 解析消息头
memcpy(&PrsResult->msg_head, para_Buffer + 1, sizeof(MsgHead_t) - ((para_Buffer[3] & 0x02)==0? 4 : 0)); memcpy(&Result->msg_head, para_Buffer + 1, sizeof(MsgHead_t) - ((para_Buffer[3] & 0x02)==0? 4 : 0));
PrsResult->msg_head.msg_id = Swap16(PrsResult->msg_head.msg_id);// 消息ID Result->msg_head.msg_id = Swap16(Result->msg_head.msg_id);// 消息ID
PrsResult->msg_head.msgbody_attr.val16 = Swap16(PrsResult->msg_head.msgbody_attr.val16);// 消息体属性 Result->msg_head.msgbody_attr.val16 = Swap16(Result->msg_head.msgbody_attr.val16);// 消息体属性
PrsResult->msg_head.msg_flow_num = Swap16(PrsResult->msg_head.msg_flow_num);// 消息流水号 Result->msg_head.msg_flow_num = Swap16(Result->msg_head.msg_flow_num);// 消息流水号
PrsResult->msg_head.total_packet = Swap16(PrsResult->msg_head.total_packet);// 总包数, 分包情况下使用 Result->msg_head.total_packet = Swap16(Result->msg_head.total_packet);// 总包数, 分包情况下使用
PrsResult->msg_head.packet_seq = Swap16(PrsResult->msg_head.packet_seq);// 当前包序号, 分包情况下使用 Result->msg_head.packet_seq = Swap16(Result->msg_head.packet_seq);// 当前包序号, 分包情况下使用
JT808_DEBUG("RECV Msg_ID:0x%04X len:%d\r\n", Result->msg_head.msg_id ,para_length);
for(uint16_t i = 0; i < para_length; i++){
app_printf("%02X ", *(para_Buffer + i));
}
// 消息体解析 // 消息体解析
if(0 != jt808_BodyParse((void *)(para_Buffer + 1 + sizeof(MsgHead_t) - ((para_Buffer[3] & 0x02)==0? 4 : 0)) ,PrsResult)){ if(0 != jt808_BodyParse((void *)(para_Buffer + 1 + sizeof(MsgHead_t) - ((para_Buffer[3] & 0x02)==0? 4 : 0)) ,Result)){
JT808_DEBUG("error jt808_BodyParse\r\n"); JT808_DEBUG("error jt808_BodyParse\r\n");
// 释放内存 // 释放内存
jt808_free(para_Buffer); jt808_free(para_Buffer);

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

@ -74,33 +74,33 @@ static int jt808_BodyPackage(JT808_2013_MsgFrame_t *p_MsgFrame, MessageID_t Msg_
break; break;
} }
case ID_GetTermParamsResp:{ // 查询终端参数应答 case ID_GetTermParamsResp:{ // 查询终端参数应答
p_MsgFrame->msg_head.msgbody_attr.msgbodylen = sizeof(GetTermParamsResp_t);// 消息体长度 // p_MsgFrame->msg_head.msgbody_attr.msgbodylen = sizeof(GetTermParamsResp_t);// 消息体长度
GetTermParamsResp_t *get_term_params_resp = (GetTermParamsResp_t *)jt808_realloc(p_MsgFrame->p_msg_body, sizeof(GetTermParamsResp_t)); // GetTermParamsResp_t *get_term_params_resp = (GetTermParamsResp_t *)jt808_realloc(p_MsgFrame->p_msg_body, sizeof(GetTermParamsResp_t));
if(get_term_params_resp == NULL){ // if(get_term_params_resp == NULL){
JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__); // JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
return -1; // return -1;
} // }
p_MsgFrame->p_msg_body = (void *)get_term_params_resp; // p_MsgFrame->p_msg_body = (void *)get_term_params_resp;
break; break;
} }
case ID_GetTermAttrResp:{ // 查询终端属性应答 case ID_GetTermAttrResp:{ // 查询终端属性应答
p_MsgFrame->msg_head.msgbody_attr.msgbodylen = sizeof(GetTermAttrResp_t);// 消息体长度 // p_MsgFrame->msg_head.msgbody_attr.msgbodylen = sizeof(GetTermAttrResp_t);// 消息体长度
GetTermAttrResp_t *get_term_attr_resp = (GetTermAttrResp_t *)jt808_realloc(p_MsgFrame->p_msg_body, sizeof(GetTermAttrResp_t)); // GetTermAttrResp_t *get_term_attr_resp = (GetTermAttrResp_t *)jt808_realloc(p_MsgFrame->p_msg_body, sizeof(GetTermAttrResp_t));
if(get_term_attr_resp == NULL){ // if(get_term_attr_resp == NULL){
JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__); // JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
return -1; // return -1;
} // }
p_MsgFrame->p_msg_body = (void *)get_term_attr_resp; // p_MsgFrame->p_msg_body = (void *)get_term_attr_resp;
break; break;
} }
case ID_Term_UpgradeResult:{ // 终端升级结果通知 case ID_Term_UpgradeResult:{ // 终端升级结果通知
p_MsgFrame->msg_head.msgbody_attr.msgbodylen = sizeof(Term_UpgradeResult_t);// 消息体长度 // p_MsgFrame->msg_head.msgbody_attr.msgbodylen = sizeof(Term_UpgradeResult_t);// 消息体长度
Term_UpgradeResult_t *term_upgrade_result = (Term_UpgradeResult_t *)jt808_realloc(p_MsgFrame->p_msg_body, sizeof(Term_UpgradeResult_t)); // Term_UpgradeResult_t *term_upgrade_result = (Term_UpgradeResult_t *)jt808_realloc(p_MsgFrame->p_msg_body, sizeof(Term_UpgradeResult_t));
if(term_upgrade_result == NULL){ // if(term_upgrade_result == NULL){
JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__); // JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
return -1; // return -1;
} // }
p_MsgFrame->p_msg_body = (void *)term_upgrade_result; // p_MsgFrame->p_msg_body = (void *)term_upgrade_result;
break; break;
} }
case ID_LocReport:{ // 位置信息汇报 case ID_LocReport:{ // 位置信息汇报
@ -130,15 +130,66 @@ static int jt808_BodyPackage(JT808_2013_MsgFrame_t *p_MsgFrame, MessageID_t Msg_
break; break;
} }
case ID_GetLocInfoResp:{ // 查询位置信息应答 case ID_GetLocInfoResp:{ // 查询位置信息应答
p_MsgFrame->msg_head.msgbody_attr.msgbodylen = sizeof(GetLocInfoResp_t);// 消息体长度 // p_MsgFrame->msg_head.msgbody_attr.msgbodylen = sizeof(GetLocInfoResp_t);// 消息体长度
GetLocInfoResp_t *get_loc_info_resp = (GetLocInfoResp_t *)jt808_realloc(p_MsgFrame->p_msg_body, sizeof(GetLocInfoResp_t)); // GetLocInfoResp_t *get_loc_info_resp = (GetLocInfoResp_t *)jt808_realloc(p_MsgFrame->p_msg_body, sizeof(GetLocInfoResp_t));
if(get_loc_info_resp == NULL){ // if(get_loc_info_resp == NULL){
// JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
// return -1;
// }
// p_MsgFrame->p_msg_body = (void *)get_loc_info_resp;
break;
}
case ID_Car_CtrlResp:{ // 车辆控制应答
p_MsgFrame->msg_head.msgbody_attr.msgbodylen =2 + sizeof(Loc_basic_info_t);// 消息体长度
Loc_addi_info_t *p_loc_addi_info = PrsResult.term_param_item->big_loc_report.addi_info;
while(p_loc_addi_info != NULL){ // 计算附加信息长度
p_MsgFrame->msg_head.msgbody_attr.msgbodylen += p_loc_addi_info->msg_len + 2;
p_loc_addi_info = p_loc_addi_info->next;
}
uint8_t *Car_CtrlResp_buf = (uint8_t *)jt808_malloc(p_MsgFrame->msg_head.msgbody_attr.msgbodylen);
if(Car_CtrlResp_buf == NULL){
JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__); JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
return -1; return -1;
} }
p_MsgFrame->p_msg_body = (void *)get_loc_info_resp; Car_CtrlResp_buf[0] = (PrsResult.msg_head.msg_flow_num >>8) & 0xFF; // 对应的车辆控制消息的流水号
Car_CtrlResp_buf[1] = PrsResult.msg_head.msg_flow_num & 0xFF; // 对应的车辆控制消息的流水号
memcpy(Car_CtrlResp_buf + 2, &PrsResult.term_param_item->big_loc_report, sizeof(Loc_basic_info_t)); // 复制基本信息内容
p_loc_addi_info = PrsResult.term_param_item->big_loc_report.addi_info;
uint16_t loc_report_offset =2 + sizeof(Loc_basic_info_t);
uint8_t loc_len = 0;
while(p_loc_addi_info != NULL){ // 填充附加信息内容
loc_len= p_loc_addi_info->msg_len + 2;
memcpy(Car_CtrlResp_buf + loc_report_offset, &p_loc_addi_info->msg_id, 2);
memcpy(Car_CtrlResp_buf + loc_report_offset + 2, p_loc_addi_info->msg, p_loc_addi_info->msg_len);
loc_report_offset += loc_len;
p_loc_addi_info = p_loc_addi_info->next;
}
p_MsgFrame->p_msg_body = (void *)Car_CtrlResp_buf;
break; break;
} }
case ID_Data_Up:{// 数据上行透传
uint8_t *up_SeriaNet_buf = NULL;
if(NULL != PrsResult.term_param_item->big_data_up_SeriaNet.Msg_Data){
up_SeriaNet_buf = (uint8_t *)jt808_malloc(PrsResult.term_param_item->big_data_up_SeriaNet.Msg_Data_Len + 1);
if(up_SeriaNet_buf == NULL){
JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
return -1;
}
up_SeriaNet_buf[0] = PrsResult.term_param_item->big_data_up_SeriaNet.Msg_type;
memcpy(up_SeriaNet_buf + 1, PrsResult.term_param_item->big_data_up_SeriaNet.Msg_Data,
PrsResult.term_param_item->big_data_up_SeriaNet.Msg_Data_Len); // 复制数据内容
p_MsgFrame->p_msg_body = (void *)up_SeriaNet_buf; //
jt808_free(PrsResult.term_param_item->big_data_up_SeriaNet.Msg_Data); // 释放数据内存
PrsResult.term_param_item->big_data_up_SeriaNet.Msg_Data = NULL;
PrsResult.term_param_item->big_data_up_SeriaNet.Msg_Data_Len = 0;
PrsResult.term_param_item->big_data_up_SeriaNet.Msg_type = 0;
}
// JT808_DEBUG("ID_Data_Up\r\n");
break;
}
default: default:
return -2; return -2;
break; break;
@ -151,7 +202,6 @@ static int jt808_BodyPackage(JT808_2013_MsgFrame_t *p_MsgFrame, MessageID_t Msg_
int jt808_msg_pkg(MessageID_t Msg_ID, JT808MsgESC_t *msgEscape){ int jt808_msg_pkg(MessageID_t Msg_ID, JT808MsgESC_t *msgEscape){
JT808_2013_MsgFrame_t big_MsgFrame;// 定义大端消息帧 JT808_2013_MsgFrame_t big_MsgFrame;// 定义大端消息帧
JT808_DEBUG("BodyPackage ID:0x%04X\r\n", Msg_ID);
big_MsgFrame.p_msg_body = NULL; big_MsgFrame.p_msg_body = NULL;
if(0 != jt808_BodyPackage(&big_MsgFrame, Msg_ID)){// 填充消息体 （注意释放p_msg_body内存） if(0 != jt808_BodyPackage(&big_MsgFrame, Msg_ID)){// 填充消息体 （注意释放p_msg_body内存）
JT808_DEBUG("jt808_BodyPackage failed\r\n"); JT808_DEBUG("jt808_BodyPackage failed\r\n");
@ -161,7 +211,7 @@ int jt808_msg_pkg(MessageID_t Msg_ID, JT808MsgESC_t *msgEscape){
uint16_t msg_total_len = 1 + sizeof(MsgHead_t) - (1 ==big_MsgFrame.msg_head.msgbody_attr.packet ? 0 : 4); uint16_t msg_total_len = 1 + sizeof(MsgHead_t) - (1 ==big_MsgFrame.msg_head.msgbody_attr.packet ? 0 : 4);
uint16_t msgbody_len =big_MsgFrame.msg_head.msgbody_attr.msgbodylen; uint16_t msgbody_len =big_MsgFrame.msg_head.msgbody_attr.msgbodylen;
msg_total_len += msgbody_len + 2; msg_total_len += msgbody_len + 2;
JT808_DEBUG("total_len:%d,len:%d\r\n", msg_total_len, msgbody_len); // JT808_DEBUG("total_len:%d,len:%d\r\n", msg_total_len, msgbody_len);
big_MsgFrame.Head_SIGN = PSIGN; big_MsgFrame.Head_SIGN = PSIGN;
big_MsgFrame.Tail_SIGN = PSIGN; big_MsgFrame.Tail_SIGN = PSIGN;
@ -241,7 +291,7 @@ int jt808_msg_pkg(MessageID_t Msg_ID, JT808MsgESC_t *msgEscape){
// 返回消息帧总长度 // 返回消息帧总长度
msgEscape->len = msg_total_len + escape_len; msgEscape->len = msg_total_len + escape_len;
app_printf("msgEscape->buf:%d\r\n", msg_total_len + escape_len); JT808_DEBUG("SEND Msg_ID:0x%04X len:%d\r\n", Msg_ID ,msg_total_len + escape_len);
for(uint16_t i = 0; i < msg_total_len + escape_len; i++){ for(uint16_t i = 0; i < msg_total_len + escape_len; i++){
app_printf("%02X ", *(msgEscape->buf + i)); app_printf("%02X ", *(msgEscape->buf + i));
} }

14
custom/jt808/src/jt808_pkg_transmit.c
View File

@ -10,7 +10,7 @@ int jt808_pkg_send(MessageID_t Msg_ID, uint32_t timeout){
pkg_msg_t send_pkg_msg={0}; pkg_msg_t send_pkg_msg={0};
send_pkg_msg.msg_id = Msg_ID; send_pkg_msg.msg_id = Msg_ID;
send_pkg_msg.timeout = timeout; send_pkg_msg.timeout = timeout;
JT808_DEBUG("send pkg_msg:%04x\n", Msg_ID); // JT808_DEBUG("send pkg_msg:%04x\n", Msg_ID);
if(osOK == osMessageQueuePut(jt808_send_msg_queue, &send_pkg_msg, 0, 0)){ // if(osOK == osMessageQueuePut(jt808_send_msg_queue, &send_pkg_msg, 0, 0)){ //
if(0 < timeout){ // 阻塞等待发送回应 if(0 < timeout){ // 阻塞等待发送回应
@ -34,7 +34,7 @@ int jt808_pkg_send(MessageID_t Msg_ID, uint32_t timeout){
void jt808_pkg_handle(uint8_t *receive_buf, uint16_t receive_len){ void jt808_pkg_handle(uint8_t *receive_buf, uint16_t receive_len){
if(0 ==jt808_msg_parse(receive_buf, receive_len, &PrsResult)){ // 解析协议数据 if(0 ==jt808_msg_parse(receive_buf, receive_len, &PrsResult)){ // 解析协议数据
osSemaphoreRelease(jt808_parse_ok_sem); // 释放解析完成信号量 osSemaphoreRelease(jt808_parse_ok_sem); // 释放解析完成信号量
JT808_DEBUG("jt808_msg_parse success\n"); // JT808_DEBUG("jt808_msg_parse success\n");
} }
} }
@ -54,13 +54,13 @@ static void jt808_pkg_send_task(void *arg){
JT808_DEBUG("MsgESC.buf is NULL:len=%d\n",MsgESC.len); JT808_DEBUG("MsgESC.buf is NULL:len=%d\n",MsgESC.len);
continue; continue;
} }
JT808_DEBUG("tcp send %d bytes\n", MsgESC.len); // JT808_DEBUG("tcp send %d bytes\n", MsgESC.len);
if(0 == PKG_SEND(MsgESC.buf, MsgESC.len)){ // 发送成功处理 if(0 == PKG_SEND(MsgESC.buf, MsgESC.len)){ // 发送成功处理
if(NULL != jt808_parse_ok_sem){ if(NULL != jt808_parse_ok_sem){
osStatus_t ret =osSemaphoreAcquire(jt808_parse_ok_sem, send_pkg_msg.timeout);// 等待接收数据并解析完成 osStatus_t ret =osSemaphoreAcquire(jt808_parse_ok_sem, send_pkg_msg.timeout);// 等待接收数据并解析完成
if(ret == osOK || 0 == send_pkg_msg.timeout){ if(ret == osOK || 0 == send_pkg_msg.timeout){
osSemaphoreRelease(jt808_send_ack_sem); // 释放发送成功应答信号量 osSemaphoreRelease(jt808_send_ack_sem); // 释放发送成功应答信号量
JT808_DEBUG("parse success\n"); // JT808_DEBUG("parse success\n");
if(PrsResult.term_param_item!= NULL){ // 协议参数项不为空 if(PrsResult.term_param_item!= NULL){ // 协议参数项不为空
PrsResult.term_param_item->msg_flow_num++; // 协议流水号+1 PrsResult.term_param_item->msg_flow_num++; // 协议流水号+1
}else{ }else{
@ -76,7 +76,7 @@ static void jt808_pkg_send_task(void *arg){
} }
} }
if(MsgESC.buf!= NULL){ // 释放发送缓存 if(MsgESC.buf!= NULL){ // 释放发送缓存
JT808_DEBUG("jt808_free MsgESC.buf\n"); // JT808_DEBUG("jt808_free MsgESC.buf\n");
jt808_free(MsgESC.buf); jt808_free(MsgESC.buf);
MsgESC.buf = NULL; MsgESC.buf = NULL;
} }
@ -87,7 +87,7 @@ static void jt808_pkg_send_task(void *arg){
// jt808协议初始化 // jt808协议初始化
int jt808_init(void){ int jt808_init(void){
if(jt808_send_msg_queue == NULL){ if(jt808_send_msg_queue == NULL){
jt808_send_msg_queue = osMessageQueueNew(1, sizeof(pkg_msg_t), NULL); jt808_send_msg_queue = osMessageQueueNew(3, sizeof(pkg_msg_t), NULL);
} }
if(jt808_send_ack_sem == NULL){ if(jt808_send_ack_sem == NULL){
jt808_send_ack_sem = osSemaphoreNew(1, 0, NULL); jt808_send_ack_sem = osSemaphoreNew(1, 0, NULL);
@ -97,7 +97,7 @@ int jt808_init(void){
} }
osThreadAttr_t jt808_pkg_send_task_attr = { osThreadAttr_t jt808_pkg_send_task_attr = {
.name = "jt808_pkg_send_task", .name = "jt808_pkg_send_task",
.stack_size = 1024, .stack_size = 4096,
.priority = osPriorityNormal, .priority = osPriorityNormal,
}; };
jt808_pkg_send_ThreadId = osThreadNew((osThreadFunc_t)jt808_pkg_send_task, 0, &jt808_pkg_send_task_attr); jt808_pkg_send_ThreadId = osThreadNew((osThreadFunc_t)jt808_pkg_send_task, 0, &jt808_pkg_send_task_attr);

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

@ -20,6 +20,49 @@ uint8_t jt808_Get_CarStatus(void){
return 0; return 0;
} }
// 串口数据下传
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++){
app_printf("%02X ", data[i]);
}
app_printf("\r\n");
}else if(type == 0x42){ // 串口2下传
JT808_DEBUG("Serial2 data: ");
for(uint16_t i = 0; i < len; i++){
app_printf("%02X ", data[i]);
}
app_printf("\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;
}
// 设置终端参数 // 设置终端参数
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){

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

@ -22,6 +22,7 @@ uint8_t local_tts_volume(uint8_t volume);
void local_tts_set(int32_t speed, int32_t volume, cm_local_tts_digit_e mode); void local_tts_set(int32_t speed, int32_t volume, cm_local_tts_digit_e mode);
// 本地TTS播放 // 本地TTS播放
int8_t local_tts_text_play(char *text, uint8_t len, uint32_t timeout); // en_break=1时使能打断播放 //timeout=0时表示播放忙时，取消播放
int8_t local_tts_text_play(char *text, uint8_t len, uint8_t en_break, uint32_t timeout);
#endif // __LOCAL_TTS_H__ #endif // __LOCAL_TTS_H__

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

@ -21,34 +21,14 @@
#endif #endif
static osMessageQueueId_t local_tts_play_queue = NULL; static osMessageQueueId_t local_tts_play_queue = NULL;
static osSemaphoreId_t local_tts_play_ok_sem = NULL; static osSemaphoreId_t local_tts_play_ok_sem = NULL;
static osSemaphoreId_t local_tts_play_stat_sem = NULL;
static int32_t TTS_play_finish_flag = 0; //播放完成标志位 0-完成 !=0-未完成
/* 离线TTS回调函数 */ typedef struct{
static void __local_tts_callback(cm_local_tts_event_e event, void *param) cm_local_tts_cfg_t tts_cfg;
{ char *text;
switch(event){ uint8_t len;
case CM_LOCAL_TTS_EVENT_SYNTH_DATA:{ }tts_play_queue_t;
// cm_local_tts_synth_data_t *data = (cm_local_tts_synth_data_t *)param;
// DEBUG("[%s] SYNTH_DATA [%d] \n", data->user, data->len); //打印log操作较费时
break;
}
case CM_LOCAL_TTS_EVENT_SYNTH_FAIL:
case CM_LOCAL_TTS_EVENT_SYNTH_INTERRUPT:
case CM_LOCAL_TTS_EVENT_SYNTH_FINISH:
break;
case CM_LOCAL_TTS_EVENT_PLAY_FAIL:
DEBUG("[%s] PLAY_FAIL\n", (char *)param);
break;
case CM_LOCAL_TTS_EVENT_PLAY_INTERRUPT:
DEBUG("[[%s] PLAY_INTERRUPT\n", (char *)param);
break;
case CM_LOCAL_TTS_EVENT_PLAY_FINISH:
DEBUG("[%s] PLAY_FINISH\n", (char *)param);
osSemaphoreRelease(local_tts_play_ok_sem); // 释放发送成功应答信号量
break;
default:
break;
}
}
// 静音 mute: 0-关闭 1-打开 // 静音 mute: 0-关闭 1-打开
void local_tts_mute(uint8_t mute){ void local_tts_mute(uint8_t mute){
@ -71,32 +51,57 @@ uint8_t local_tts_volume(uint8_t volume){
// volume: 音量，取值范围0-15，默认为5 // volume: 音量，取值范围0-15，默认为5
// mode: 0-自动模式 1-数字模式,2-数值模式 // mode: 0-自动模式 1-数字模式,2-数值模式
void local_tts_set(int32_t speed, int32_t volume, cm_local_tts_digit_e mode){ void local_tts_set(int32_t speed, int32_t volume, cm_local_tts_digit_e mode){
cm_local_tts_deinit();
cm_local_tts_cfg_t tts_cfg = {0};
tts_cfg.speed = speed;
tts_cfg.volume = volume;
tts_cfg.encode = CM_LOCAL_TTS_ENCODE_TYPE_UTF8; // 离线TTS仅支持UTF8格式
tts_cfg.digit = mode;
if(0 == cm_local_tts_init(&tts_cfg)){
DEBUG("tts set:speed %d,volume %d,encode %d,digit %d\n" , tts_cfg.speed, tts_cfg.volume, tts_cfg.encode, tts_cfg.digit);
}else{
DEBUG("tts set error\n");
}
osDelay(100/5); // 等待初始化完成
}
typedef struct{
char *text;
uint8_t len;
}tts_play_queue_t;
// 发送本地TTS播放内容 //timeout=osWaitForever时表示等待播放完成
int8_t local_tts_text_play(char *text, uint8_t len, uint32_t timeout){
tts_play_queue_t tts_play_queue = {0}; tts_play_queue_t tts_play_queue = {0};
tts_play_queue.text = NULL;
tts_play_queue.len = 1;
tts_play_queue.tts_cfg.speed = speed;
tts_play_queue.tts_cfg.volume = volume;
tts_play_queue.tts_cfg.encode = CM_LOCAL_TTS_ENCODE_TYPE_UTF8; // 离线TTS仅支持UTF8格式
tts_play_queue.tts_cfg.digit = mode;
DEBUG("tts set:speed %d,volume %d,encode %d,digit %d\n" , tts_play_queue.tts_cfg.speed, tts_play_queue.tts_cfg.volume, tts_play_queue.tts_cfg.encode, tts_play_queue.tts_cfg.digit);
if(osOK != osMessageQueuePut(local_tts_play_queue, &tts_play_queue, 0, 0)){
DEBUG("tts play queue put error\n");
}
// cm_local_tts_deinit();
// cm_local_tts_cfg_t tts_cfg = {0};
// tts_cfg.speed = speed;
// tts_cfg.volume = volume;
// tts_cfg.encode = CM_LOCAL_TTS_ENCODE_TYPE_UTF8; // 离线TTS仅支持UTF8格式
// tts_cfg.digit = mode;
// if(0 == cm_local_tts_init(&tts_cfg)){
// DEBUG("tts set:speed %d,volume %d,encode %d,digit %d\n" , tts_cfg.speed, tts_cfg.volume, tts_cfg.encode, tts_cfg.digit);
// }else{
// DEBUG("tts set error\n");
// }
// osDelay(100/5); // 等待初始化完成
}
// 发送本地TTS播放内容 //timeout=osWaitForever时表示等待播放完成 //len=0时自动计算长度
// en_break=1时使能打断播放 //timeout=0时表示播放忙时，取消播放
int8_t local_tts_text_play(char *text, uint8_t len, uint8_t en_break, uint32_t timeout){
DEBUG("tts play text:%s,len:%d,en_break:%d,timeout:%d\n", text, len, en_break, timeout);
// if((en_break == 0) && (TTS_play_finish_flag != 0)){
// if(TTS_play_finish_flag < 0){
// TTS_play_finish_flag = 0;
// }
// DEBUG("tts play busy\n");
// return -1;
// }
// if((en_break == 1)||(TTS_play_finish_flag < 0)){// 使能打断播放
// TTS_play_finish_flag = 0;
// }
if((en_break == 1) && (TTS_play_finish_flag != 0)){
cm_local_tts_play_stop(); // 停止播放
while(TTS_play_finish_flag==0){//等待转码结束
osDelay(50/5); // 等待播放停止
}
// osSemaphoreAcquire(local_tts_play_stat_sem, 300/5);// 等待播放结束
}
tts_play_queue_t tts_play_queue = {0};
local_tts_mute(0); // 取消静音 local_tts_mute(0); // 取消静音
if(0 == len || len > strlen(text)){ if(0 == len || len > strlen(text)){
@ -116,27 +121,80 @@ int8_t local_tts_text_play(char *text, uint8_t len, uint32_t timeout){
cm_free(tts_play_queue.text); cm_free(tts_play_queue.text);
return -1; return -1;
} }
TTS_play_finish_flag =1; //播放完成标志位 0-完成 !=0-未完成
// 等待播放完成 // 等待播放完成
osSemaphoreAcquire(local_tts_play_ok_sem, timeout); osSemaphoreAcquire(local_tts_play_ok_sem, timeout);
DEBUG("tts play queue put success\n"); DEBUG("tts play queue put success\n");
return 0; return 0;
} }
/* 离线TTS回调函数 */
static void __local_tts_callback(cm_local_tts_event_e event, void *param)
{
switch(event){
case CM_LOCAL_TTS_EVENT_SYNTH_DATA:{
// cm_local_tts_synth_data_t *data = (cm_local_tts_synth_data_t *)param;
// DEBUG("[%s] SYNTH_DATA [%d] \n", data->user, data->len); //打印log操作较费时
break;
}
case CM_LOCAL_TTS_EVENT_SYNTH_FAIL:
case CM_LOCAL_TTS_EVENT_SYNTH_INTERRUPT:
case CM_LOCAL_TTS_EVENT_SYNTH_FINISH:
break;
case CM_LOCAL_TTS_EVENT_PLAY_FAIL:
DEBUG("[%s] PLAY_FAIL\n", (char *)param);
break;
case CM_LOCAL_TTS_EVENT_PLAY_INTERRUPT:
DEBUG("[[%s] PLAY_INTERRUPT\n", (char *)param);
break;
case CM_LOCAL_TTS_EVENT_PLAY_FINISH:
DEBUG("[%s] PLAY_FINISH\n", (char *)param);
// TTS_play_finish_flag =0; //播放完成标志位 0-完成 !=0-未完成
osSemaphoreRelease(local_tts_play_ok_sem); // 释放发送成功应答信号量
osSemaphoreRelease(local_tts_play_stat_sem);
break;
default:
break;
}
}
// 异步播放，播放完成后播放下一条 //TODO: 待优化（暂时方案，打断播放） // 异步播放，播放完成后播放下一条 //TODO: 待优化（暂时方案，打断播放）
static osThreadFunc_t local_tts_play_task(void *arg){ static osThreadFunc_t local_tts_play_task(void *arg){
tts_play_queue_t tts_play_queue; tts_play_queue_t tts_play_queue;
osStatus_t ret=0;
while(1){ while(1){
if(osOK == osMessageQueueGet(local_tts_play_queue, &tts_play_queue, NULL, osWaitForever)){ // if(osOK == osMessageQueueGet(local_tts_play_queue, &tts_play_queue, NULL, osWaitForever)){ //
DEBUG("tts play stop\n");
cm_local_tts_play_stop(); // 停止播放 // cm_local_tts_play_stop(); // 停止播放
osDelay(200/5); // 等待播放停止 // osDelay(300/5); // 等待播放停止
if(tts_play_queue.text == NULL){ if(tts_play_queue.text == NULL){
if(tts_play_queue.len != 0){
tts_play_queue.len = 0;
cm_local_tts_deinit();
if(15 < tts_play_queue.tts_cfg.speed){tts_play_queue.tts_cfg.speed = 15;}
if(15 < tts_play_queue.tts_cfg.volume){tts_play_queue.tts_cfg.volume = 15;}
if(0 == cm_local_tts_init(&tts_play_queue.tts_cfg)){
DEBUG("TASK:speed %d,volume %d,encode %d,digit %d\n", tts_play_queue.tts_cfg.speed, tts_play_queue.tts_cfg.volume, tts_play_queue.tts_cfg.encode, tts_play_queue.tts_cfg.digit);
}else{
DEBUG("tts set error\n");
}
osDelay(200/5);
}
DEBUG("tts play text is null\n"); DEBUG("tts play text is null\n");
continue; continue;
} }
DEBUG("tts play start\n"); DEBUG("tts play start\n");
cm_local_tts_play(tts_play_queue.text, tts_play_queue.len, __local_tts_callback,"Chinese"); // TTS_play_finish_flag =1; //播放完成标志位 0-完成 !=0-未完成
cm_local_tts_play(tts_play_queue.text, tts_play_queue.len, __local_tts_callback, "Chinese");
TTS_play_finish_flag =2; //播放完成标志位 0-完成 !=0-未完成
ret =osSemaphoreAcquire(local_tts_play_stat_sem, 60000/5);// 等待播放结束
if(osOK != ret){
DEBUG("tts play queue stat error:%d\n", ret);
}
TTS_play_finish_flag =0; //播放完成标志位 0-完成 !=0-未完成
DEBUG("tts play stop\n");
cm_free(tts_play_queue.text); cm_free(tts_play_queue.text);
tts_play_queue.text = NULL; tts_play_queue.text = NULL;
} }
@ -152,22 +210,38 @@ void local_tts_init(void){
cm_iomux_set_pin_func(CM_IOMUX_PIN_77, CM_IOMUX_FUNC_FUNCTION2);//初始化之前一定要先设置引脚复用 cm_iomux_set_pin_func(CM_IOMUX_PIN_77, CM_IOMUX_FUNC_FUNCTION2);//初始化之前一定要先设置引脚复用
cm_gpio_init(CM_GPIO_NUM_13, &cfg); cm_gpio_init(CM_GPIO_NUM_13, &cfg);
local_tts_mute(1); // 开启静音
local_tts_mute(1); // 关闭静音
local_tts_volume(100); // 设置音量为50 local_tts_volume(100); // 设置音量为50
local_tts_set(7, 5, CM_LOCAL_TTS_DIGIT_AUTO); // 设置TTS转换参数 cm_local_tts_deinit();
cm_local_tts_cfg_t tts_cfg={
.speed = 5,
.volume = 15,
.encode = CM_LOCAL_TTS_ENCODE_TYPE_UTF8, // 离线TTS仅支持UTF8格式
.digit = CM_LOCAL_TTS_DIGIT_AUTO, // 自动模式
};
if(0 == cm_local_tts_init(&tts_cfg)){
DEBUG("local_tts_init:speed %d,volume %d,encode %d,digit %d\n", tts_cfg.speed, tts_cfg.volume, tts_cfg.encode, tts_cfg.digit);
}else{
DEBUG("local_tts_init error\n");
}
osDelay(200/5); // 等待初始化完成
if(local_tts_play_queue == NULL){ if(local_tts_play_queue == NULL){
local_tts_play_queue = osMessageQueueNew(10, sizeof(tts_play_queue_t), NULL); local_tts_play_queue = osMessageQueueNew(1, sizeof(tts_play_queue_t), NULL);
} }
if(local_tts_play_ok_sem == NULL){ if(local_tts_play_ok_sem == NULL){
local_tts_play_ok_sem = osSemaphoreNew(1, 0, NULL); local_tts_play_ok_sem = osSemaphoreNew(1, 0, NULL);
} }
if(local_tts_play_stat_sem == NULL){
local_tts_play_stat_sem = osSemaphoreNew(1, 0, NULL);
}
osThreadAttr_t local_tts_play_thread_attr = { osThreadAttr_t local_tts_play_thread_attr = {
.name = "local_tts_play_thread", .name = "local_tts_play_thread",
.stack_size = 4096 * 4, .stack_size = 4096,
.priority = osPriorityNormal .priority = osPriorityNormal
}; };
osThreadNew((osThreadFunc_t)local_tts_play_task, NULL, &local_tts_play_thread_attr); osThreadNew((osThreadFunc_t)local_tts_play_task, NULL, &local_tts_play_thread_attr);
osDelay(200/5); // 等待初始化完成
} }

40
custom/radar/inc/radar.h Normal file
View File

@ -0,0 +1,40 @@
#ifndef _RADAR_H
#define _RADAR_H
#include "cm_os.h"
#define RADAR_BUFF_MAX 9
typedef struct radar_daraframe{
volatile uint16_t Front_data;
volatile uint16_t Back_data;
} radar_daraframe_t;
enum RADAR_MODE{
RADAR_MODE_Dispose = 0, //处理模式
RADAR_MODE_Real = 1, //实时模式
};
enum RADAR_ID{
RADAR_ID_Front = 0x01, //前雷达ID
RADAR_ID_Back = 0x02, //后雷达ID
};
typedef struct radar_data{
uint8_t radar_id;
uint16_t distance;
} radar_data_t;
extern radar_data_t radar_data;
// 雷达测离初始化
void radar_init(void);
//发送读取实时值数据命令
void radar_Sendcmd(uint8_t radar_id , uint8_t radar_mode);
// 数据接收处理函数
void radar_CheckData(uint8_t *data, uint16_t data_len);
uint16_t crc16_modbus(uint8_t *data, uint16_t length);
#endif /* _RADAR_H */

6
custom/radar/radar.mk Normal file
View File

@ -0,0 +1,6 @@
CUSTOM_MAIN_DIR := custom/radar
OC_FILES += $(CUSTOM_MAIN_DIR)/src/radar.c
INC += -I'$(CUSTOM_MAIN_DIR)/inc'

160
custom/radar/src/radar.c Normal file
View File

@ -0,0 +1,160 @@
#include "cm_iomux.h"
#include "cm_gpio.h"
#include "stdio.h"
#include "stdlib.h"
#include "stdarg.h"
#include "cm_os.h"
#include "cm_mem.h"
#include "cm_sys.h"
#include "cm_uart.h"
#include "app_common.h"
#include "app_uart.h"
#include "control_out.h"
#include "radar.h"
#include "local_tts.h"
#define RADAR_DEBUG_ENABLE 1
#if RADAR_DEBUG_ENABLE
#include "app_uart.h"
#define DEBUG(fmt, args...) app_printf("[RADAR]" fmt, ##args)
#else
#define DEBUG(fmt, arg...)
#endif
static osThreadId_t os_RADAR_ThreadId;
radar_data_t radar_data;
/******************************************************************************
* Name: CRC-16/MODBUS
* Poly: 0x8005 ( x16+x15+x2+1 )
* Init: 0xFFFF
* Refin: True
* Refout: True
* Xorout: 0x0000
*****************************************************************************/
uint16_t crc16_modbus(uint8_t *data, uint16_t length){
uint8_t i;
uint16_t crc = 0xFFFF; // Initial value
while(length--){
crc ^= *data++;
for (i = 0; i < 8; ++i){
if (crc & 1){
crc = (crc >> 1) ^ 0xA001; // 0xA001 = reverse 0x8005
}else{
crc = (crc >> 1);
}
}
}
return crc;
}
// 自动刹车或减速判断处理函数
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 Speed_Cut_Distance = ((radar_id == RADAR_ID_Back )? sys_conf.Speed_Cut_DLimit_B : sys_conf.Speed_Cut_DLimit);
if((35 < Car_Distance) && Car_Distance < Brake_Distance){//小于自动刹车距离时
if(!sys_sta.A_brake){
// local_tts_set(5, 15, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("自动刹车",0,1,0);
// Time_Event_Blink(Buzzer_Event,100,100,0xffff,NULL);
}
sys_sta.A_brake =1;//使能自动刹车
sys_sta.A_Speed_Cut=1;
}else if((35 < Car_Distance) && Car_Distance < Speed_Cut_Distance){//小于自动减速距离时
if(sys_sta.A_brake || !sys_sta.A_Speed_Cut){
// local_tts_set(5, 15, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("减速",0,1,0);
// Time_Event_Blink(Buzzer_Event,200,500,0xffff,NULL);
}
sys_sta.A_brake =0;
sys_sta.A_Speed_Cut=1;//使能自动减速
}else{
if(sys_sta.A_brake || sys_sta.A_Speed_Cut){
// local_tts_text_play("自动刹车",0,1,0);
// Time_Event_Off(Buzzer_Event,NULL);
}
sys_sta.A_brake =0;
sys_sta.A_Speed_Cut=0;
}
}
static uint8_t radar_CMDSend_cnt=0; // 发送命令计数
static uint8_t radar_CMDReceive_cnt=0; // 接收命令计数
//发送读取实时值数据命令
void radar_Sendcmd(uint8_t radar_id , uint8_t radar_mode){
uint8_t len=0;
uint8_t data[8];
data[len++] = radar_id;
data[len++] = 0x03;
data[len++] = 0x01;
data[len++] = radar_mode ? 0x01 : 0x00; // 0x01:实时值(120ms) 0x00:处理值(520ms)
data[len++] = 0x00;
data[len++] = 0x01;
uint16_t crc16 =crc16_modbus(data,len);
data[len++] = crc16 & 0xff;
data[len++] = (crc16 >> 8) & 0xff;
uart0_send_msg(data,len,0);
radar_CMDSend_cnt++;
}
// 数据接收处理函数
void radar_CheckData(uint8_t *data, uint16_t data_len){
if(data_len != 7){ // 数据长度不正确
return;
}
uint16_t crc16 =crc16_modbus(data, 5);
if((data[0] == RADAR_ID_Front) || (data[0] == RADAR_ID_Back) ||
(crc16 == (((uint16_t)data[6] << 8 ) | data[5]))){ // 雷达ID匹配
radar_data.radar_id = data[0];
radar_data.distance = ((uint16_t)data[3] << 8 ) | data[4];
radar_AUTO_BrakeORSpeedCut(radar_data.radar_id ,radar_data.distance);
radar_CMDReceive_cnt++;
}
}
// 定时处理数和获取数据
static void RADAR_TaskHandle(void *param){
uint8_t temp_count =0;
while(1){
if(radar_CMDSend_cnt != radar_CMDReceive_cnt){ // 发送命令和接收命令计数不一致时，复位自动刹车和减速状态
temp_count++;
if(temp_count > 10){ // 连续10次未收到数据，复位自动刹车和减速状态
temp_count =0;
radar_CMDSend_cnt =0; // 清空发送命令计数
radar_CMDReceive_cnt =0; // 清空接收命令计数
DEBUG("radar anomaly......"); // 雷达异常
radar_AUTO_BrakeORSpeedCut(radar_data.radar_id , 0); // 复位自动刹车和减速状态
}
}
// 进入游客模式开启雷达 //管理员模式优先于游客模式
if(((0 != sys_sta.O_door_lock) && ((1 == sys_sta.MAG_MODE)||(1 == sys_sta.PLT_MODE ))) && sys_sta.P_Radar_EN){
// 根据倒车状态确定雷达ID
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);
}
osDelay(140/5); // 140ms
}
}
// 雷达测离初始化
void radar_init(void){
radar_data.radar_id = RADAR_ID_Front;
radar_data.distance = 0;
osThreadAttr_t radar_task_attr = {
.name = "uart_tx_task",
.stack_size = 2048,
.priority= osPriorityNormal
};
os_RADAR_ThreadId= osThreadNew(RADAR_TaskHandle, 0, &radar_task_attr);
}

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

@ -9,7 +9,7 @@
#include "jt808_set_TermParam.h" #include "jt808_set_TermParam.h"
#include "tcp_client.h" #include "tcp_client.h"
#include "app_common.h" #include "app_common.h"
#include "local_tts.h"
#define TCP_CLIENT_ENABLE 1 #define TCP_CLIENT_ENABLE 1
@ -44,11 +44,11 @@ static void tcp_recv_task(void){
if(FD_ISSET(tcp_client_sock, &sets)){ // 套接字可读 if(FD_ISSET(tcp_client_sock, &sets)){ // 套接字可读
ret = recv(tcp_client_sock, buf, sizeof(buf), 0); ret = recv(tcp_client_sock, buf, sizeof(buf), 0);
if(ret > 0){ if(ret > 0){
DEBUG("tcp_read recv:%d\n", ret); // DEBUG("tcp_read recv:%d\n", ret);
for(int i = 0; i < ret; i++){ // for(int i = 0; i < ret; i++){
app_printf("%02x ", buf[i]); // app_printf("%02x ", buf[i]);
} // }
app_printf("\n\n"); // app_printf("\n\n");
// 处理接收到的数据 // 处理接收到的数据
jt808_pkg_handle(buf, ret); jt808_pkg_handle(buf, ret);
@ -147,6 +147,7 @@ static void net_manage_task(void *arg){
uint8_t error_time_out = 0; uint8_t error_time_out = 0;
while(1){ while(1){
TCP_DISABLE: TCP_DISABLE:
error_time_out = 0;
do{// 连接服务器 do{// 连接服务器
while(1){ // 等待插入SIM卡并建立网络连接 while(1){ // 等待插入SIM卡并建立网络连接
osDelay(1000/5); osDelay(1000/5);
@ -182,7 +183,7 @@ TCP_DISABLE:
// jt808_pkg_send(ID_Term_GenResp,5000/5); // jt808_pkg_send(ID_Term_GenResp,5000/5);
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,8000/5);//注册终端 超时：8S
if(0 == ret){ 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 < 3; i++){ for(uint8_t i = 0; i < 3; i++){
ret =jt808_pkg_send(ID_Term_Auth,10000/5);//终端鉴权 超时：10S ret =jt808_pkg_send(ID_Term_Auth,10000/5);//终端鉴权 超时：10S
@ -199,7 +200,7 @@ TCP_DISABLE:
break; break;
}else{ }else{
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;
} }
} }
@ -207,16 +208,23 @@ TCP_DISABLE:
jt808_Autoreport_param_start();//开启自动上报参数设置 jt808_Autoreport_param_start();//开启自动上报参数设置
led_set_event(EVENT_NETWORK_READY); // 网络连接成功 led_set_event(EVENT_NETWORK_READY); // 网络连接成功
DEBUG("\n\nNetwarK connected!\r\n\n");
// local_tts_set(5, 15, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("网络已连接",0,1,osWaitForever);
local_tts_text_play("欢迎使用莱昂特智能终端设备...。",0 , 1, osWaitForever); // 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("\n\nNetwarK disconnected!\r\n\n");
// local_tts_set(5, 15, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("网络已断开",0,1,0);
} }
} }
void tcp_client_init(void){ void tcp_client_init(void){
osThreadAttr_t net_manage_task_attr={ osThreadAttr_t net_manage_task_attr={
.name = "net_manage_task", .name = "net_manage_task",
.stack_size = 1024, .stack_size = 4096,
.priority = osPriorityNormal, .priority = osPriorityNormal,
}; };
DEBUG("tcp_client_init!\r\n"); DEBUG("tcp_client_init!\r\n");
@ -224,4 +232,5 @@ void tcp_client_init(void){
netconn_disconnect_sem = osSemaphoreNew(1, 0, NULL); netconn_disconnect_sem = osSemaphoreNew(1, 0, NULL);
} }
net_manage_ThreadId = osThreadNew((osThreadFunc_t)net_manage_task, 0, &net_manage_task_attr); net_manage_ThreadId = osThreadNew((osThreadFunc_t)net_manage_task, 0, &net_manage_task_attr);
osDelay(300/5); // 等待网络管理线程启动
} }

20
src/cm_lib/cm_tts_play/cm_tts_play.c
View File

@ -6,7 +6,7 @@
#include "cm_audio_player.h" #include "cm_audio_player.h"
#include "cm_audio_common.h" #include "cm_audio_common.h"
#define DEBUG_ENABLE 0 #define DEBUG_ENABLE 1
#if DEBUG_ENABLE #if DEBUG_ENABLE
#include "app_uart.h" #include "app_uart.h"
@ -15,7 +15,7 @@
#define DEBUG(fmt, arg...) #define DEBUG(fmt, arg...)
#endif #endif
#define CM_TTS_FRAME_BUFFER_SIZE (320 * 50 * 60) //支持存放10秒数据，可修改 #define CM_TTS_FRAME_BUFFER_SIZE (320 * 50 * 60) // (320 * 50 * 10)支持存放10秒数据，可修改
typedef struct { typedef struct {
osThreadId_t TaskHandle; /* TTS播放管理句柄 */ osThreadId_t TaskHandle; /* TTS播放管理句柄 */
@ -47,7 +47,7 @@ static void __cm_tts_play_callback(cm_local_tts_event_e event, void *param)
{ {
cm_tts_play_cfg.user_cb(event, param); cm_tts_play_cfg.user_cb(event, param);
} }
DEBUG("[TTS] [%s] CM_LOCAL_TTS_EVENT_SYNTH_DATA [%d] \n", synth_data->user, synth_data->len); DEBUG("SYNTH_DATA [%d] \n", synth_data->len);
break; break;
} }
case CM_LOCAL_TTS_EVENT_SYNTH_FAIL: case CM_LOCAL_TTS_EVENT_SYNTH_FAIL:
@ -174,13 +174,13 @@ int32_t cm_local_tts_play(const char *text, int32_t len, cm_local_tts_callback c
int32_t ret = cm_audio_player_stream_open(CM_AUDIO_PLAY_FORMAT_PCM, &frame); //从pipe中播放音频（开启） int32_t ret = cm_audio_player_stream_open(CM_AUDIO_PLAY_FORMAT_PCM, &frame); //从pipe中播放音频（开启）
if (-1 == ret){ if (-1 == ret){
DEBUG("%s() __%d__ cm_audio_player_stream_open0() error, ret is %d", __func__, __LINE__, ret); // DEBUG("%s() __%d__ cm_audio_player_stream_open0() error, ret is %d", __func__, __LINE__, ret);
cm_audio_player_stream_close(); // cm_audio_player_stream_close();
ret = cm_audio_player_stream_open(CM_AUDIO_PLAY_FORMAT_PCM, &frame); //从pipe中播放音频（开启） // ret = cm_audio_player_stream_open(CM_AUDIO_PLAY_FORMAT_PCM, &frame); //从pipe中播放音频（开启）
if (-1 == ret){ // if (-1 == ret){
DEBUG("%s() __%d__ cm_audio_player_stream_open1() error, ret is %d", __func__, __LINE__, ret); DEBUG("%s() __%d__ cm_audio_player_stream_open1() error, ret is %d", __func__, __LINE__, ret);
return -1; return -1;
} // }
} }
if (NULL == cm_tts_play_cfg.SemHandle) if (NULL == cm_tts_play_cfg.SemHandle)
@ -217,9 +217,9 @@ int32_t cm_local_tts_play(const char *text, int32_t len, cm_local_tts_callback c
cm_tts_play_cfg.user_cb_param = cb_param; cm_tts_play_cfg.user_cb_param = cb_param;
cm_tts_play_cfg.TtsPcmBufLen = 0; cm_tts_play_cfg.TtsPcmBufLen = 0;
cm_tts_play_cfg.state = CM_LOCAL_TTS_STATE_WORKING; cm_tts_play_cfg.state = CM_LOCAL_TTS_STATE_WORKING;
DEBUG("tts_synth_start\n\n========\n");
ret = cm_local_tts_synth(text, len, __cm_tts_play_callback, cb_param); ret = cm_local_tts_synth(text, len, __cm_tts_play_callback, cb_param);
DEBUG("tts_synth_end\n\n========\n");
if (0 == ret) if (0 == ret)
{ {
osSemaphoreRelease(cm_tts_play_cfg.SemHandle); osSemaphoreRelease(cm_tts_play_cfg.SemHandle);