开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > DSP编程 > 查看源码
energyaddcorrellation_improve_done1.cpp
资源名称：se06.rar　[点击查看]
上传用户：kepeng103
上传日期：2022-07-27
资源大小：2653k
文件大小：13k
源码类别：

DSP编程

开发平台：

C/C++

energyaddcorrellation_improve_done1.cpp：源码内容
  1. /**********本函数的功能是用能量和自相*******************
  2. ***********关向量方差相结合的算法来进*******************
  3. ******************行VAD检测*****************************/
  5. /**********胡曙辉,2008年4月完成********************/
  7. /*4.3  加入了一些必须的初始化语句，*/
  8. /*4.7  在判断语音起始点和结束点加入了窗移动函数，即用连续多帧来进行判断*
  9. *******解决了训练过程的一个bug*******/
  10. /*4.8  把整个代码用函数实现**********/
  11. /*4.14 对语音的结束点判断采用了另一种方法*/
  12. /*4.16 静噪时候的压缩倍数必须增大，否则当输入信号的能量较大时，可以听到较小的压缩后输出。到1000倍左右，目前是150倍***
  13. ********为了减少误报率，必须提高能量门限，8倍到10倍左右，第二级门限设定到5至7倍，**
  14. ********找语音结束点的时候，采用的是两级判决方法，首先在50帧内计算出能量少于某一门限的帧数，如果帧数大于某一个值，这个值需要进行一定的试验调整（选15~25帧），然后对最后一帧用avv判决，这里好像有一定的偶然性，可能会提前终止语音。是否可以将avv加到能量判决那一部分中，统计同时满足两个条件的总帧数。*****
  15. ********当找到语音起始点的时候，默认输出100帧（1.6s），可能在换台的时候会使系统的静噪关断时延超过3s。因为后面还有50帧的统计，总时间为2.4s，如果第一次未能准确判决，将会有4.8s才能关断。将100帧换为75帧，时延减少0.4s，换为50帧，时延减少0.8s。********/
  16. /*k值有变换，今天试验的时候需要选择10，以前是2.5，有点奇怪。*/
  17. /*4.17 语音起始点判断的时候，连续两帧满足avv才判为语音起始点(效果很好，噪声误判率极低，试听了很久)*/
  18. /* 4.18 根据试验结果修改了一些参数值*/
  19. /* 4.23 改变了语音起始点的检测，起始点和结束点的参数也不一样，并不是判为噪声才进行噪声更新，在能量低于1.5倍门限的时候也进行噪声更新，防止长时间不更新噪声影响系统的判决。
  20.    每次找语音起始点之前重新训练信道*/
  21. #include "..commonhal.h"
  22. #include "device.h"
  23. #include "buf.h"
  24. #include <stdio.h>
  25. #include <math.h>
  26. #define PI 3.141592
  28. float noise_energy[10]={0};
  29. float subframe_energy[32]={0}; 
  30. float input_signal[128]={0};
  31. float energy_threshhold=0;
  32. float average_noiseenergy=0;
  33. float signal_energy=0;
  34. float signal_temp[128];
  35. float frame_energyvariance=0;
  36. float frame_noisereference=0;
  37. float frame_energyreference;
  38. int16 qq[128]={0};
  39. int16 *p;
  42. void train(void);
  43. void read_signal(void);
  44. void compress_signal(void);
  45. void subframe_energyvar(void);
  46. void noise_update(void);
  48. void sys_init(void)
  49. {
  50. gpio_init();
  51. dac_reset();
  52. mcbsp0_init_serial();
  53. adc_init();
  54. mcasp_init();
  55. timer0_init();
  56. ADC_SE_HI();
  58. ISTP = 0x00000400;
  59. IER |= 0x00000002;
  60. CSR |= 0x00000001;
  61. }
  63. void spark_led(void)
  64. {
  65. REG32(MCASP1_PFUNC) |= 0x0000003e;
  66. REG32(MCASP1_PDIR) |= 0x0000003e;
  67. REG32(MCASP1_PDOUT) = 0x00000000;
  69. uint8 code = 1;  
  70. for(int k=0; k<10; k++) 
  71. {
  72. set_led(0xff, code);
  73. code <<= 1;
  74. code = (code == 0x20? 1:code);
  75. delay_ms(100);
  76. }
  77. REG32(MCASP1_PDOUT) = 0x00000000;
  78. }
  80. int16 data[128];
  82. void data_init(void)
  83. {
  84. for(int i=0; i<128; i++) 
  85. {
  86. data[i] = 30000*sin(i*PI*2/64);
  87. }
  88. }
  90. /**本函数的目的是训练信道******
  91. ***输入:读入10帧数据     ******
  92. ***输出:得到average_noiseenergy值和energy_threshhold值*/
  93. void train(void)
  94. {
  95. int i;
  96. int j;
  97. for(i=0; i<10; i++)
  98. {
  99. noise_energy[i] = 0.0;
  100. }
  101. for(i=0; i<10; i++)
  102. {
  103. p = read_data();
  104. for(j=0; j<128; j++)
  105. {
  106. input_signal[j] = (float)p[j];
  107. noise_energy[i] += input_signal[j]*input_signal[j]; 
  108. qq[j] = input_signal[j];
  109. }
  110. noise_energy[i]/=128;
  111. compress_signal();//训练的时候默认是关断输出
  112. write_data(qq);
  113. }
  114. average_noiseenergy = 0.0;
  115. for(i=0; i<10; i++)
  116. {
  117. average_noiseenergy += noise_energy[i];
  118. }
  119. average_noiseenergy /= 10;
  121. //能量判决门限初始化为起始10帧数据的平均能量值;        
  122. energy_threshhold = average_noiseenergy;
  124. }//训练结束
  126. /*****功能:读取一帧数据，并计算出signal_energy****
  127. ******输入:无                                 ****
  128. ******输出:一帧数据和此数据帧的signal_energy值***/
  129. void read_signal(void)
  130. {
  131. int i;
  132. p = read_data();
  133. signal_energy = 0.0;
  134. for(i=0; i<128; i++)
  135. {
  136. input_signal[i] = (float)p[i];
  137. qq[i] = (int16)input_signal[i];
  138. signal_energy += input_signal[i]*input_signal[i];
  139.     
  140. }     
  141. signal_energy /= 128;
  142. }
  144. /****功能:对qq[128]赋值零****
  145. *****输入:无             ****
  146. *****输出:qq[128]        ***/
  147. void compress_signal(void)
  148. {
  149. int i;
  150. for(i=0; i<128; i++)
  151.     {
  152. qq[i] = 0;
  153. }
  154. }
  157. /*****功能:把一帧数据分成32个子帧，计算出子帧      ****
  158. ******的frame_energyvariance与frame_energyreference****
  159. ******输入:一帧数据                                ****
  160. ******输出:frame_energyvariance与frame_energyreference值***/
  161. void subframe_energyvar(void)
  162. {
  163. int i;
  164. int j;
  165. int subframe_number = 32;
  166. float subframe_total;
  167. float subframelength=128/subframe_number;
  168.         
  169. for(i=0; i<subframe_number; i++)
  170. {
  171. subframe_energy[i]=0;
  172. }
  173. for(i=0; i<subframe_number; i++)
  174. {
  175. for(j=0; j<subframelength; j++)
  176. subframe_energy[i] += input_signal[i*4+j]*input_signal[i*4+j];
  177. subframe_energy[i] /= subframelength;
  178. }
  179. subframe_total = 0;
  180. for(i=0; i<subframe_number; i++)
  181. {
  182. subframe_total += subframe_energy[i];
  183. }
  184. frame_energyreference = subframe_total/subframe_number;
  185. frame_energyvariance = 0.0;
  186. for(i=0; i<subframe_number; i++)
  187. {
  188. frame_energyvariance += (subframe_energy[i]-frame_energyreference)*(subframe_energy[i]-frame_energyreference);
  189. }
  190. frame_energyvariance = sqrt(frame_energyvariance);
  191. }
  194. /*****功能:更新门限energy_threshhold****
  195. ******使之能自适应信道的变化        ****
  196. ******输入:一帧数据                 ****
  197. ******输出:门限energy_threshhold值  ***/
  198. void noise_update(void)
  199. {
  200. int i;
  201. float old_noiseenergyvar;
  202. float new_noiseenergyvar;
  203. float ratio;
  204. float t;
  206.         
  207. average_noiseenergy = 0.0;
  208. for(i=0; i<10; i++)
  209. {
  210. average_noiseenergy += noise_energy[i];
  211. }
  212. average_noiseenergy /= 10;
  213.         
  214. old_noiseenergyvar = 0.0;
  215. for(i=0; i<10; i++)
  216. old_noiseenergyvar += (noise_energy[i]-average_noiseenergy)*(noise_energy[i]-average_noiseenergy);
  217.         
  218. for(i=0; i<9; i++) //这里i最高只能取8！！！        
  219. {
  220. noise_energy[i+1] = noise_energy[i];
  221. noise_energy[0] =  signal_energy;
  222. }
  223. average_noiseenergy = 0.0;
  224. for(i=0; i<10; i++)
  225. {
  226. average_noiseenergy += noise_energy[i];
  227. }
  228. average_noiseenergy /= 10;
  229. new_noiseenergyvar = 0.0;
  230. for(i=0; i<10; i++)
  231. new_noiseenergyvar += (noise_energy[i]-average_noiseenergy)*(noise_energy[i]-average_noiseenergy);
  232. old_noiseenergyvar = sqrt(old_noiseenergyvar);
  233. new_noiseenergyvar = sqrt(new_noiseenergyvar);
  234. //根据当前噪声能量方差与先前能量方差的比值来对p赋值,借此自适应的跟踪信道的噪声变化;                    
  235.         
  236. ratio = new_noiseenergyvar/old_noiseenergyvar;
  237. if(ratio>=1.25)
  238. t=0.25;
  239. else if(ratio>=1.10)
  240. t=0.20;
  241. else if(ratio>=1.00)
  242. t=0.15;        
  243. else
  244. t=0.10;
  245. energy_threshhold = energy_threshhold*(1-t)+t*noise_energy[0];
  246.        
  248. }
  252. int main(void)
  253. {
  254. float a;//avv判决语音起始点的倍数
  255. float b; //avv判决语音结束点的倍数
  256. float c;//第一级能量倍数
  257. float d;  //第二级能量倍数
  258. float f;
  259. int dip1,dip2,dip3,dip4;
  260. int value;  
  261. bool flag;
  263. CSR &= (~0x00000001);
  264. IER = 0;
  266. data_init();
  267. buf_init();
  268. timer1_init();
  269. spark_led();
  270. sys_init();
  273. //循环判断每帧数据    
  275. while(1)
  276. {         
  277. //用十帧数据来训练整个算法,并得到相关参数.
  278. train();
  279. flag = false;//初始化flag:语音有无标志
  280. //找语音的起始点
  281.         
  282. while(!flag)
  283. {            
  284. value = REG32(GPIO_GPVAL);
  285. dip1 = value & 0x00000001;
  286. dip2 = value & 0x00000080;
  287. dip3 = value & 0x00000040;
  288. dip4 = value & 0x00000020;
  290. if((!dip1) && (dip2) && (dip3) && (dip4))
  291. {
  292. a = 0.8;
  293. b = 0.5;
  294. c = 5;
  295. d = 3;
  296. f = 1.0;
  297. }
  299. else if((!dip1) && (dip2) && (dip3) && (!dip4))
  300. {
  301. a = 1.2;
  302. b = 1;
  303. c = 5;
  304. d = 4;
  305. f = 1.5;
  306. }
  308. else if((!dip1) && (dip2) && (!dip3) && (dip4))
  309. {
  310. a = 3;
  311. b = 3;
  312. c = 6;
  313. d = 4;
  314. f = 1.5;
  315. }
  318. else if((!dip1) && (dip2) && (!dip3) && (!dip4))
  319. {
  320. a = 5;
  321. b = 4;
  322. c = 6;
  323. d = 4;
  324. f=1.8;
  325. }
  326. else 
  327. ;
  328. read_signal();
  329. //能量判决,如果读入帧的能量与门限值比较,如果大于门限,则输出,                            
  330. if(signal_energy > c*energy_threshhold)
  331. {                  
  332. subframe_energyvar();
  333.           
  334. if(frame_energyvariance>(a-0.5)*(frame_energyreference+0.1))
  335. {            
  336. flag = true;                       
  337. write_data(qq);   
  338. }
  339. else
  340. {
  341. compress_signal();
  342. flag = false;
  343. write_data(qq);
  344. noise_update();
  345. }
  347. }
  348.     //如果是5倍门限以上则需看avv;         
  349. else if(signal_energy > d*energy_threshhold)
  350. {
  351. subframe_energyvar();
  353. //avv判决           
  354. if(frame_energyvariance > (a-0.5)*(frame_energyreference+0.1))
  355. {            
  356. flag = true;
  357. write_data(qq);
  358. }           
  359. else
  360. {                            
  361. compress_signal();
  362. flag = false;
  363. write_data(qq);
  364. noise_update();
  365. }
  366. }
  367.     
  368.         
  369. else if(signal_energy > 1.8*energy_threshhold)
  370. {                  
  371. subframe_energyvar();
  373. //avv判决;
  374. if(frame_energyvariance>a*(frame_energyreference+0.1))
  375. {                        
  377. compress_signal();
  378. write_data(qq);
  379. read_signal();
  380. subframe_energyvar();
  382. //avv判决;
  383. if(frame_energyvariance>(a)*(frame_energyreference+0.1))
  384. {
  385. flag = true;
  386. write_data(qq);
  387. }
  388. else
  389. {
  390. compress_signal();
  391. write_data(qq);
  392. flag = false;
  393. noise_update();
  394. }
  395. }                
  396. //当判为静音帧时进行噪声更新;                  
  397. else                  
  398. {                        
  399. compress_signal();                        
  400. write_data(qq);
  401. flag = false;                        
  402. noise_update();                  
  403. }             
  404. }
  406. //小能量帧用avv判决 
  407. else
  408. {
  409. subframe_energyvar();
  410. if(frame_energyvariance>(a+0.5)*(frame_energyreference+0.1))//文献中用的是frame_noisereference
  411. {
  412. compress_signal();
  413. write_data(qq);
  414. read_signal();
  415. subframe_energyvar();
  417. //进一步avv判决;
  418. if(frame_energyvariance>(a+0.5)*(frame_energyreference+0.1))
  419. {
  420. flag = true;
  421. write_data(qq);
  422. }
  423. else
  424. {
  425. compress_signal();
  426. write_data(qq);
  427. flag = false;
  428. noise_update();
  429. }
  430. }
  431. else
  432. {
  433. compress_signal();
  434. write_data(qq);
  435. flag = false;
  436. noise_update();
  437. }
  438. }//if(signal_energy > 8*energy_threshhold)
  439. }//while(!flag)结束
  441.        //找语音的结束点
  442. //如果有连续        
  443. while(flag)
  444. {    
  445.     value = REG32(GPIO_GPVAL);
  446. dip1 = value & 0x00000001;
  447. dip2 = value & 0x00000080;
  448. dip3 = value & 0x00000040;
  449. dip4 = value & 0x00000020;
  451. if((!dip1) && (dip2) && (dip3) && (dip4))
  452. {
  453. a = 0.8;
  454. b = 0.8;
  455. c = 5;
  456. d = 3;
  457. f = 1.0;
  458. }
  460. else if((!dip1) && (dip2) && (dip3) && (!dip4))
  461. {
  462. a = 1.2;
  463. b = 1;
  464. c = 5;
  465. d = 4;
  466. f = 1.5;
  467. }
  469. else if((!dip1) && (dip2) && (!dip3) && (dip4))
  470. {
  471. a = 3;
  472. b = 3;
  473. c = 6;
  474. d = 4;
  475. f = 1.5;
  476. }
  479. else if((!dip1) && (dip2) && (!dip3) && (!dip4))
  480. {
  481. a = 5;
  482. b = 4;
  483. c = 6;
  484. d = 4;
  485. f = 1.8;
  486. }
  487. else 
  488. ;
  489. //这种判断方法是在50帧中如果有15帧的能量小于1.5倍门限则进一步用avv判决  
  490. int s = 150;
  491. int totalenergynum = 0;
  492. int totalavvnum = 0;
  493. int totalnum = 0;
  494. read_signal();
  496. //能量判决,如果读入k帧的能量与门限值比较,如果大于门限,则输出,否则进一步用AVV判决;               
  497. while(s!=0)
  498. {
  499. if(signal_energy < f*energy_threshhold)
  500. {
  501. totalenergynum++;
  502. noise_update();
  503. }
  504. else if(signal_energy < 1.8*energy_threshhold)
  505. {
  506. totalnum++;
  507. }
  508. else
  509. ;
  511. subframe_energyvar();
  513. //根据子帧能量方差与子帧的平均能量比较来做判决;
  514. if(frame_energyvariance<(b)*(frame_energyreference+0.1))
  515. {
  516. totalavvnum++;
  517. }
  518.                    
  519. write_data(qq);
  520. read_signal();
  521. s--;
  522. }
  524. //if(totalnum>60 && totalavvnum<60)
  525. //{
  526. // flag = true;  
  527. // write_data(qq);
  528. //}
  529. //else
  530. {
  531. if(totalenergynum>120)
  532. {
  533. totalenergynum=0;
  534. //语音结束点，并更新噪声
  535. flag = false;
  536. compress_signal();
  537. write_data(qq);
  538. noise_update();//当判为静音帧时进行噪声更新          
  539. }//if(totalenergynum>70 && totalavvnum>50)结束
  540. else
  541. {
  542. flag = true;
  543. write_data(qq);
  544. }
  546. }//while(s!=0)结束
  548. }//while(flag)结束
  550.     }//while(1)结束
  552. }//主函数结束