466 lines
11 KiB
C
466 lines
11 KiB
C
#include "app_config.h"
|
|
#include "server/audio_server.h"
|
|
#include "os/os_api.h"
|
|
#include "server/server_core.h"
|
|
|
|
#ifdef CONFIG_ACOUSTIC_COMMUNICATION_ENABLE
|
|
|
|
#include "voiceprint_cfg.h"
|
|
#include "MultSine_Control.h"
|
|
|
|
typedef struct __us_ctl {
|
|
s16 us_buf[2][512];
|
|
u8 us_bufnum;
|
|
u8 csb_key[2];
|
|
u8 csb_cnt;
|
|
} _us_ctl;
|
|
|
|
typedef struct __us_wifi {
|
|
u8 ssid_pwd[128];
|
|
u8 ssid_pwd_cnt;
|
|
u8 head_is_recv;
|
|
u8 lens;
|
|
u8 j;
|
|
u8 l;
|
|
u32 time_out_cnt;
|
|
} _us_wifi;
|
|
|
|
enum {
|
|
US_COME_CMD,
|
|
US_CLOSE_CMD,
|
|
US_INIT_CMD,
|
|
US_CALC_CMD,
|
|
US_WIFI_SUCC,
|
|
US_BYTE_OT,
|
|
};
|
|
|
|
|
|
#define US_STA_NAME_LEN 33
|
|
#define US_STA_PWD_LEN 65
|
|
#define US_RANDOM_LEN 8
|
|
#define TotalFreq 17
|
|
|
|
struct vp_cfg {
|
|
struct server *audio_rec;
|
|
_us_ctl us_ctl;
|
|
_us_wifi us_wifi;
|
|
u8 us_ssid_pwd_is_recv;
|
|
char us_ssid[US_STA_NAME_LEN];
|
|
char us_pwd[US_STA_PWD_LEN];
|
|
u8 us_random[US_RANDOM_LEN];
|
|
int pre_code;
|
|
MultSine_Control *us_con;
|
|
int pid;
|
|
};
|
|
static struct vp_cfg *vp_cfg;
|
|
|
|
#define VOICE_PRINT_TASK_NAME "voiceprint"
|
|
|
|
static void aud_rec_stop();
|
|
static int aud_rec_start();
|
|
|
|
|
|
static int const coeff[TotalFreq] = {
|
|
//48000
|
|
615432,
|
|
818268,
|
|
1019133,
|
|
1217542,
|
|
1413018,
|
|
1605091,
|
|
1793296,
|
|
1977181,
|
|
2156303,
|
|
2330230,
|
|
2498544,
|
|
2660838,
|
|
2816722,
|
|
2965821,
|
|
3107774,
|
|
3242241,
|
|
3368897
|
|
};
|
|
|
|
static void us_code_post(int code)
|
|
{
|
|
int i;
|
|
int real_code;
|
|
|
|
for (i = 0; i < TotalFreq; i++) {
|
|
if (code & (1 << i)) {
|
|
code = i;
|
|
}
|
|
}
|
|
|
|
vp_cfg->us_wifi.time_out_cnt = 0;
|
|
|
|
if (code != vp_cfg->pre_code) {
|
|
if (code == 0x10) {
|
|
real_code = vp_cfg->pre_code;
|
|
} else {
|
|
real_code = code;
|
|
}
|
|
|
|
vp_cfg->pre_code = code;
|
|
|
|
if (vp_cfg->us_ctl.csb_cnt == 0) {
|
|
vp_cfg->us_ctl.csb_key[0] = real_code;
|
|
vp_cfg->us_ctl.csb_cnt = 1;
|
|
/*os_taskq_post(VOICE_PRINT_TASK_NAME, 1, US_COME_CMD);*/
|
|
} else {
|
|
vp_cfg->us_ctl.csb_key[1] = real_code ;
|
|
vp_cfg->us_ctl.csb_cnt = 0;
|
|
os_taskq_post(VOICE_PRINT_TASK_NAME, 1, US_COME_CMD);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
static void us_close()
|
|
{
|
|
printf("us_close\n");
|
|
|
|
aud_rec_stop();
|
|
}
|
|
|
|
static void us_init()
|
|
{
|
|
printf("us init\n");
|
|
|
|
MultSine_Control_init(vp_cfg->us_con, TotalFreq, 256, 1, 2000, us_code_post, coeff, 1);
|
|
|
|
aud_rec_start();
|
|
}
|
|
|
|
static u8 get_ssid_pwd_deal(u8 *buf, u8 len)
|
|
{
|
|
u8 i, fen = 0, dian = 0, rand = 0;
|
|
for (i = 0; i < len; i++) {
|
|
if (buf[i] == 0x02) {
|
|
fen = i;
|
|
} else if (buf[i] == 0x03) {
|
|
dian = i;
|
|
} else if (buf[i] == 0x04) {
|
|
rand = i;
|
|
}
|
|
}
|
|
|
|
if (fen == 0 || dian == 0 || rand == 0 || fen >= dian || dian >= rand) {
|
|
return -1;
|
|
}
|
|
|
|
memset(vp_cfg->us_ssid, 0, US_STA_NAME_LEN);
|
|
memset(vp_cfg->us_pwd, 0, US_STA_PWD_LEN);
|
|
memset(vp_cfg->us_random, 0, US_RANDOM_LEN);
|
|
memcpy(vp_cfg->us_ssid, buf, fen);
|
|
memcpy(vp_cfg->us_pwd, buf + fen + 1, dian - fen - 1);
|
|
memcpy(vp_cfg->us_random, buf + dian + 1, rand - dian - 1);
|
|
vp_cfg->us_ssid_pwd_is_recv = 1;
|
|
printf("us_ssid:%s\n", vp_cfg->us_ssid);
|
|
printf("us_pwd :%s\n", vp_cfg->us_pwd);
|
|
printf("us_rand :%s\n", vp_cfg->us_random);
|
|
|
|
os_taskq_post(VOICE_PRINT_TASK_NAME, 1, US_WIFI_SUCC);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void us_wifi_byte_deal(u8 a, u8 b)
|
|
{
|
|
u8 i_cnt;
|
|
u8 val = a << 4 | b;
|
|
|
|
printf("us recv: 0x%x,%c\n", val, val);
|
|
vp_cfg->us_wifi.ssid_pwd[vp_cfg->us_wifi.ssid_pwd_cnt] = val;
|
|
if (vp_cfg->us_wifi.ssid_pwd_cnt == 0) {
|
|
vp_cfg->us_wifi.j = val;
|
|
if (vp_cfg->us_wifi.j != 'J') {
|
|
goto _us_wifi_reset;
|
|
}
|
|
|
|
printf(" us recv J\n");
|
|
}
|
|
|
|
if (vp_cfg->us_wifi.ssid_pwd_cnt == 1) {
|
|
vp_cfg->us_wifi.l = val;
|
|
if (vp_cfg->us_wifi.l != 'L') {
|
|
goto _us_wifi_reset;
|
|
}
|
|
|
|
printf(" us recv L\n");
|
|
}
|
|
|
|
if (vp_cfg->us_wifi.ssid_pwd_cnt == 2) {
|
|
vp_cfg->us_wifi.lens = val;
|
|
if (vp_cfg->us_wifi.lens >= 128) {
|
|
goto _us_wifi_reset;
|
|
}
|
|
|
|
/*printf(" us recv len = %d\n", vp_cfg->us_wifi.lens);*/
|
|
}
|
|
|
|
vp_cfg->us_wifi.ssid_pwd_cnt++;
|
|
if (vp_cfg->us_wifi.ssid_pwd_cnt >= 128) {
|
|
goto _us_wifi_reset;
|
|
}
|
|
|
|
if (vp_cfg->us_wifi.ssid_pwd_cnt == vp_cfg->us_wifi.lens) {
|
|
//收完一整个包,校验解释数据
|
|
val = 0;
|
|
for (i_cnt = 0; i_cnt < vp_cfg->us_wifi.lens - 1; i_cnt++) {
|
|
val += vp_cfg->us_wifi.ssid_pwd[i_cnt];
|
|
}
|
|
/*printf("us val = 0x%x,recv = 0x%x\n", val, vp_cfg->us_wifi.ssid_pwd[vp_cfg->us_wifi.lens - 1]);*/
|
|
if (val != vp_cfg->us_wifi.ssid_pwd[vp_cfg->us_wifi.lens - 1]) {
|
|
goto _us_wifi_reset;
|
|
}
|
|
|
|
val = get_ssid_pwd_deal(vp_cfg->us_wifi.ssid_pwd + 3, vp_cfg->us_wifi.lens - 4); //去掉头部和校验
|
|
if (val) {
|
|
goto _us_wifi_reset;
|
|
}
|
|
}
|
|
|
|
return;
|
|
|
|
_us_wifi_reset:
|
|
printf("us wifi reset...\n");
|
|
memset(&vp_cfg->us_wifi, 0, sizeof(_us_wifi));
|
|
vp_cfg->us_ctl.csb_cnt = 0;
|
|
vp_cfg->pre_code = 0x10;
|
|
|
|
return;
|
|
}
|
|
|
|
#if 0
|
|
static void ustimeout_fun(void *parm)
|
|
{
|
|
//2ms
|
|
parm = parm;
|
|
|
|
//多久未收到一个字节超时
|
|
vp_cfg->us_wifi.time_out_cnt++;//0.8s
|
|
if (vp_cfg->us_wifi.time_out_cnt >= 400) {
|
|
printf("us ot\n");
|
|
vp_cfg->us_wifi.time_out_cnt = 0;
|
|
os_taskq_post(VOICE_PRINT_TASK_NAME, 1, US_BYTE_OT);
|
|
}
|
|
|
|
}
|
|
#endif
|
|
|
|
static void us_task(void *arg)
|
|
{
|
|
u8 temp_us_bufnum;
|
|
int res;
|
|
int msg[32];
|
|
|
|
printf("\n\n======us_task=====\n\n");
|
|
|
|
vp_cfg->pre_code = 0x10;
|
|
us_init();
|
|
|
|
while (1) {
|
|
res = os_task_pend("taskq", msg, ARRAY_SIZE(msg));
|
|
switch (res) {
|
|
case OS_TASKQ:
|
|
switch (msg[0]) {
|
|
case Q_USER:
|
|
switch (msg[1]) {
|
|
case US_CALC_CMD:
|
|
temp_us_bufnum = vp_cfg->us_ctl.us_bufnum ^ 1;
|
|
if (vp_cfg->us_ssid_pwd_is_recv == 0) {
|
|
#if 0
|
|
static FILE *file_test;
|
|
if (file_test == NULL) {
|
|
file_test = fopen("mnt/spiflash/res/ms.raw", "r");
|
|
}
|
|
res = fread(file_test, &vp_cfg->us_ctl.us_buf[temp_us_bufnum], 512);
|
|
if (res != 512) {
|
|
fclose(file_test);
|
|
file_test = NULL;
|
|
}
|
|
#endif
|
|
MultSine_Control_run(vp_cfg->us_con, (short *)&vp_cfg->us_ctl.us_buf[temp_us_bufnum], 256);
|
|
}
|
|
|
|
break;
|
|
|
|
case US_WIFI_SUCC:
|
|
printf("US_WIFI_SUCC\n");
|
|
|
|
extern int voiceprint_cfg_net_set_ssid_pwd(const char *ssid, const char *pwd, const char *rand_str);
|
|
voiceprint_cfg_net_set_ssid_pwd(vp_cfg->us_ssid, vp_cfg->us_pwd, (const char *)vp_cfg->us_random);
|
|
|
|
case US_CLOSE_CMD:
|
|
printf("US_CLOSE_CMD\n");
|
|
us_close();
|
|
return;
|
|
|
|
case US_BYTE_OT:
|
|
memset(&vp_cfg->us_wifi, 0, sizeof(_us_wifi));
|
|
vp_cfg->us_ctl.csb_cnt = 0;
|
|
vp_cfg->pre_code = 0x10;
|
|
MultSine_Control_init(vp_cfg->us_con, TotalFreq, 256, 1, 2000, us_code_post, coeff, 1);
|
|
break;
|
|
|
|
case US_COME_CMD:
|
|
//us_printf("US_COME_CMD:%d %d\n",vp_cfg->us_ctl.csb_key[0],vp_cfg->us_ctl.csb_key[1]);
|
|
us_wifi_byte_deal(vp_cfg->us_ctl.csb_key[0], vp_cfg->us_ctl.csb_key[1]);
|
|
break;
|
|
default :
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int vfs_fwrite(void *file, void *buf, u32 len)
|
|
{
|
|
if (vp_cfg->us_ssid_pwd_is_recv == 0) {
|
|
s16 *buf1 = buf;
|
|
|
|
memcpy(vp_cfg->us_ctl.us_buf[vp_cfg->us_ctl.us_bufnum], buf1, len);
|
|
|
|
vp_cfg->us_ctl.us_bufnum ^= 1;
|
|
|
|
os_taskq_post(VOICE_PRINT_TASK_NAME, 1, US_CALC_CMD);
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
static int vfs_fclose(void *file)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static const struct audio_vfs_ops audio_vfs_ops = {
|
|
.fwrite = vfs_fwrite,
|
|
.fclose = vfs_fclose,
|
|
};
|
|
|
|
|
|
static void enc_server_event_handler(void *priv, int argc, int *argv)
|
|
{
|
|
switch (argv[0]) {
|
|
case AUDIO_SERVER_EVENT_END:
|
|
puts("audio_server_enc_end\n");
|
|
break;
|
|
case AUDIO_SERVER_EVENT_ERR:
|
|
puts("audio_server_enc_err\n");
|
|
break;
|
|
case AUDIO_SERVER_EVENT_CURR_TIME:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static int aud_rec_start()
|
|
{
|
|
union audio_req req = {0};
|
|
|
|
if (!vp_cfg->audio_rec) {
|
|
vp_cfg->audio_rec = server_open("audio_server", "enc");
|
|
/*server_register_event_handler(vp_cfg->audio_rec, NULL, enc_server_event_handler);*/
|
|
}
|
|
|
|
req.enc.cmd = AUDIO_ENC_OPEN;
|
|
req.enc.channel = 1;
|
|
req.enc.volume = 100;
|
|
req.enc.priority = 0;
|
|
req.enc.output_buf = NULL;
|
|
req.enc.output_buf_len = 16 * 1024;
|
|
req.enc.sample_rate = 48000;
|
|
req.enc.msec = 0;
|
|
req.enc.format = "pcm";
|
|
req.enc.frame_size = 512;
|
|
#if CONFIG_AUDIO_ENC_SAMPLE_SOURCE == AUDIO_ENC_SAMPLE_SOURCE_PLNK0
|
|
req.enc.sample_source = "plnk0";
|
|
#elif CONFIG_AUDIO_ENC_SAMPLE_SOURCE == AUDIO_ENC_SAMPLE_SOURCE_PLNK1
|
|
req.enc.sample_source = "plnk1";
|
|
#elif CONFIG_AUDIO_ENC_SAMPLE_SOURCE == AUDIO_ENC_SAMPLE_SOURCE_IIS0
|
|
req.enc.sample_source = "iis0";
|
|
#elif CONFIG_AUDIO_ENC_SAMPLE_SOURCE == AUDIO_ENC_SAMPLE_SOURCE_IIS1
|
|
req.enc.sample_source = "iis1";
|
|
#else
|
|
req.enc.sample_source = "mic";
|
|
#endif
|
|
req.enc.vfs_ops = &audio_vfs_ops;
|
|
req.enc.file = NULL;
|
|
#ifdef CONFIG_ALL_ADC_CHANNEL_OPEN_ENABLE
|
|
req.enc.channel_bit_map = BIT(CONFIG_VOICE_NET_CFG_ADC_CHANNEL);
|
|
#endif
|
|
server_request(vp_cfg->audio_rec, AUDIO_REQ_ENC, &req);
|
|
|
|
req.enc.cmd = AUDIO_ENC_START;
|
|
server_request(vp_cfg->audio_rec, AUDIO_REQ_ENC, &req);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void aud_rec_stop()
|
|
{
|
|
if (!vp_cfg->audio_rec) {
|
|
return;
|
|
}
|
|
union audio_req r;
|
|
memset(&r, 0, sizeof(union audio_req));
|
|
r.enc.cmd = AUDIO_ENC_STOP;
|
|
server_request(vp_cfg->audio_rec, AUDIO_REQ_ENC, &r);
|
|
r.enc.cmd = AUDIO_ENC_CLOSE;
|
|
server_request(vp_cfg->audio_rec, AUDIO_REQ_ENC, &r);
|
|
server_close(vp_cfg->audio_rec);
|
|
vp_cfg->audio_rec = NULL;
|
|
}
|
|
|
|
int voiceprint_cfg_start(void)
|
|
{
|
|
if (vp_cfg) {
|
|
return 0;
|
|
}
|
|
|
|
vp_cfg = zalloc(sizeof(struct vp_cfg) + MultSine_Control_QuaryBufSize(17, 256));
|
|
if (!vp_cfg) {
|
|
return -1;
|
|
}
|
|
vp_cfg->us_con = (MultSine_Control *)(((char *)vp_cfg) + sizeof(struct vp_cfg));
|
|
|
|
return thread_fork(VOICE_PRINT_TASK_NAME, 11, 2048, 32, &vp_cfg->pid, us_task, NULL);
|
|
}
|
|
|
|
void voiceprint_cfg_stop(void)
|
|
{
|
|
if (vp_cfg == NULL) {
|
|
return;
|
|
}
|
|
|
|
int retry = 0;
|
|
int ret;
|
|
vp_cfg->us_ssid_pwd_is_recv = 1;
|
|
|
|
do {
|
|
ret = os_taskq_post(VOICE_PRINT_TASK_NAME, 1, US_CLOSE_CMD);
|
|
if (ret != OS_NO_ERR) {
|
|
msleep(50);
|
|
retry++;
|
|
} else {
|
|
break;
|
|
}
|
|
} while (retry < 5);
|
|
|
|
if (ret != OS_NO_ERR) {
|
|
puts("voiceprint_cfg_stop fail\n");
|
|
}
|
|
|
|
thread_kill(&vp_cfg->pid, KILL_WAIT);
|
|
free(vp_cfg);
|
|
vp_cfg = NULL;
|
|
}
|
|
|
|
#endif
|