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

改善TTS语音播放问题 zsxfly20241125

This commit is contained in:
zsx 2024-11-25 22:16:49 +08:00
parent d8a6bc7f2a
commit 96bf55d238
16 changed files with 362 additions and 245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -12,6 +12,8 @@
#include "app_uart.h"
#include "gps_config.h"
#include "local_tts.h"
#define GPS_URAT CM_UART_DEV_1
#define GPS_RX_IOMUX UART1_RX_IOMUX
@ -63,6 +65,8 @@ static nmeaPARSER parser;
static void gps_TaskHandle(void *param){
int temp_len = 0;
int it = 0;
uint8_t gps_flag = 0;
uint8_t gps_flag_last = 0;
/* 设置用于输出调试信息的函数 */
nmea_property()->trace_func = &trace;
@ -83,16 +87,26 @@ static void gps_TaskHandle(void *param){
nmea_info2pos(&gps_data.info, &gps_data.dpos);
gps_data.flow_num++;
app_printf(
"\nGPS:%03d,Lat:%.02f,Lon:%.02f,Sig:%d,Fix:%d,RL=%d\n",
"[GPS]:%03d,Lat:%.02f,Lon:%.02f,Sig:%d,Fix:%d,RL=%d\n",
it++, gps_data.info.lat, gps_data.info.lon, gps_data.info.sig, gps_data.info.fix, gps_rev_len
);
if((gps_data.info.fix == 1)||(gps_data.info.sig == 0)){ // 不可用
// app_printf("GPS no locate!\n");
led_set_event(EVENT_GPS_NO_LOCATE);
gps_flag =0;
}else{
// app_printf("GPS locate success!\n");
led_set_event(EVENT_GPS_LOCATE_SUCCESS);
gps_flag =1;
}
if(gps_flag!= gps_flag_last){ // GPS状态变化
gps_flag_last = gps_flag;
if(gps_flag == 1){
// app_printf("GPS locate success!\n");
led_set_event(EVENT_GPS_LOCATE_SUCCESS);
local_tts_text_play("定位成功",0,0);
}else{
// app_printf("GPS no locate!\n");
led_set_event(EVENT_GPS_NO_LOCATE);
local_tts_text_play("定位信号弱",0,0);
}
}
memset((void*)gps_rev_data, 0, gps_rev_len);

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

@ -132,38 +132,38 @@ void control_out_task(void *argument){
// }
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(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 )){ // 游客模式下，电门锁状态变化时触发
if((door_lock_last_status != sys_sta.O_door_lock) && (1 == sys_sta.MAG_MODE ) && (1 == sys_sta.PLT_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);
local_tts_text_play("欢迎使用游园猫",0,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);
local_tts_text_play("行程结束，祝您生活愉快",0,0);
}
}
if((S_MODE_last_status != sys_sta.MAG_MODE) || ((0 == sys_sta.PLT_MODE)&&(1 == sys_sta.O_door_lock))){ // 管理员模式状态变化时触发
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);
// local_tts_set(5, 7, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("管理员模式",0,1);
}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);
// local_tts_set(10, 7, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("退出管理员模式",0,1);
}
}
@ -174,7 +174,7 @@ void control_out_task(void *argument){
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); // 忙时自动取消倒车提示语
local_tts_text_play("请注意倒车！",0,1); // 忙时自动取消倒车提示语
}
}
@ -182,7 +182,7 @@ void control_out_task(void *argument){
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((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{
@ -205,6 +205,17 @@ void control_out_task(void *argument){
void control_out_init(void){
cm_gpio_cfg_t cfg = {0};
// 手动设置初始值
sys_sta.O_door_lock = 0; // 电门锁状态:关闭
sys_sta.PLT_MODE = 1; // 模式:游客模式
sys_sta.P_Radar_EN = 1; // 雷达使能状态:开启
// 自动设置
sys_sta.MAG_MODE = 1; // 系统模式:游客模式
sys_sta.IO_RX_back = 1; // 倒车模式:正常模式
sys_sta.IO_TX_brake = 1; // 刹车模式:正常模式
sys_sta.A_brake = 0; // 自动刹车状态:关闭
sys_sta.A_Speed_Cut = 0; // 自动减速状态:关闭
// SW_ADC
cfg.direction = CM_GPIO_DIRECTION_OUTPUT;
cfg.pull = CM_GPIO_PULL_UP;
@ -250,7 +261,7 @@ void control_out_init(void){
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.stack_size = 4096*4;
control_out_task_attr.priority = osPriorityNormal;
control_out_TaskHandle = osThreadNew((osThreadFunc_t)control_out_task,0,&control_out_task_attr);

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

@ -87,14 +87,14 @@ static void Uart_RX_TaskHandle(void *param){
// 发送数据
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);
if(msg_data_len > UART_BUF_LEN || msg_data_len == 0){
cm_uart_write(APP_URAT, "TX 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);
cm_uart_write(APP_URAT, "TX malloc error\r\n", 14, 1000);
return -2;//内存不足
}
memcpy(p_data, msg_data, msg_data_len);
@ -102,11 +102,14 @@ int8_t uart0_send_msg(uint8_t *msg_data, uint16_t msg_data_len, uint32_t timeout
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);
if(uart_tx_ack_sem != NULL){
osSemaphoreAcquire(uart_tx_ack_sem, timeout);
// cm_uart_write(APP_URAT, "TX send ok\r\n", 12, 1000);
}
}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);
// cm_uart_write(APP_URAT, "TX msg queue full\r\n", 22, 1000);
return -1;
}
return 0;
@ -119,11 +122,12 @@ static void Uart_TX_TaskHandle(void *param){
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);
}
// 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);
// }
osSemaphoreRelease(uart_tx_ack_sem); //发送成功，释放信号量
send_msg.msg_data_len = 0;
if(send_msg.msg_data != NULL){
cm_free(send_msg.msg_data);
@ -190,7 +194,7 @@ void app_uart_init(void){
// 串口接收处理任务
osThreadAttr_t uart_rx_task_attr = {
.name = "uart_rx_task",
.stack_size = 4096,
.stack_size = 4096 * 4,
.priority= APP_UART_TASK_PRIORITY
};
os_UART_RX_ThreadId= osThreadNew(Uart_RX_TaskHandle, 0, &uart_rx_task_attr);
@ -200,14 +204,14 @@ void app_uart_init(void){
}
if(uart_tx_msg_queue == NULL){
uart_tx_msg_queue = osMessageQueueNew(10, sizeof(uart_tx_msg_t), NULL);
uart_tx_msg_queue = osMessageQueueNew(1000, 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,
.stack_size = 4096 * 4,
.priority= APP_UART_TASK_PRIORITY
};
os_UART_TX_ThreadId= osThreadNew(Uart_TX_TaskHandle, 0, &uart_tx_task_attr);
@ -225,7 +229,7 @@ void app_uart_init(void){
// }
void uart0_printf(char *str, ...){
static char s[600]; //This needs to be large enough to store the string TODO Change magic number
static char s[1000]; //This needs to be large enough to store the string TODO Change magic number
va_list args;
int len;
@ -234,13 +238,13 @@ void uart0_printf(char *str, ...){
}
va_start(args, str);
len = vsnprintf((char*)s, 600, str, args);
len = vsnprintf((char*)s, 1000, 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
static char s[1000]; //This needs to be large enough to store the string TODO Change magic number
va_list args;
int len;
@ -250,8 +254,8 @@ void app_printf(char *str, ...){
}
va_start(args, str);
len = vsnprintf((char*)s, 600, str, args);
len = vsnprintf((char*)s, 1000, str, args);
va_end(args);
// cm_uart_write(APP_URAT, s, len, 1000);
uart0_send_msg((uint8_t*)s, len, 0);
uart0_send_msg((uint8_t*)s, len, osWaitForever);
}

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

@ -31,14 +31,14 @@ void print_network_info(void){
cm_cereg_state_t cereg_state = {0};
if(0 == cm_modem_get_cpin()){
app_printf("sim card ready!\r\n\n");
app_printf("sim card ready!\r\n");
}else{
app_printf("sim card not ready!\r\n\n");
app_printf("sim card not ready!\r\n");
}
if(0 ==cm_modem_get_cereg_state(&cereg_state)){ // 获取PS网络注册状态
app_printf("cereg_state:%d\n",cereg_state.state); // 注册状态
}else{
app_printf("cereg_get_state fail!\n\n");
app_printf("cereg_get_state fail!\n");
}
if(cm_modem_get_pdp_state(1) == 1){ //网络就绪
app_printf("network ready\n");
@ -47,83 +47,19 @@ 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);
void led_set_event(led_event_t event){ // 支持多线程并发调用
if(NULL == LED_EventFlags){
app_printf("LED_EventFlags create fail\n");
// return;
app_printf("LED_EventFlags is NULL\n");
return;
}
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_16, CM_IOMUX_FUNC_FUNCTION1);//初始化之前一定要先设置引脚复用
cm_gpio_init(CM_GPIO_NUM_0, &cfg);
cm_gpio_set_level(CM_GPIO_NUM_0, 0);
app_uart_init();
//--------------------------------------------
{
char buf[CM_VER_LEN] = {0};
cm_fs_system_info_t info = {0, 0};
cm_heap_stats_t stats = {0};
app_printf("\n\n\n\n\n");
app_printf("CM OpenCPU Starts\n");
cm_sys_get_cm_ver(buf, CM_VER_LEN);
app_printf("SDK VERSION:%s\n", buf);
cm_fs_getinfo(&info);
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);
osEventFlagsSet(LED_EventFlags, event);
}
// -----------------------------------------------------
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();
gps_config_init();
void led_task(char *param){
led_status_t led_status = {0};
uint32_t led_event = 0;
while(1){
led_event = osEventFlagsWait(LED_EventFlags, 0x0000000f, osFlagsWaitAny, 0); //0等待
@ -169,12 +105,144 @@ void my_appimg_enter(char *param){
}
}
void led_set_event(led_event_t event){
void led_task_init(void){
LED_EventFlags =osEventFlagsNew(NULL);
if(NULL == LED_EventFlags){
app_printf("LED_EventFlags is NULL\n");
return;
app_printf("LED_EventFlags create fail\n");
}
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_16, CM_IOMUX_FUNC_FUNCTION1);//初始化之前一定要先设置引脚复用
cm_gpio_init(CM_GPIO_NUM_0, &cfg);
cm_gpio_set_level(CM_GPIO_NUM_0, 0);
osThreadAttr_t led_task_attr = {
.name = "led_task",
.stack_size = 1024,
.priority = osPriorityNormal,
};
osThreadNew((osThreadFunc_t)led_task,0,&led_task_attr);
}
void my_appimg_enter(char *param){
app_uart_init();
led_task_init();
cm_uart_write(0, "\n\n---zsxfly---\n\n", 16, 1000);
if(1){
char buf[CM_VER_LEN] = {0};
cm_fs_system_info_t info = {0, 0};
cm_heap_stats_t stats = {0};
app_printf("\n\n\n\n\n");
app_printf("CM OpenCPU Starts\n");
cm_sys_get_cm_ver(buf, CM_VER_LEN);
app_printf("SDK VERSION:%s\n", buf);
cm_fs_getinfo(&info);
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);
}
local_tts_init();
// local_tts_mute(0);// 取消静音
local_tts_volume(50); // 设置音量为55
// local_tts_set(7, 7, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("设备已开机",0,0);
control_out_init();
// /*
if( 0 ){
while(1){
cm_gpio_set_level(CM_GPIO_NUM_0, 1);
osDelay(500/5);
cm_gpio_set_level(CM_GPIO_NUM_0, 0);
osDelay(500/5);
}
}else if( 0 ){
// cm_gpio_level_e level = 0;
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);
// local_tts_set(7, 7, CM_LOCAL_TTS_DIGIT_AUTO);
// local_tts_text_play("风和日丽的日子。阳光，洒下诸多幻影，让我重温当初。漫步时光，携一身清爽走一程简单的凉薄，回味中，",0,0);
// local_tts_text_play("是否，悠然还在?一路足迹，是否还可以寻回当初?是否青春的影子还残留在那些剪影中?",0,0);
// local_tts_text_play("回望沿途的风景，朦胧中，似乎少了几许张扬的味道,多了几许成熟的风韵。",0,0);
// local_tts_text_play("轻盈步伐，让流逝的永远流逝，让脚下的路延伸到尽头，依一素颜，走自己该走的路..…",0,0);
// osDelay(25000/5);
local_tts_volume(5);
// local_tts_set(2, 2, CM_LOCAL_TTS_DIGIT_AUTO);
cm_gpio_set_level(CM_GPIO_NUM_0, 1);
local_tts_text_play("测试0",0 ,1);
local_tts_text_play("测试1",0 ,1);
local_tts_text_play("测试2",0 ,1);
cm_gpio_set_level(CM_GPIO_NUM_0, 0);
local_tts_text_play("测试3",0 ,0);
osDelay(5000/5);
local_tts_volume(25);
// local_tts_set(7, 7, CM_LOCAL_TTS_DIGIT_AUTO);
cm_gpio_set_level(CM_GPIO_NUM_0, 1);
local_tts_text_play("测试4",0 ,1);
local_tts_text_play("测试5",0 ,1); // 不可打断
local_tts_text_play("测试6",0 ,1);
cm_gpio_set_level(CM_GPIO_NUM_0, 0);
local_tts_text_play("测试7",0 ,1);
osDelay(5000/5);
local_tts_volume(50);
// local_tts_set(7, 12, CM_LOCAL_TTS_DIGIT_AUTO);
cm_gpio_set_level(CM_GPIO_NUM_0, 1);
local_tts_text_play("测试8",0 ,1);
local_tts_text_play("测试9",0 ,1); // 不可打断
local_tts_text_play("测试10",0 ,1);
cm_gpio_set_level(CM_GPIO_NUM_0, 0);
local_tts_text_play("测试11",0 ,1);
osDelay(5000/5);
local_tts_volume(75);
// local_tts_set(7, 15, CM_LOCAL_TTS_DIGIT_AUTO);
cm_gpio_set_level(CM_GPIO_NUM_0, 1);
local_tts_text_play("测试12",0 ,1);
local_tts_text_play("测试13",0 ,1); // 不可打断
local_tts_text_play("测试14",0 ,1);
cm_gpio_set_level(CM_GPIO_NUM_0, 0);
local_tts_text_play("测试15",0 ,0);
osDelay(5000/5);
local_tts_volume(100);
// local_tts_set(6, 0, CM_LOCAL_TTS_DIGIT_AUTO);
cm_gpio_set_level(CM_GPIO_NUM_0, 1);
local_tts_text_play("测试16",0 ,1);
local_tts_text_play("测试17",0 ,1); // 不可打断
local_tts_text_play("测试18",0 ,1);
cm_gpio_set_level(CM_GPIO_NUM_0, 0);
local_tts_text_play("测试19",0 ,0);
osDelay(5000/5);
}
}
// */
jt808_set_term_param_init();
jt808_init();
tcp_client_init();
gps_config_init();
while(1){
osDelay(1000/5);
}
osEventFlagsSet(LED_EventFlags, event);
}
int cm_opencpu_entry(char * param)

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

@ -239,7 +239,15 @@ typedef union{
uint32_t beidou_en : 1;// 0: 未使用北斗卫星进行定位; 1: 使用北斗卫星进行定位
uint32_t glonass_en : 1;// 0: 未使用 GLONASS 卫星进行定位; 1: 使用 GLONASS 卫星进行定位
uint32_t galileo_en : 1;// 0: 未使用 Galileo 卫星进行定位; 1: 使用 Galileo 卫星进行定位
uint32_t retain2 : 10;// 保留10位
// uint32_t retain2 : 10;// 保留10位
uint32_t MAG_MODE :1; // 1:游客模式,0:管理模式
uint32_t PLT_MODE :1; // 1:游客模式,0:管理模式
uint32_t IO_RX_back :1; // 1:正常 0:倒车
uint32_t IO_TX_brake :1; // 1:正常 0:刹车
uint32_t A_brake :1; // 1:自动刹车,0:手动刹车
uint32_t A_Speed_Cut :1; // 1:自动减速,0:手动减速
uint32_t P_Radar_EN :1; // 1:雷达使能,0:雷达禁止
uint32_t retain2 : 3;// 保留10位
};
uint32_t val32;
}LocStatus_t;
@ -254,21 +262,6 @@ typedef struct{
uint16_t direction; // 方向
uint8_t BCDtime[6]; // 时间YY-MM-DD-hh-mm-ss（GMT+8 时间，本标准中之后涉及的时间均采用此时区）
}Loc_basic_info_t;
typedef enum{
MileageID = 0x01,// 里程, 1/10km, 对应车上里程表读数, DWORD
OilMassID = 0x02,// 油量, 1/10L, 对应车上油量表读数, WORD
TachographSpeedID = 0x03,// 行驶记录功能获取的速度, 1/10km/h, WORD
AlarmCountID = 0x04,// 需要人工确认报警事件的 ID, 从 1 开始计数, WORD
OverSpeedAlarmID = 0x11,// 超速报警附加信息, BYTE or BYTE+DWORD
AccessAreaAlarmID = 0x12,// 进出区域/路线报警附加信息, BYTE+DWORD+BYTE
DrivingTimeAlarmID = 0x13,// 路段行驶时间不足/过长报警附加信息, DWORD+WORD+BYTE
VehicleSignalStatusID = 0x25,// 扩展车辆信号状态位, DWORD
IoStatusID = 0x2A,// IO 状态位, WORD
AnalogQuantityID = 0x2B,// 模拟量, DWORD
NetworkQuantityID = 0x30,// 无线通信网络信号强度, BYTE
GnssSatellitesID = 0x31,// GNSS 定位卫星数, BYTE
CustomInformationLengthID = 0xE0,// 后续自定义信息长度, BYTE
}addi_infoID_t;
// 位置附加信息
typedef struct Loc_addi_info_t{
uint8_t msg_id; // 附加消息ID

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

@ -30,6 +30,23 @@ typedef struct{
uint8_t CarPlateColor;//车牌颜色，按照 JT/T415-2006 的 5.4.12
}set_TermParam_t;
// 支持的附加消息ID
typedef enum{
MileageID = 0x01,// 里程, 1/10km, 对应车上里程表读数, DWORD
OilMassID = 0x02,// 油量, 1/10L, 对应车上油量表读数, WORD
TachographSpeedID = 0x03,// 行驶记录功能获取的速度, 1/10km/h, WORD
AlarmCountID = 0x04,// 需要人工确认报警事件的 ID, 从 1 开始计数, WORD
OverSpeedAlarmID = 0x11,// 超速报警附加信息, BYTE or BYTE+DWORD
AccessAreaAlarmID = 0x12,// 进出区域/路线报警附加信息, BYTE+DWORD+BYTE
DrivingTimeAlarmID = 0x13,// 路段行驶时间不足/过长报警附加信息, DWORD+WORD+BYTE
VehicleSignalStatusID = 0x25,// 扩展车辆信号状态位, DWORD
IoStatusID = 0x2A,// IO 状态位, WORD
AnalogQuantityID = 0x2B,// 模拟量, DWORD
NetworkQuantityID = 0x30,// 无线通信网络信号强度, BYTE
GnssSatellitesID = 0x31,// GNSS 定位卫星数, BYTE
CustomInformationLengthID = 0xE0,// 后续自定义信息长度, BYTE
}addi_infoID_t;
// big_标记的参数需以大端方式存储，需手动转换为大端
typedef struct {// 终端参数项
uint8_t phone_BCDnum[6];// 终端手机号

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

@ -96,8 +96,8 @@ static int jt808_BodyParse(void *Prsmsg_body, PrsResult_t *Result){
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);
local_tts_volume(50); // 设置音量大小
local_tts_set(6, 7, CM_LOCAL_TTS_DIGIT_AUTO);
Result->Rsp_result = Msg_invalid;//消息有误
}
}else{
@ -106,7 +106,7 @@ static int jt808_BodyParse(void *Prsmsg_body, PrsResult_t *Result){
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); // 开始播放文本信息//不等待播放完成
local_tts_text_play((char *)Prsmsg_body + 11, Result->msg_head.msgbody_attr.msgbodylen -11,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;
@ -219,7 +219,7 @@ int jt808_msg_parse(const uint8_t *BufferReceive, uint16_t length, PrsResult_t *
for(uint16_t i = 0; i < para_length; i++){
app_printf("%02X ", *(para_Buffer + i));
}
app_printf("\n");
// 消息体解析
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");

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

@ -7,6 +7,7 @@ static int jt808_BodyPackage(JT808_2013_MsgFrame_t *p_MsgFrame, MessageID_t Msg_
JT808_DEBUG("[%s,%s] term_param_item is NULL \r\n", __FUNCTION__,__LINE__);
return -1;
}
p_MsgFrame->msg_head.msgbody_attr.msgbodylen = 0;// 消息体长度
p_MsgFrame->msg_head.msgbody_attr.encrypt = 0;// 数据加密方式
p_MsgFrame->msg_head.msgbody_attr.packet = 0;// 分包标记
p_MsgFrame->msg_head.msgbody_attr.retain = 0;// 保留2位

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

@ -97,10 +97,10 @@ int jt808_init(void){
}
osThreadAttr_t jt808_pkg_send_task_attr = {
.name = "jt808_pkg_send_task",
.stack_size = 4096,
.stack_size = 4096*4,
.priority = osPriorityNormal,
};
jt808_pkg_send_ThreadId = osThreadNew((osThreadFunc_t)jt808_pkg_send_task, 0, &jt808_pkg_send_task_attr);
osDelay(200); // 等待线程启动
// osDelay(200); // 等待线程启动
return 0;
}

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

@ -6,18 +6,27 @@
#include "cm_sys.h"
#include "cm_sim.h"
#include "control_out.h"
Term_Param_item_t jt808_term_param_item; // 终端参数项
// 控制车辆状态
void jt808_Set_CarStatus(uint8_t status){
// (void)status;
// TODO: 车辆控制状态
sys_sta.O_door_lock = (status & 0x01)? 1 : 0; // 设置电门锁状态
sys_sta.PLT_MODE = (status & 0x02)? 1 : 0; // 平台设置的模式 //1:游客模式,0:管理模式
sys_sta.P_Radar_EN = (status & 0x04)? 1 : 0; // 1:雷达使能,0:雷达禁止
}
// 获取车辆状态
uint8_t jt808_Get_CarStatus(void){
uint8_t status = 0;
// TODO: 车辆控制状态
return 0;
status |= (sys_sta.O_door_lock? 0x01 : 0); // 门锁状态
status |= (sys_sta.PLT_MODE? 0x02 : 0); // 平台设置模式 //1:游客模式,0:管理模式
status |= (sys_sta.P_Radar_EN? 0x04 : 0); // 1:雷达使能,0:雷达禁止
return status;
}
// 串口数据下传
@ -148,11 +157,15 @@ void Autoreport_param_Task(void *arg){
jt808_term_param_item.big_loc_report.basic_info.BCDtime[5] = (((beiJingTime.sec%100/10)&0x0F)<<4) | ((beiJingTime.sec%10)&0x0F);
jt808_term_param_item.big_loc_report.basic_info.status.val32 = 0; // 清除状态信息
jt808_term_param_item.big_loc_report.basic_info.status.acc =0; // 0:未开启，1:已开启
jt808_term_param_item.big_loc_report.basic_info.status.positioning = (0 == gps_data.info.sig) ? 0 : 1; // 0:未定位，1:已定位
jt808_term_param_item.big_loc_report.basic_info.status.door_lock = 0; // 0:未锁车，1:已锁车
jt808_term_param_item.big_loc_report.basic_info.status.operation = 0; // 0:运营状态; 1:停运状态
jt808_term_param_item.big_loc_report.basic_info.status.circuit_cut = 0; // 0:车辆电路正常; 1:车辆电路断开
jt808_term_param_item.big_loc_report.basic_info.status.positioning = (((gps_data.info.fix == 1)||(gps_data.info.sig == 0)) ? 0 : 1); // 0:未定位，1:已定位
jt808_term_param_item.big_loc_report.basic_info.status.acc =sys_sta.O_door_lock; // 1:电门锁打开,0:电门锁关闭
jt808_term_param_item.big_loc_report.basic_info.status.MAG_MODE =sys_sta.MAG_MODE;// 1:游客模式,0:管理模式
jt808_term_param_item.big_loc_report.basic_info.status.PLT_MODE =sys_sta.PLT_MODE; // 1:游客模式,0:管理模式
jt808_term_param_item.big_loc_report.basic_info.status.IO_RX_back =sys_sta.IO_RX_back; // 1:正常 0:倒车
jt808_term_param_item.big_loc_report.basic_info.status.IO_TX_brake =sys_sta.IO_TX_brake; // 1:正常 0:刹车
jt808_term_param_item.big_loc_report.basic_info.status.A_brake =sys_sta.A_brake; // 1:自动刹车,0:手动刹车
jt808_term_param_item.big_loc_report.basic_info.status.A_Speed_Cut =sys_sta.A_Speed_Cut; // 1:自动减速,0:手动减速
jt808_term_param_item.big_loc_report.basic_info.status.P_Radar_EN =sys_sta.P_Radar_EN; // 1:雷达使能,0:雷达禁止
jt808_term_param_item.big_loc_report.basic_info.status.val32 = Swap32(jt808_term_param_item.big_loc_report.basic_info.status.val32); // 状态信息（转大端）
jt808_term_param_item.big_loc_report.basic_info.alarm_flag.val32 = 0; // 清除报警标志
@ -164,7 +177,7 @@ void Autoreport_param_Task(void *arg){
// jt808_term_param_item.big_loc_report.basic_info.alarm_flag.gnss_fault = 0 == gps_data.info.sig ? 1 : 0; // 0:无故障，1:有故障
if(0 == (count_Sec % jt808_term_param_item.set_term_param.HeartBeatInterval)){
if(0 == jt808_term_param_item.big_loc_report.basic_info.status.positioning){ // 未定位时发送心跳包
if((gps_data.info.fix == 1)||(gps_data.info.sig == 0)){ // 不可用// 未定位时发送心跳包
jt808_pkg_send(ID_Term_HB,0); // 发送心跳包 // 不接收应答
}else{
jt808_pkg_send(ID_LocReport,10000/5); // 发送位置信息上报包
@ -180,7 +193,7 @@ void jt808_Autoreport_param_start(void){
if(Autoreport_param_ThreadId == NULL){
osThreadAttr_t Autoreport_param_task_attr = {
.name = "Autoreport_param_Task",
.stack_size = 1024,
.stack_size = 4096*4,
.priority = osPriorityNormal,
};
Autoreport_param_ThreadId = osThreadNew((osThreadFunc_t)Autoreport_param_Task, 0, &Autoreport_param_task_attr);
@ -274,7 +287,7 @@ void jt808_set_term_param_init(void){
// jt808_term_param_item.big_auth_info.str_auth_code = NULL;
}while(0);
do{// 终端参数初始化
jt808_term_param_item.set_term_param.HeartBeatInterval = 5; // 心跳包间隔(秒)
jt808_term_param_item.set_term_param.HeartBeatInterval = 30; // 心跳包间隔(秒)
char ServerAddr[] ="47.99.118.34"; // 车牌号码
uint32_t ServerPort = 5000; // 服务器端口
// char ServerAddr[] ="36.137.226.30"; // 车牌号码

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

@ -21,8 +21,8 @@ uint8_t local_tts_volume(uint8_t volume);
// mode: 0-自动模式 1-数字模式,2-数值模式
void local_tts_set(int32_t speed, int32_t volume, cm_local_tts_digit_e mode);
// 本地TTS播放
// en_break=1时使能打断播放 //timeout=0时表示播放忙时，取消播放
int8_t local_tts_text_play(char *text, uint8_t len, uint8_t en_break, uint32_t timeout);
// 发送本地TTS播放内容
// len=0时自动计算长度//interruptible =1时,表示允许被打断播放
int8_t local_tts_text_play(char *text, uint8_t len, uint8_t en_interruptible);
#endif // __LOCAL_TTS_H__

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

@ -20,12 +20,14 @@
#define DEBUG(fmt, arg...)
#endif
static osMessageQueueId_t local_tts_play_queue = NULL;
// static osMessageQueueId_t local_tts_free_sem_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-未完成
// static osSemaphoreId_t local_tts_play_stat_sem = NULL;
// static int32_t TTS_play_finish_flag = 0; //播放完成标志位 0-完成 !=0-未完成
typedef struct{
cm_local_tts_cfg_t tts_cfg;
uint8_t en_interruptible;
char *text;
uint8_t len;
}tts_play_queue_t;
@ -38,10 +40,12 @@ void local_tts_mute(uint8_t mute){
// 音量设置 volume: 0-100
uint8_t local_tts_volume(uint8_t volume){
uint8_t ret;
if(volume > 100){
volume = 100;
int32_t vol = volume;
if(vol > 100){
vol = 100;
}
cm_audio_play_set_cfg(CM_AUDIO_PLAY_CFG_VOLUME, &volume); //音量设置 0-100
// DEBUG("[AUDIO] volume1:%d\n", vol);
cm_audio_play_set_cfg(CM_AUDIO_PLAY_CFG_VOLUME, &vol); //音量设置 0-100
cm_audio_play_get_cfg(CM_AUDIO_PLAY_CFG_VOLUME, &ret);
DEBUG("[AUDIO] volume:%d\n", ret);
return ret;
@ -59,7 +63,7 @@ void local_tts_set(int32_t speed, int32_t volume, cm_local_tts_digit_e mode){
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);
// 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");
}
@ -79,52 +83,39 @@ void local_tts_set(int32_t speed, int32_t volume, cm_local_tts_digit_e mode){
// 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播放内容
// len=0时自动计算长度//interruptible =1时,表示允许被打断播放
int8_t local_tts_text_play(char *text, uint8_t len, uint8_t en_interruptible){
// return 0;
DEBUG("tts text:%s,len:%d,en_interruptible:%d \n", text, len, en_interruptible);
tts_play_queue_t tts_play_queue = {0};
local_tts_mute(0); // 取消静音
if(0 == len || len > strlen(text)){
len = strlen(text);
DEBUG("tts play text len > len:%d \n", len);
DEBUG("tts text: len > len:%d \n", len);
}
tts_play_queue.text = cm_malloc(len + 1);
if(tts_play_queue.text == NULL){
DEBUG("tts play malloc error\n");
DEBUG("tts text: malloc error\n");
return -1;
}
memcpy(tts_play_queue.text, text, len);
tts_play_queue.text[len] = '\0';
tts_play_queue.len = len;
if(osOK != osMessageQueuePut(local_tts_play_queue, &tts_play_queue, 0, 0)){
DEBUG("tts play queue put error\n");
tts_play_queue.en_interruptible = en_interruptible;
DEBUG("tts text:Put queue\n");
if(local_tts_play_queue == NULL){
DEBUG("local_tts_play_queue is null\n");
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");
if(osOK != osMessageQueuePut(local_tts_play_queue, &tts_play_queue, 0, 0)){
DEBUG("tts text: queue put error\n");
cm_free(tts_play_queue.text);
return -1;
}
return 0;
}
@ -147,12 +138,11 @@ static void __local_tts_callback(cm_local_tts_event_e event, void *param)
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-未完成
case CM_LOCAL_TTS_EVENT_PLAY_FINISH:{
DEBUG("[PLAY_FINISH] %p=%x \n\n", param, *((osSemaphoreId_t *)param));
osSemaphoreRelease(local_tts_play_ok_sem); // 释放发送成功应答信号量
osSemaphoreRelease(local_tts_play_stat_sem);
break;
}
default:
break;
}
@ -166,10 +156,8 @@ static osThreadFunc_t local_tts_play_task(void *arg){
while(1){
if(osOK == osMessageQueueGet(local_tts_play_queue, &tts_play_queue, NULL, osWaitForever)){ //
// cm_local_tts_play_stop(); // 停止播放
// osDelay(300/5); // 等待播放停止
if(tts_play_queue.text == NULL){
if(tts_play_queue.len != 0){
if(tts_play_queue.len == 1){// 设置TTS参数
tts_play_queue.len = 0;
cm_local_tts_deinit();
if(15 < tts_play_queue.tts_cfg.speed){tts_play_queue.tts_cfg.speed = 15;}
@ -180,21 +168,27 @@ static osThreadFunc_t local_tts_play_task(void *arg){
}else{
DEBUG("tts set error\n");
}
osDelay(200/5);
}
DEBUG("tts play text is null\n");
DEBUG("tts task: text= null\n");
continue;
}
DEBUG("tts play start\n");
// 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);
if(0 == cm_local_tts_play_stop()){ // 停止播放
ret =osSemaphoreAcquire(local_tts_play_ok_sem, 30000/5);// 等待播放结束
if(osOK != ret){
DEBUG("local_tts_play_ok_sem:%d\n", ret);
}
}
TTS_play_finish_flag =0; //播放完成标志位 0-完成 !=0-未完成
DEBUG("tts play stop\n");
// DEBUG("tts task: 00000000000\n\n");
cm_local_tts_play(tts_play_queue.text, tts_play_queue.len, __local_tts_callback, NULL);
// DEBUG("tts task: 1111111111\n\n");
if(0 == tts_play_queue.en_interruptible){ // 不允许被打断播放
// DEBUG("tts task: 2222222222\n\n");
ret =osSemaphoreAcquire(local_tts_play_ok_sem, 30000/5);// 等待播放结束
if(osOK != ret){
DEBUG("local_tts_play_ok_sem:%d\n", ret);
}
}
// DEBUG("tts task: 3333333333\n\n");
cm_free(tts_play_queue.text);
tts_play_queue.text = NULL;
}
@ -215,8 +209,8 @@ void local_tts_init(void){
cm_local_tts_deinit();
cm_local_tts_cfg_t tts_cfg={
.speed = 5,
.volume = 15,
.speed = 6,
.volume = 7,
.encode = CM_LOCAL_TTS_ENCODE_TYPE_UTF8, // 离线TTS仅支持UTF8格式
.digit = CM_LOCAL_TTS_DIGIT_AUTO, // 自动模式
};
@ -225,23 +219,16 @@ void local_tts_init(void){
}else{
DEBUG("local_tts_init error\n");
}
osDelay(200/5); // 等待初始化完成
if(local_tts_play_queue == NULL){
local_tts_play_queue = osMessageQueueNew(1, sizeof(tts_play_queue_t), NULL);
local_tts_play_queue = osMessageQueueNew(50, 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,
.stack_size = 4096*4,
.priority = osPriorityNormal
};
osThreadNew((osThreadFunc_t)local_tts_play_task, NULL, &local_tts_play_thread_attr);
osDelay(200/5); // 等待初始化完成
}

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

@ -62,7 +62,7 @@ static void radar_AUTO_BrakeORSpeedCut(uint8_t radar_id , uint16_t Car_Distance)
if((35 < Car_Distance) && Car_Distance < Brake_Distance){//小于自动刹车距离时
if(!sys_sta.A_brake){
// local_tts_set(5, 15, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("自动刹车",0,1,0);
local_tts_text_play("自动刹车",0,0);
// Time_Event_Blink(Buzzer_Event,100,100,0xffff,NULL);
}
sys_sta.A_brake =1;//使能自动刹车
@ -70,14 +70,14 @@ static void radar_AUTO_BrakeORSpeedCut(uint8_t radar_id , uint16_t Car_Distance)
}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);
local_tts_text_play("减速",0,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);
// local_tts_text_play("自动刹车",0,0);
// Time_Event_Off(Buzzer_Event,NULL);
}
sys_sta.A_brake =0;
@ -153,7 +153,7 @@ void radar_init(void){
radar_data.distance = 0;
osThreadAttr_t radar_task_attr = {
.name = "uart_tx_task",
.stack_size = 2048,
.stack_size = 4096*4,
.priority= osPriorityNormal
};
os_RADAR_ThreadId= osThreadNew(RADAR_TaskHandle, 0, &radar_task_attr);

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

@ -100,7 +100,7 @@ int tcp_client_connect(const char *host, int port) {
if (tcp_recv_ThreadId == NULL){
osThreadAttr_t tcp_recv_task_attr = {0};
tcp_recv_task_attr.name = "tcp_recv_task";
tcp_recv_task_attr.stack_size = 1024;
tcp_recv_task_attr.stack_size = 4096*4;
tcp_recv_task_attr.priority = osPriorityNormal;
tcp_recv_ThreadId = osThreadNew((osThreadFunc_t)tcp_recv_task, 0, &tcp_recv_task_attr);
@ -178,21 +178,20 @@ TCP_DISABLE:
// app_printf("waiting for network...\n");
// }
}
}while(0 != tcp_client_connect(PrsResult.term_param_item->set_term_param.MainServerAddr , PrsResult.term_param_item->set_term_param.ServerPort)); // 连接到TCP服务器
}while(0 != tcp_client_connect((char *)(PrsResult.term_param_item->set_term_param.MainServerAddr) , PrsResult.term_param_item->set_term_param.ServerPort)); // 连接到TCP服务器
DEBUG("tcp_client_connect success!\r\n");
// 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){ // 0：成功；1：车辆已被注册；2：数据库中无该车辆；3：终端已被注册；4：数据库中无该终端
DEBUG("send ID_Term_Reg success!\n");
for(uint8_t i = 0; i < 3; i++){
for(uint8_t i = 0; i < 5; i++){
ret =jt808_pkg_send(ID_Term_Auth,10000/5);//终端鉴权 超时：10S
if(0 == ret){
DEBUG("send ID_Term_Auth success!\n");
break;
}else{
DEBUG("send ID_Term_Auth fail:%d!\n",ret);
if(ret == -1){
if((ret == -1)||(i == 3)){
goto TCP_DISABLE;
}
}
@ -208,23 +207,23 @@ TCP_DISABLE:
jt808_Autoreport_param_start();//开启自动上报参数设置
led_set_event(EVENT_NETWORK_READY); // 网络连接成功
DEBUG("\n\nNetwarK connected!\r\n\n");
DEBUG("NetwarK connected!\r\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表示最大等待时间
local_tts_text_play("网络已连接",0,0);
local_tts_text_play("欢迎使用莱昂特智能终端设备...。",0,0); // 0:表示自动计算字符串长度,10000表示最大等待时间
osSemaphoreAcquire(netconn_disconnect_sem, osWaitForever); // 等待断开连接信号
jt808_Autoreport_param_stop();//停止自动上报参数设置
led_set_event(EVENT_NETWORK_DISCONNECT); // 网络断开连接
DEBUG("\n\nNetwarK disconnected!\r\n\n");
DEBUG("NetwarK disconnected!\r\n");
// local_tts_set(5, 15, CM_LOCAL_TTS_DIGIT_AUTO);
local_tts_text_play("网络已断开",0,1,0);
local_tts_text_play("网络已断开",0,0);
}
}
void tcp_client_init(void){
osThreadAttr_t net_manage_task_attr={
.name = "net_manage_task",
.stack_size = 4096,
.stack_size = 4096*4,
.priority = osPriorityNormal,
};
DEBUG("tcp_client_init!\r\n");
@ -232,5 +231,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); // 等待网络管理线程启动
// osDelay(300/5); // 等待网络管理线程启动
}

3
include/cmiot/cm_local_tts.h
View File

@ -189,6 +189,9 @@ int32_t cm_local_tts_play(const char *text, int32_t len, cm_local_tts_callback c
*/
int32_t cm_local_tts_play_stop(void);
int32_t cm_local_tts_play_status(void);
#undef EXTERN
#ifdef __cplusplus
}

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

@ -6,16 +6,16 @@
#include "cm_audio_player.h"
#include "cm_audio_common.h"
#define DEBUG_ENABLE 1
#define DEBUG_ENABLE 0
#if DEBUG_ENABLE
#include "app_uart.h"
#define DEBUG(fmt, args...) app_printf("[tts]" fmt, ##args)
#define DEBUG(fmt, args...) app_printf("[cm_tts]" fmt, ##args)
#else
#define DEBUG(fmt, arg...)
#endif
#define CM_TTS_FRAME_BUFFER_SIZE (320 * 50 * 60) // (320 * 50 * 10)支持存放10秒数据，可修改
#define CM_TTS_FRAME_BUFFER_SIZE (320 * 50 * 30) // (320 * 50 * 10)支持存放10秒数据，可修改
typedef struct {
osThreadId_t TaskHandle; /* TTS播放管理句柄 */
@ -76,7 +76,7 @@ static void __cm_tts_play_task(void *param)
/* 转码速度大于播放速度，故无需考虑播放速度大于转码速度情况的延迟等待问题 */
while (index < cm_tts_play_cfg.TtsPcmBufLen && CM_LOCAL_TTS_STATE_WORKING == cm_tts_play_cfg.state)
{
DEBUG("%s() __%d__ Length is %d, index is %d", __func__, __LINE__, cm_tts_play_cfg.TtsPcmBufLen, index);
DEBUG("play_task :len:%d, index: %d\n",cm_tts_play_cfg.TtsPcmBufLen, index);
/* 每200ms传10帧PCM数据 */
if (index + 3200 <= cm_tts_play_cfg.TtsPcmBufLen)
@ -109,8 +109,6 @@ static void __cm_tts_play_task(void *param)
}
cm_audio_player_stream_close();
cm_tts_play_cfg.state = CM_LOCAL_TTS_STATE_IDLE;
cm_tts_play_cfg.TtsPcmBufLen = 0;
if (cm_tts_play_cfg.user_cb)
{
@ -123,6 +121,8 @@ static void __cm_tts_play_task(void *param)
cm_tts_play_cfg.user_cb(CM_LOCAL_TTS_EVENT_PLAY_FINISH, cm_tts_play_cfg.user_cb_param);
}
}
cm_tts_play_cfg.state = CM_LOCAL_TTS_STATE_IDLE;
cm_tts_play_cfg.TtsPcmBufLen = 0;
cm_free(cm_tts_play_cfg.TtsPcmBuf);
cm_tts_play_cfg.TtsPcmBuf = NULL;
@ -155,7 +155,7 @@ int32_t cm_local_tts_play(const char *text, int32_t len, cm_local_tts_callback c
//需要判断当前是否处于播放过程中，处于播放过程中报错
if (CM_LOCAL_TTS_STATE_WORKING == cm_tts_play_cfg.state)
{
DEBUG("%s() __%d__ TTS busy", __func__, __LINE__);
DEBUG(" TTS busy\n");
return -1;
}
@ -165,7 +165,7 @@ int32_t cm_local_tts_play(const char *text, int32_t len, cm_local_tts_callback c
if (NULL == cm_tts_play_cfg.TtsPcmBuf)
{
DEBUG("%s() __%d__ cm_malloc() error", __func__, __LINE__);
DEBUG("__%d__ cm_malloc() error",__LINE__);
return -1;
}
}
@ -174,11 +174,11 @@ 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);
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);
// DEBUG("__%d__ stream_open1() error, ret: %d", __LINE__, ret);
return -1;
// }
}
@ -189,7 +189,7 @@ int32_t cm_local_tts_play(const char *text, int32_t len, cm_local_tts_callback c
if (NULL == cm_tts_play_cfg.SemHandle)
{
DEBUG("%s() __%d__ osSemaphoreNew() error", __func__, __LINE__);
DEBUG("__%d__ osSemaphoreNew() error",__LINE__);
cm_audio_player_stream_close();
return -1;
}
@ -207,7 +207,7 @@ int32_t cm_local_tts_play(const char *text, int32_t len, cm_local_tts_callback c
if (NULL == cm_tts_play_cfg.TaskHandle)
{
DEBUG("%s() __%d__ osThreadNew() error", __func__, __LINE__);
DEBUG("__%d__ osThreadNew() error", __LINE__);
cm_audio_player_stream_close();
return -1;
}
@ -239,10 +239,17 @@ int32_t cm_local_tts_play(const char *text, int32_t len, cm_local_tts_callback c
*/
int32_t cm_local_tts_play_stop(void){
if (CM_LOCAL_TTS_STATE_IDLE == cm_tts_play_cfg.state){
DEBUG("%s() __%d__ no TTS task", __func__, __LINE__);
DEBUG("__%d__ no TTS task\n", __LINE__);
return -1;
}
cm_tts_play_cfg.state = CM_LOCAL_TTS_STATE_IDLE;;
return 0;
}
int32_t cm_local_tts_play_status(void){
if (CM_LOCAL_TTS_STATE_IDLE == cm_tts_play_cfg.state){
return -1;
}
return 0;
}