From d8a6bc7f2a179ad533b472d090acdc6cfc7c64a5 Mon Sep 17 00:00:00 2001 From: zsx <1543588107@qq.com> Date: Sat, 23 Nov 2024 16:22:04 +0800 Subject: [PATCH] =?UTF-8?q?=E4=B8=B4=E6=97=B6=E6=8F=90=E4=BA=A4=EF=BC=8CTT?= =?UTF-8?q?S=E8=AF=AD=E9=9F=B3=E5=8A=9F=E8=83=BD=E5=BC=82=E5=B8=B8=20zsxfl?= =?UTF-8?q?y20241123?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- custom/GPS/src/gps_config.c | 4 +- custom/adc_dac/adc_dac.mk | 6 - custom/adc_dac/inc/adc_dac.h | 8 - custom/adc_dac/src/adc_dac.c | 81 -------- custom/control_out/control_out.mk | 6 + custom/control_out/inc/control_out.h | 73 +++++++ custom/control_out/src/control_out.c | 258 +++++++++++++++++++++++++ custom/custom.mk | 3 +- custom/custom_main/inc/app_uart.h | 4 +- custom/custom_main/src/app_uart.c | 210 +++++++++++--------- custom/custom_main/src/custom_main.c | 193 ++++-------------- custom/jt808/inc/jt808_protocol.h | 23 ++- custom/jt808/inc/jt808_set_TermParam.h | 6 + custom/jt808/src/jt808_msg_parse.c | 109 ++++++++--- custom/jt808/src/jt808_msg_pkg.c | 106 +++++++--- custom/jt808/src/jt808_pkg_transmit.c | 14 +- custom/jt808/src/jt808_set_TermParam.c | 43 +++++ custom/local_tts/inc/local_tts.h | 3 +- custom/local_tts/src/local_tts.c | 194 +++++++++++++------ custom/radar/inc/radar.h | 40 ++++ custom/radar/radar.mk | 6 + custom/radar/src/radar.c | 160 +++++++++++++++ custom/tcp_client/src/tcp_client.c | 27 ++- src/cm_lib/cm_tts_play/cm_tts_play.c | 20 +- 24 files changed, 1113 insertions(+), 484 deletions(-) delete mode 100644 custom/adc_dac/adc_dac.mk delete mode 100644 custom/adc_dac/inc/adc_dac.h delete mode 100644 custom/adc_dac/src/adc_dac.c create mode 100644 custom/control_out/control_out.mk create mode 100644 custom/control_out/inc/control_out.h create mode 100644 custom/control_out/src/control_out.c create mode 100644 custom/radar/inc/radar.h create mode 100644 custom/radar/radar.mk create mode 100644 custom/radar/src/radar.c diff --git a/custom/GPS/src/gps_config.c b/custom/GPS/src/gps_config.c index 7ec3e18..b23e0ba 100644 --- a/custom/GPS/src/gps_config.c +++ b/custom/GPS/src/gps_config.c @@ -33,7 +33,7 @@ static void* gps_uart_sem = NULL; //串口数据接收、解析任务信号量 */ void trace(const char *str, int str_size){ // 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_STOP_BIT_ONE, CM_UART_FLOW_CTRL_NONE, - CM_UART_BAUDRATE_9600, + CM_UART_BAUDRATE_115200, 0 //配置为普通串口模式，若要配置为低功耗模式可改为1 }; // 开启串口 diff --git a/custom/adc_dac/adc_dac.mk b/custom/adc_dac/adc_dac.mk deleted file mode 100644 index 789c4de..0000000 --- a/custom/adc_dac/adc_dac.mk +++ /dev/null @@ -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' \ No newline at end of file diff --git a/custom/adc_dac/inc/adc_dac.h b/custom/adc_dac/inc/adc_dac.h deleted file mode 100644 index 3c751b8..0000000 --- a/custom/adc_dac/inc/adc_dac.h +++ /dev/null @@ -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__ \ No newline at end of file diff --git a/custom/adc_dac/src/adc_dac.c b/custom/adc_dac/src/adc_dac.c deleted file mode 100644 index 20a2532..0000000 --- a/custom/adc_dac/src/adc_dac.c +++ /dev/null @@ -1,81 +0,0 @@ -#include "adc_dac.h" -#include -#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); -} - diff --git a/custom/control_out/control_out.mk b/custom/control_out/control_out.mk new file mode 100644 index 0000000..c08200d --- /dev/null +++ b/custom/control_out/control_out.mk @@ -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' \ No newline at end of file diff --git a/custom/control_out/inc/control_out.h b/custom/control_out/inc/control_out.h new file mode 100644 index 0000000..f1a0261 --- /dev/null +++ b/custom/control_out/inc/control_out.h @@ -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__ \ No newline at end of file diff --git a/custom/control_out/src/control_out.c b/custom/control_out/src/control_out.c new file mode 100644 index 0000000..f531345 --- /dev/null +++ b/custom/control_out/src/control_out.c @@ -0,0 +1,258 @@ +#include +#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); +} + diff --git a/custom/custom.mk b/custom/custom.mk index be8b3bf..1bbc31a 100644 --- a/custom/custom.mk +++ b/custom/custom.mk @@ -8,6 +8,7 @@ include $(CUSTOM_DIR)/nmealib/nmealib.mk include $(CUSTOM_DIR)/GPS/gps.mk include $(CUSTOM_DIR)/jt808/jt808.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)/radar/radar.mk endif \ No newline at end of file diff --git a/custom/custom_main/inc/app_uart.h b/custom/custom_main/inc/app_uart.h index 4ebb603..d4879e9 100644 --- a/custom/custom_main/inc/app_uart.h +++ b/custom/custom_main/inc/app_uart.h @@ -24,8 +24,10 @@ typedef struct 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, ...); diff --git a/custom/custom_main/src/app_uart.c b/custom/custom_main/src/app_uart.c index cea63c2..e418908 100644 --- a/custom/custom_main/src/app_uart.c +++ b/custom/custom_main/src/app_uart.c @@ -38,101 +38,110 @@ #define APP_UARTRX_IOMUX CM_IOMUX_PIN_51, CM_IOMUX_FUNC_FUNCTION3 #endif - -typedef struct{ - int msg_type; -} uart_event_msg_t; #define UART_BUF_LEN 1024 static int rx_rev_len = 0; static char rx_rev_data[UART_BUF_LEN] = {0}; -static osThreadId_t os_UART_ThreadId = NULL; //串口数据接收、解析任务Handle -static osThreadId_t uart_event_thread = NULL; +static osThreadId_t os_UART_RX_ThreadId = NULL; //串口数据接收、解析任务Handle +static osSemaphoreId_t uart_rx_sem = NULL; // 接收数据信号量 -static void* g_uart_sem = NULL; -static osMessageQueueId_t uart_event_queue = NULL; +static osThreadId_t os_UART_TX_ThreadId = NULL; //串口数据发送任务Handle +static osMessageQueueId_t uart_tx_msg_queue = NULL; // 发送消息队列 +static osSemaphoreId_t uart_tx_ack_sem = NULL; // 发送成功应答信号量 +typedef struct{ + uint16_t msg_data_len; // 发送数据长度 + uint8_t *msg_data; // 发送数据缓存 +}uart_tx_msg_t; -// 用于测试串口事件，用户可参考 -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; -} - - /* 串口接收示例，平时使用信号量挂起，当收到接收事件后，释放信号量以触发读取任务 */ -static void Uart_TaskHandle(void *param){ +static void Uart_RX_TaskHandle(void *param){ int temp_len = 0; while (1){ - if (g_uart_sem != NULL){ - osSemaphoreAcquire(g_uart_sem, osWaitForever);//阻塞 + if (uart_rx_sem != NULL){ + 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 - rx_rev_len, 1000); - rx_rev_len += temp_len; - } - app_printf("uart rev data len = %d\n", rx_rev_len); + temp_len = cm_uart_read(APP_URAT, (void*)&rx_rev_data[rx_rev_len], UART_BUF_LEN, 1000); + rx_rev_len += temp_len; + if (rx_rev_len < UART_BUF_LEN){ // 处理数据 - /* 后续用于SDK测试，用户可酌情参考*/ - if (g_uart_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; + memset((void*)rx_rev_data, 0, rx_rev_len); + temp_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、串口打印、执行复杂任务或消耗过多资源，建议以信号量或消息队列形式控制其他线程执行任务 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){ /* 收到接收事件，触发其他线程执行读取数据 */ - osSemaphoreRelease(g_uart_sem); + osSemaphoreRelease(uart_rx_sem); } - if (CM_UART_EVENT_TYPE_RX_OVERFLOW & type){ /* 收到溢出事件，触发其他线程处理溢出事件 */ - msg.msg_type = type; - - if (uart_event_queue != NULL){//向队列发送数据 - osMessageQueuePut(uart_event_queue, &msg, 0, 0); - } + osSemaphoreRelease(uart_rx_sem); // 触发读取任务 } } @@ -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); // 串口接收处理任务 - osThreadAttr_t uart_task_attr = {0}; - uart_task_attr.name = "uart_task"; - uart_task_attr.stack_size = 2048; - uart_task_attr.priority= APP_UART_TASK_PRIORITY; - - os_UART_ThreadId= osThreadNew(Uart_TaskHandle, 0, &uart_task_attr); + osThreadAttr_t uart_rx_task_attr = { + .name = "uart_rx_task", + .stack_size = 4096, + .priority= APP_UART_TASK_PRIORITY + }; + os_UART_RX_ThreadId= osThreadNew(Uart_RX_TaskHandle, 0, &uart_rx_task_attr); - if (g_uart_sem == NULL) { - g_uart_sem = osSemaphoreNew(1, 0, NULL); + if (uart_rx_sem == NULL) { + uart_rx_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){ - cm_uart_dev_e dev = CM_UART_DEV_0; +// /* 关闭串口 */ +// void app_uart_close(void){ +// cm_uart_dev_e dev = CM_UART_DEV_0; - if (0 == cm_uart_close(dev)){ - app_printf("uart%d close is ok\n", dev); - }else{ - app_printf("uart%d close is error\n", dev); - } -} +// if (0 == cm_uart_close(dev)){ +// app_printf("uart%d close is ok\n", dev); +// }else{ +// 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, ...){ 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); len = vsnprintf((char*)s, 600, str, 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); } diff --git a/custom/custom_main/src/custom_main.c b/custom/custom_main/src/custom_main.c index efa6444..85e1041 100644 --- a/custom/custom_main/src/custom_main.c +++ b/custom/custom_main/src/custom_main.c @@ -21,122 +21,12 @@ #include "jt808_msg_parse.h" #include "jt808_pkg_transmit.h" #include "tcp_client.h" +#include "control_out.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; - -// 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){ cm_cereg_state_t cereg_state = {0}; @@ -157,11 +47,11 @@ void print_network_info(void){ } } - led_status_t led_status = {0}; osEventFlagsId_t LED_EventFlags = NULL; void my_appimg_enter(char *param){ + // cm_gpio_level_e level = 0; LED_EventFlags =osEventFlagsNew(NULL); if(NULL == LED_EventFlags){ @@ -175,35 +65,10 @@ void my_appimg_enter(char *param){ cm_gpio_init(CM_GPIO_NUM_0, &cfg); 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_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}; - int pdp_time_out=0; cm_fs_system_info_t info = {0, 0}; cm_heap_stats_t stats = {0}; app_printf("\n\n\n\n\n"); @@ -214,23 +79,46 @@ void my_appimg_enter(char *param){ cm_mem_get_heap_stats(&stats); 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("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_init(); tcp_client_init(); @@ -289,7 +177,6 @@ void led_set_event(led_event_t event){ osEventFlagsSet(LED_EventFlags, event); } - int cm_opencpu_entry(char * param) { osThreadAttr_t app_task_attr = {0}; diff --git a/custom/jt808/inc/jt808_protocol.h b/custom/jt808/inc/jt808_protocol.h index a576d80..c9c0d31 100644 --- a/custom/jt808/inc/jt808_protocol.h +++ b/custom/jt808/inc/jt808_protocol.h @@ -28,10 +28,19 @@ typedef enum { ID_TxtMsgdelivery = 0x8300, // 文本信息下发 ID_Car_Ctrl = 0x8500, // 车辆控制 ID_Car_CtrlResp = 0x0500, // 车辆控制应答 -} MessageID_t; + ID_Data_Down = 0x8900, // 数据透传下行 + ID_Data_Up = 0x0900, // 数据透传上行 +}MessageID_t; #pragma pack(1) // ----------------------------- 协议消息体结构体定义 ---------- +typedef enum{ + Msg_ok = 0, // 成功 + Msg_err = 1, // 失败 + Msg_invalid = 2, // 消息有误//无效 + Msg_no_support = 3, // 不支持 +}Msg_result_t; + // 终端通用应答体（0x0001） typedef struct { uint16_t msg_flow_num; // 对应的平台消息的流水号 @@ -287,6 +296,18 @@ typedef struct { uint32_t eff_time; // 追踪有效时间，单位为秒（s） }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 { diff --git a/custom/jt808/inc/jt808_set_TermParam.h b/custom/jt808/inc/jt808_set_TermParam.h index d156402..1480c86 100644 --- a/custom/jt808/inc/jt808_set_TermParam.h +++ b/custom/jt808/inc/jt808_set_TermParam.h @@ -42,6 +42,7 @@ typedef struct {// 终端参数项 Term_Upgrade_t big_upgrade_info; // 解析出的升级信息 LocReport_t big_loc_report; // 位置信息汇报 LocTrackingCtrl_t big_loc_tracking_ctrl; // 临时位置跟踪控制 + Data_SeriaNet_t big_data_up_SeriaNet; // 数据上行透传 }Term_Param_item_t; #pragma pack() @@ -55,6 +56,11 @@ void jt808_Set_CarStatus(uint8_t status); // 获取车辆状态 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); diff --git a/custom/jt808/src/jt808_msg_parse.c b/custom/jt808/src/jt808_msg_parse.c index ac3757a..fee4c44 100644 --- a/custom/jt808/src/jt808_msg_parse.c +++ b/custom/jt808/src/jt808_msg_parse.c @@ -1,17 +1,18 @@ #include "jt808_msg_parse.h" #include "jt808_pkg_transmit.h" +#include "local_tts.h" PrsResult_t PrsResult; // 消息体解析 -static int jt808_BodyParse(void *Prsmsg_body, PrsResult_t *PrsResult){ - switch (PrsResult->msg_head.msg_id){ +static int jt808_BodyParse(void *Prsmsg_body, PrsResult_t *Result){ + switch (Result->msg_head.msg_id){ 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); - PrsResult->Rsp_msg_id = Swap16(PrsResult->Rsp_msg_id); - // PrsResult->Rsp_result = PrsResult->Rsp_result; + Result->Rsp_flow_num = Swap16(Result->msg_head.msg_flow_num); + Result->Rsp_msg_id = Swap16(Result->msg_head.msg_id); + // Result->Rsp_result = Result->Rsp_result; break; } case ID_FillPktReq:{// 补传分包请求 @@ -19,34 +20,36 @@ static int jt808_BodyParse(void *Prsmsg_body, PrsResult_t *PrsResult){ break; } case ID_Term_RegResp:{// 终端注册应答 - PrsResult->Rsp_flow_num = (uint16_t)(((uint8_t *)Prsmsg_body)[0] << 8) | (((uint8_t *)Prsmsg_body)[1]); - PrsResult->Rsp_result = ((uint8_t *)Prsmsg_body)[2]; - if(PrsResult->Rsp_result == 0){ // 成功时，读取鉴权码 - if(PrsResult->term_param_item->big_auth_info.str_auth_code != NULL){ - jt808_free(PrsResult->term_param_item->big_auth_info.str_auth_code); - PrsResult->term_param_item->big_auth_info.str_auth_code = NULL; + Result->Rsp_flow_num = (uint16_t)(((uint8_t *)Prsmsg_body)[0] << 8) | (((uint8_t *)Prsmsg_body)[1]); + Result->Rsp_result = ((uint8_t *)Prsmsg_body)[2]; + if(Result->Rsp_result == Msg_ok){ // 成功时，读取鉴权码 + if(Result->term_param_item->big_auth_info.str_auth_code != NULL){ + jt808_free(Result->term_param_item->big_auth_info.str_auth_code); + 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是为了加上结束符 - if(PrsResult->term_param_item->big_auth_info.str_auth_code == NULL){ + Result->term_param_item->big_auth_info.str_auth_code = (char *)jt808_malloc(Result->msg_head.msgbody_attr.msgbodylen - 3 +1); // 加1是为了加上结束符 + if(Result->term_param_item->big_auth_info.str_auth_code == NULL){ JT808_DEBUG("[%s,%s] malloc failed\r\n", __FUNCTION__,__LINE__); return -1; } - memset(PrsResult->term_param_item->big_auth_info.str_auth_code, 0, PrsResult->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); + memset(Result->term_param_item->big_auth_info.str_auth_code, 0, Result->msg_head.msgbody_attr.msgbodylen - 3 +1); + memcpy(Result->term_param_item->big_auth_info.str_auth_code, Prsmsg_body + 3 , Result->msg_head.msgbody_attr.msgbodylen - 3); } break; } 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; - 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 (void *)(Prsmsg_body + param_lenoffset + 5), // 参数值 *((uint8_t*)(Prsmsg_body + param_lenoffset + 4))); // 参数长度 param_lenoffset += 5 + (*((uint8_t*)(Prsmsg_body + param_lenoffset + 4))); // 参数ID(4) + 参数长度(1) + 参数值(n) } - + 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; } @@ -78,11 +81,55 @@ static int jt808_BodyParse(void *Prsmsg_body, PrsResult_t *PrsResult){ break; } + 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);// 发送车辆控制应答，设置本消息无发送应答 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:{ return -2; // 没有对应的消息体解析函数 break; @@ -92,7 +139,7 @@ static int jt808_BodyParse(void *Prsmsg_body, PrsResult_t *PrsResult){ } // 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)); if(raw_Buffer == NULL){ 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); return -1; } - // 解析消息头 - memcpy(&PrsResult->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 - PrsResult->msg_head.msgbody_attr.val16 = Swap16(PrsResult->msg_head.msgbody_attr.val16);// 消息体属性 - PrsResult->msg_head.msg_flow_num = Swap16(PrsResult->msg_head.msg_flow_num);// 消息流水号 - PrsResult->msg_head.total_packet = Swap16(PrsResult->msg_head.total_packet);// 总包数, 分包情况下使用 - PrsResult->msg_head.packet_seq = Swap16(PrsResult->msg_head.packet_seq);// 当前包序号, 分包情况下使用 + memcpy(&Result->msg_head, para_Buffer + 1, sizeof(MsgHead_t) - ((para_Buffer[3] & 0x02)==0? 4 : 0)); + Result->msg_head.msg_id = Swap16(Result->msg_head.msg_id);// 消息ID + Result->msg_head.msgbody_attr.val16 = Swap16(Result->msg_head.msgbody_attr.val16);// 消息体属性 + Result->msg_head.msg_flow_num = Swap16(Result->msg_head.msg_flow_num);// 消息流水号 + Result->msg_head.total_packet = Swap16(Result->msg_head.total_packet);// 总包数, 分包情况下使用 + 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_free(para_Buffer); diff --git a/custom/jt808/src/jt808_msg_pkg.c b/custom/jt808/src/jt808_msg_pkg.c index 9c0b65c..afc7606 100644 --- a/custom/jt808/src/jt808_msg_pkg.c +++ b/custom/jt808/src/jt808_msg_pkg.c @@ -74,33 +74,33 @@ static int jt808_BodyPackage(JT808_2013_MsgFrame_t *p_MsgFrame, MessageID_t Msg_ break; } case ID_GetTermParamsResp:{ // 查询终端参数应答 - 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)); - if(get_term_params_resp == NULL){ - JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__); - return -1; - } - p_MsgFrame->p_msg_body = (void *)get_term_params_resp; + // 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)); + // if(get_term_params_resp == NULL){ + // JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__); + // return -1; + // } + // p_MsgFrame->p_msg_body = (void *)get_term_params_resp; break; } case ID_GetTermAttrResp:{ // 查询终端属性应答 - 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)); - if(get_term_attr_resp == NULL){ - JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__); - return -1; - } - p_MsgFrame->p_msg_body = (void *)get_term_attr_resp; + // 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)); + // if(get_term_attr_resp == NULL){ + // JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__); + // return -1; + // } + // p_MsgFrame->p_msg_body = (void *)get_term_attr_resp; break; } case ID_Term_UpgradeResult:{ // 终端升级结果通知 - 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)); - if(term_upgrade_result == NULL){ - JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__); - return -1; - } - p_MsgFrame->p_msg_body = (void *)term_upgrade_result; + // 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)); + // if(term_upgrade_result == NULL){ + // JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__); + // return -1; + // } + // p_MsgFrame->p_msg_body = (void *)term_upgrade_result; break; } case ID_LocReport:{ // 位置信息汇报 @@ -130,15 +130,66 @@ static int jt808_BodyPackage(JT808_2013_MsgFrame_t *p_MsgFrame, MessageID_t Msg_ break; } case ID_GetLocInfoResp:{ // 查询位置信息应答 - 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)); - if(get_loc_info_resp == NULL){ + // 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)); + // 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__); 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; } + 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: return -2; 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){ JT808_2013_MsgFrame_t big_MsgFrame;// 定义大端消息帧 - JT808_DEBUG("BodyPackage ID:0x%04X\r\n", Msg_ID); big_MsgFrame.p_msg_body = NULL; if(0 != jt808_BodyPackage(&big_MsgFrame, Msg_ID)){// 填充消息体 （注意释放p_msg_body内存） 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 msgbody_len =big_MsgFrame.msg_head.msgbody_attr.msgbodylen; 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.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; - 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++){ app_printf("%02X ", *(msgEscape->buf + i)); } diff --git a/custom/jt808/src/jt808_pkg_transmit.c b/custom/jt808/src/jt808_pkg_transmit.c index d002cd0..ca4ef8c 100644 --- a/custom/jt808/src/jt808_pkg_transmit.c +++ b/custom/jt808/src/jt808_pkg_transmit.c @@ -10,7 +10,7 @@ int jt808_pkg_send(MessageID_t Msg_ID, uint32_t timeout){ pkg_msg_t send_pkg_msg={0}; send_pkg_msg.msg_id = Msg_ID; 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(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){ if(0 ==jt808_msg_parse(receive_buf, receive_len, &PrsResult)){ // 解析协议数据 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); 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(NULL != jt808_parse_ok_sem){ osStatus_t ret =osSemaphoreAcquire(jt808_parse_ok_sem, send_pkg_msg.timeout);// 等待接收数据并解析完成 if(ret == osOK || 0 == send_pkg_msg.timeout){ osSemaphoreRelease(jt808_send_ack_sem); // 释放发送成功应答信号量 - JT808_DEBUG("parse success\n"); + // JT808_DEBUG("parse success\n"); if(PrsResult.term_param_item!= NULL){ // 协议参数项不为空 PrsResult.term_param_item->msg_flow_num++; // 协议流水号+1 }else{ @@ -76,7 +76,7 @@ static void jt808_pkg_send_task(void *arg){ } } if(MsgESC.buf!= NULL){ // 释放发送缓存 - JT808_DEBUG("jt808_free MsgESC.buf\n"); + // JT808_DEBUG("jt808_free MsgESC.buf\n"); jt808_free(MsgESC.buf); MsgESC.buf = NULL; } @@ -87,7 +87,7 @@ static void jt808_pkg_send_task(void *arg){ // jt808协议初始化 int jt808_init(void){ 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){ jt808_send_ack_sem = osSemaphoreNew(1, 0, NULL); @@ -97,7 +97,7 @@ int jt808_init(void){ } osThreadAttr_t jt808_pkg_send_task_attr = { .name = "jt808_pkg_send_task", - .stack_size = 1024, + .stack_size = 4096, .priority = osPriorityNormal, }; jt808_pkg_send_ThreadId = osThreadNew((osThreadFunc_t)jt808_pkg_send_task, 0, &jt808_pkg_send_task_attr); diff --git a/custom/jt808/src/jt808_set_TermParam.c b/custom/jt808/src/jt808_set_TermParam.c index cec9b77..b73a86f 100644 --- a/custom/jt808/src/jt808_set_TermParam.c +++ b/custom/jt808/src/jt808_set_TermParam.c @@ -20,6 +20,49 @@ uint8_t jt808_Get_CarStatus(void){ 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){ diff --git a/custom/local_tts/inc/local_tts.h b/custom/local_tts/inc/local_tts.h index f5c2edf..74bcf76 100644 --- a/custom/local_tts/inc/local_tts.h +++ b/custom/local_tts/inc/local_tts.h @@ -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); // 本地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__ \ No newline at end of file diff --git a/custom/local_tts/src/local_tts.c b/custom/local_tts/src/local_tts.c index 1a08d7c..f43fa04 100644 --- a/custom/local_tts/src/local_tts.c +++ b/custom/local_tts/src/local_tts.c @@ -21,34 +21,14 @@ #endif static osMessageQueueId_t local_tts_play_queue = 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回调函数 */ -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); - osSemaphoreRelease(local_tts_play_ok_sem); // 释放发送成功应答信号量 - break; - default: - break; - } -} +typedef struct{ + cm_local_tts_cfg_t tts_cfg; + char *text; + uint8_t len; +}tts_play_queue_t; // 静音 mute: 0-关闭 1-打开 void local_tts_mute(uint8_t mute){ @@ -71,32 +51,57 @@ uint8_t local_tts_volume(uint8_t volume){ // volume: 音量，取值范围0-15，默认为5 // mode: 0-自动模式 1-数字模式,2-数值模式 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.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); // 取消静音 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); return -1; } + TTS_play_finish_flag =1; //播放完成标志位 0-完成 !=0-未完成 // 等待播放完成 osSemaphoreAcquire(local_tts_play_ok_sem, timeout); DEBUG("tts play queue put success\n"); 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: 待优化（暂时方案，打断播放） static osThreadFunc_t local_tts_play_task(void *arg){ tts_play_queue_t tts_play_queue; + osStatus_t ret=0; while(1){ if(osOK == osMessageQueueGet(local_tts_play_queue, &tts_play_queue, NULL, osWaitForever)){ // - DEBUG("tts play stop\n"); - cm_local_tts_play_stop(); // 停止播放 - osDelay(200/5); // 等待播放停止 + + // cm_local_tts_play_stop(); // 停止播放 + // osDelay(300/5); // 等待播放停止 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"); continue; } 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); 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_gpio_init(CM_GPIO_NUM_13, &cfg); - - local_tts_mute(1); // 关闭静音 + local_tts_mute(1); // 开启静音 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){ - 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){ 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 = { .name = "local_tts_play_thread", - .stack_size = 4096 * 4, + .stack_size = 4096, .priority = osPriorityNormal }; osThreadNew((osThreadFunc_t)local_tts_play_task, NULL, &local_tts_play_thread_attr); + osDelay(200/5); // 等待初始化完成 } diff --git a/custom/radar/inc/radar.h b/custom/radar/inc/radar.h new file mode 100644 index 0000000..d13ca96 --- /dev/null +++ b/custom/radar/inc/radar.h @@ -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 */ \ No newline at end of file diff --git a/custom/radar/radar.mk b/custom/radar/radar.mk new file mode 100644 index 0000000..57451d2 --- /dev/null +++ b/custom/radar/radar.mk @@ -0,0 +1,6 @@ + +CUSTOM_MAIN_DIR := custom/radar + +OC_FILES += $(CUSTOM_MAIN_DIR)/src/radar.c + +INC += -I'$(CUSTOM_MAIN_DIR)/inc' \ No newline at end of file diff --git a/custom/radar/src/radar.c b/custom/radar/src/radar.c new file mode 100644 index 0000000..818f260 --- /dev/null +++ b/custom/radar/src/radar.c @@ -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); +} diff --git a/custom/tcp_client/src/tcp_client.c b/custom/tcp_client/src/tcp_client.c index 980416f..224a525 100644 --- a/custom/tcp_client/src/tcp_client.c +++ b/custom/tcp_client/src/tcp_client.c @@ -9,7 +9,7 @@ #include "jt808_set_TermParam.h" #include "tcp_client.h" #include "app_common.h" - +#include "local_tts.h" #define TCP_CLIENT_ENABLE 1 @@ -44,11 +44,11 @@ static void tcp_recv_task(void){ if(FD_ISSET(tcp_client_sock, &sets)){ // 套接字可读 ret = recv(tcp_client_sock, buf, sizeof(buf), 0); if(ret > 0){ - DEBUG("tcp_read recv:%d\n", ret); - for(int i = 0; i < ret; i++){ - app_printf("%02x ", buf[i]); - } - app_printf("\n\n"); + // DEBUG("tcp_read recv:%d\n", ret); + // for(int i = 0; i < ret; i++){ + // app_printf("%02x ", buf[i]); + // } + // app_printf("\n\n"); // 处理接收到的数据 jt808_pkg_handle(buf, ret); @@ -147,6 +147,7 @@ static void net_manage_task(void *arg){ uint8_t error_time_out = 0; while(1){ TCP_DISABLE: + error_time_out = 0; do{// 连接服务器 while(1){ // 等待插入SIM卡并建立网络连接 osDelay(1000/5); @@ -182,7 +183,7 @@ TCP_DISABLE: // jt808_pkg_send(ID_Term_GenResp,5000/5); for(uint8_t i = 0; i < 3; i++){ // 发送3次注册、鉴权、参数设置、上报参数 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"); for(uint8_t i = 0; i < 3; i++){ ret =jt808_pkg_send(ID_Term_Auth,10000/5);//终端鉴权 超时：10S @@ -199,7 +200,7 @@ TCP_DISABLE: break; }else{ DEBUG("send ID_Term_Reg fail:%d!\n",ret); - if(ret == -1){ + if(ret == -1){ // 发送失败 goto TCP_DISABLE; } } @@ -207,16 +208,23 @@ TCP_DISABLE: jt808_Autoreport_param_start();//开启自动上报参数设置 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); // 等待断开连接信号 jt808_Autoreport_param_stop();//停止自动上报参数设置 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){ osThreadAttr_t net_manage_task_attr={ .name = "net_manage_task", - .stack_size = 1024, + .stack_size = 4096, .priority = osPriorityNormal, }; DEBUG("tcp_client_init!\r\n"); @@ -224,4 +232,5 @@ void tcp_client_init(void){ netconn_disconnect_sem = osSemaphoreNew(1, 0, NULL); } net_manage_ThreadId = osThreadNew((osThreadFunc_t)net_manage_task, 0, &net_manage_task_attr); + osDelay(300/5); // 等待网络管理线程启动 } \ No newline at end of file diff --git a/src/cm_lib/cm_tts_play/cm_tts_play.c b/src/cm_lib/cm_tts_play/cm_tts_play.c index 4eca545..a0b3a13 100644 --- a/src/cm_lib/cm_tts_play/cm_tts_play.c +++ b/src/cm_lib/cm_tts_play/cm_tts_play.c @@ -6,7 +6,7 @@ #include "cm_audio_player.h" #include "cm_audio_common.h" -#define DEBUG_ENABLE 0 +#define DEBUG_ENABLE 1 #if DEBUG_ENABLE #include "app_uart.h" @@ -15,7 +15,7 @@ #define DEBUG(fmt, arg...) #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 { 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); } - 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; } 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中播放音频（开启） if (-1 == ret){ - DEBUG("%s() __%d__ cm_audio_player_stream_open0() error, ret is %d", __func__, __LINE__, ret); - cm_audio_player_stream_close(); - ret = cm_audio_player_stream_open(CM_AUDIO_PLAY_FORMAT_PCM, &frame); //从pipe中播放音频（开启） - if (-1 == ret){ + // DEBUG("%s() __%d__ cm_audio_player_stream_open0() error, ret is %d", __func__, __LINE__, ret); + // cm_audio_player_stream_close(); + // ret = cm_audio_player_stream_open(CM_AUDIO_PLAY_FORMAT_PCM, &frame); //从pipe中播放音频（开启） + // if (-1 == ret){ DEBUG("%s() __%d__ cm_audio_player_stream_open1() error, ret is %d", __func__, __LINE__, ret); return -1; - } + // } } 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.TtsPcmBufLen = 0; 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); - + DEBUG("tts_synth_end\n\n========\n"); if (0 == ret) { osSemaphoreRelease(cm_tts_play_cfg.SemHandle);