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

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

DSP编程

开发平台：

C/C++

new.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 FRAMELEN  256   
  27. #define PI       4.0*atan(1.0)
  29. float noise_energy[10]={0};
  30. float subframe_energy[32]={0}; 
  31. float input_signal[128]={0};
  32. float energy_threshhold=0;
  33. float average_noiseenergy=0;
  34. float signal_energy=0;
  35. float signal_temp[128];
  36. float frame_energyvariance=0;
  37. float frame_noisereference=0;
  38. float frame_energyreference;
  39. int16 qq[128]={0};
  40. int16 *p;
  43. /////////////////
  44. int16 cm[128];
  46. float w1[FRAMELEN]; //蝶形因子
  47. float fft1[FRAMELEN*2];    //每帧语音信号的FFT 
  48. float yp[FRAMELEN]; //未处理语音信号的功率谱
  49. float dp[129]; //噪声功率谱
  50. float xp[129]; //增强后语音信号的功率谱
  51. float predp[129];         //前一帧噪声信号的功率谱
  52. float prexp[129];         //前一帧增强后语音信号的功率谱
  53. float yo[FRAMELEN]; //增强后的时域信号
  54. float sita[FRAMELEN]; //相角
  55. float amp[FRAMELEN]; //幅度值
  56. float pre_energy[200]; //统计直方图所用每帧信号能量
  57. unsigned quota[129];
  58. float dm[FRAMELEN]; 
  59. float d1[FRAMELEN];
  60. float const hamming[FRAMELEN] = {0.0800, 0.0801, 0.0806, 0.0812, 0.0822, 0.0835, 0.0850, 0.0868, 
  61.      0.0888, 0.0912, 0.0938, 0.0967, 0.0998, 0.1032, 0.1069, 0.1108, 
  62.  0.1150, 0.1195, 0.1242, 0.1291, 0.1343, 0.1398, 0.1454, 0.1514, 
  63.                      0.1575, 0.1639, 0.1705, 0.1774, 0.1844, 0.1917, 0.1992, 0.2068, 
  64.                      0.2147, 0.2228, 0.2311, 0.2395, 0.2482, 0.2570, 0.2660, 0.2751, 
  65.                      0.2844, 0.2939, 0.3035, 0.3133, 0.3232, 0.3332, 0.3433, 0.3536, 
  66.                      0.3640, 0.3744, 0.3850, 0.3957, 0.4065, 0.4173, 0.4282, 0.4392, 
  67.                      0.4503, 0.4614, 0.4725, 0.4837, 0.4949, 0.5062, 0.5174, 0.5287, 
  68.                      0.5400, 0.5513, 0.5626, 0.5738, 0.5851, 0.5963, 0.6075, 0.6186, 
  69.                      0.6297, 0.6408, 0.6518, 0.6627, 0.6735, 0.6843, 0.6950, 0.7056, 
  70.                      0.7160, 0.7264, 0.7367, 0.7468, 0.7568, 0.7667, 0.7765, 0.7861, 
  71.                      0.7956, 0.8049, 0.8140, 0.8230, 0.8318, 0.8405, 0.8489, 0.8572, 
  72.                      0.8653, 0.8732, 0.8808, 0.8883, 0.8956, 0.9026, 0.9095, 0.9161, 
  73.                      0.9225, 0.9286, 0.9346, 0.9402, 0.9457, 0.9509, 0.9558, 0.9605, 
  74.                      0.9650, 0.9692, 0.9731, 0.9768, 0.9802, 0.9833, 0.9862, 0.9888, 
  75.                      0.9912, 0.9932, 0.9950, 0.9965, 0.9978, 0.9988, 0.9994, 0.9999, 
  76.                      1.0000, 0.9999, 0.9994, 0.9988, 0.9978, 0.9965, 0.9950, 0.9932, 
  77.                      0.9912, 0.9888, 0.9862, 0.9833, 0.9802, 0.9768, 0.9731, 0.9692, 
  78.                      0.9650, 0.9605, 0.9558, 0.9509, 0.9457, 0.9402, 0.9346, 0.9286, 
  79.                      0.9225, 0.9161, 0.9095, 0.9026, 0.8956, 0.8883, 0.8808, 0.8732, 
  80.                      0.8653, 0.8572, 0.8489, 0.8405, 0.8318, 0.8230, 0.8140, 0.8049, 
  81.                      0.7956, 0.7861, 0.7765, 0.7667, 0.7568, 0.7468, 0.7367, 0.7264, 
  82.                      0.7160, 0.7056, 0.6950, 0.6843, 0.6735, 0.6627, 0.6518, 0.6408, 
  83.                      0.6297, 0.6186, 0.6075, 0.5963, 0.5851, 0.5738, 0.5626, 0.5513, 
  84.                      0.5400, 0.5287, 0.5174, 0.5062, 0.4949, 0.4837, 0.4725, 0.4614, 
  85.                      0.4503, 0.4392, 0.4282, 0.4173, 0.4065, 0.3957, 0.3850, 0.3744, 
  86.                      0.3640, 0.3536, 0.3433, 0.3332, 0.3232, 0.3133, 0.3035, 0.2939, 
  87.                      0.2844, 0.2751, 0.2660, 0.2570, 0.2482, 0.2395, 0.2311, 0.2228, 
  88.                      0.2147, 0.2068, 0.1992, 0.1917, 0.1844, 0.1774, 0.1705, 0.1639, 
  89.                      0.1575, 0.1514, 0.1454, 0.1398, 0.1343, 0.1291, 0.1242, 0.1195, 
  90.                      0.1150, 0.1108, 0.1069, 0.1032, 0.0998, 0.0967, 0.0938, 0.0912, 
  91.                      0.0888, 0.0868, 0.0850, 0.0835, 0.0822, 0.0812, 0.0806, 0.0801}; //hamming窗
  92. float out1[FRAMELEN/2];
  93. ///////////
  96. void train(void);
  97. void read_signal(void);
  98. void compress_signal(void);
  99. void subframe_energyvar(void);
  100. void noise_update(void);
  102. void sys_init(void)
  103. {
  104. gpio_init();
  105. dac_reset();
  106. mcbsp0_init_serial();
  107. adc_init();
  108. mcasp_init();
  109. timer0_init();
  110. ADC_SE_HI();
  112. ISTP = 0x00000400;
  113. IER |= 0x00000002;
  114. CSR |= 0x00000001;
  115. }
  117. void spark_led(void)
  118. {
  119. REG32(MCASP1_PFUNC) |= 0x0000003e;
  120. REG32(MCASP1_PDIR) |= 0x0000003e;
  121. REG32(MCASP1_PDOUT) = 0x00000000;
  123. uint8 code = 1;  
  124. for(int k=0; k<10; k++) 
  125. {
  126. set_led(0xff, code);
  127. code <<= 1;
  128. code = (code == 0x20? 1:code);
  129. delay_ms(100);
  130. }
  131. REG32(MCASP1_PDOUT) = 0x00000000;
  132. }
  134. int16 data[128];
  136. void data_init(void)
  137. {
  138. for(int i=0; i<128; i++) 
  139. {
  140. data[i] = 30000*sin(i*PI*2/64);
  141. }
  142. }
  144. //////////////////////////
  145. void gen_w_r2(float* w, int n)     //产生旋转因子（n个）的函数
  146. {
  147.     int i;
  148.     float pi = 4.0*atan(1.0);
  149.     float e = pi*2.0/n;
  151.     for(i=0; i < ( n>>1 ); i++) {
  152.         w[2*i]   = cos(i*e);
  153.         w[2*i+1] = sin(i*e);
  154.     }
  155. }
  157. void bit_rev(float* x, int n)     //产生n比特翻转的函数,将x[]做n比特翻转
  158. {
  159.     int i, j, k;
  160.     float rtemp, itemp;
  161.     j = 0;
  163.     for(i=1; i < (n-1); i++) {
  164.         k = n >> 1;
  165.         while(k <= j) {
  166.             j -= k;
  167.             k >>= 1;
  168.         }
  169.         j += k;
  170.         if(i < j) {
  171.             rtemp    = x[j*2];
  172.             x[j*2]   = x[i*2];
  173.             x[i*2]   = rtemp;
  174.             itemp    = x[j*2+1];
  175.             x[j*2+1] = x[i*2+1];
  176.             x[i*2+1] = itemp;
  177.         }
  178.     }
  179. }
  182. void DSPF_sp_cfftr2_dit(float* x, float* w, short n)       //计算n点FFT的函数
  183. {                                                                   
  184.     short n2, ie, ia, i, j, k, m;                                    
  185.     float rtemp, itemp, c, s;                                        
  187.     n2 = n;                                                          
  188.     ie = 1;                                                          
  190.     for(k=n; k > 1; k >>= 1) {                                                                
  191.         n2 >>= 1; 
  192.         ia = 0;
  193.         for(j=0; j < ie; j++) {                                                             
  194.             c = w[2*j];
  195.             s = w[2*j+1];
  196.             for(i=0; i < n2; i++) {                                                          
  197.                 m = ia + n2;
  198.                 rtemp     = c * x[2*m]   + s * x[2*m+1];
  199.                 itemp     = c * x[2*m+1] - s * x[2*m];
  200.                 x[2*m]    = x[2*ia]   - rtemp;
  201.                 x[2*m+1]  = x[2*ia+1] - itemp;
  202.                 x[2*ia]   = x[2*ia]   + rtemp;
  203.                 x[2*ia+1] = x[2*ia+1] + itemp;
  204.                 ia++;
  205.             }
  206.         ia += n2;
  207.         }
  208.         ie <<= 1;                                               
  209.     }
  210. }
  213. void Stastic(void)
  214. {
  215. int h;
  216.    
  217. float term; //统计直方图的幅度间隔
  218. unsigned maxScript;     //记录统计直方图最大值下标
  219. float MAX; //200帧信号能量最大值
  220. float signal_energy;    //本帧信号能量
  221. float Threshold;        //直方图门限
  222. // float sum = 0.0; //本帧信号幅度值之和
  223. // float mean = 0.0; //平均每个点平均幅度
  225. float const coeffience1 = 4.8;   //3.8
  226. float const coeffience2 = 0.005; //0.007
  227. float const coeffience3 = 0.5;   //0.6
  230.     //做每帧信号的FFT
  231. for (h = 0; h < FRAMELEN; h++) 
  232. {
  233. fft1[h*2] = d1[h];      
  234.         fft1[h*2+1] = 0.0;    
  235. }
  237.         
  238. //做FRAMELEN个点FFT
  239.     gen_w_r2(w1, FRAMELEN);
  240.     bit_rev(w1, FRAMELEN/2);
  241.     DSPF_sp_cfftr2_dit(fft1, w1, FRAMELEN);   
  242.     bit_rev(fft1, FRAMELEN);
  243.           
  244.     
  245.     for (h=0; h < FRAMELEN; h++) 
  246.     {
  247.         yp[h] = fft1[h*2]*fft1[h*2] + fft1[h*2+1]*fft1[h*2+1];    //未处理语音信号的功率谱
  248.         sita[h] = atan2( fft1[h*2+1], fft1[h*2] );   //保留相角  
  249. } 
  251. /////////////////////////////////////////////////////////////////////////////////////////////////
  252. //                    下面的代码作能量值方图的统计,其原理为:
  253. //        短时能量的概率密度最大值点对应着噪声帧能量概率密度最大值点.因此具体实
  254. //    现时maxScript为带噪语音信号的短时能量概率密度达到最大值时对应的点，可以通
  255. //    过连续统计一定长度带噪语音信号的短时能量直方图得到.计算统计直方图的门限由
  256. //    maxScript可以得到判别有声帧和无声帧的门限.
  257. /////////////////////////////////////////////////////////////////////////////////////////////////
  259. signal_energy = 0.0;
  260. for(h = 0; h < FRAMELEN; h++)
  261. {
  262. signal_energy += d1[h]*d1[h];
  263. }
  265.     //计算统计直方图的门限
  266. MAX = 0.0;                                      
  267. for(h = 0; h < 199; h++)               
  268. {
  269. pre_energy[h] = pre_energy[h+1];
  270. }
  271. pre_energy[199] = signal_energy;
  273. for(h = 0; h < 200; h++)
  274. {
  275. if(pre_energy[h] > MAX)
  276. MAX = pre_energy[h];
  277. }
  279. term = MAX / 128;
  281. for(h = 0; h < 129; h++)
  282. {
  283. quota[h] = 0;
  284. }
  286. int flag;
  287. for(h = 0; h < 200; h++)
  288. {
  289. flag = ceil(pre_energy[h]/term);
  290. quota[flag]++;
  291. }
  293. maxScript = 0;
  294. for(h = 1; h < 129; h++)
  295. {
  296. if(quota[h] > quota[maxScript])
  297. maxScript = h;
  298. }
  300. Threshold = 285.0*(maxScript+0.5)*term/254.0;  //门限
  301.     
  302. /////////////////////////////////////////////////////////////////////////////////////////////////
  303. //                    下面的代码作噪声估计和语音增强,其原理为:
  304. //        由本帧信号短时能量与上述门限值比较,判别有声/无声帧.判为有声帧时,
  305. //    不更新噪声;判为噪声值时,更新噪声功率谱.
  306. /////////////////////////////////////////////////////////////////////////////////////////////////
  308.     for (h = 0; h < 129; h++)
  309. {
  310. if( signal_energy < Threshold )
  311. {
  312. dp[h] = 0.84*predp[h]+0.16*yp[h]; 
  313. xp[h] = coeffience3*(0.2*prexp[h]+0.8*((yp[h]-coeffience1*dp[h]>0.0) ? (yp[h]-coeffience1*dp[h]) : coeffience2*yp[h]));//为减小音乐噪声，噪声帧作衰减
  314. }
  315. else
  316. {
  317. dp[h] = predp[h];
  318.          xp[h] = 0.2*prexp[h]+0.8*((yp[h]-coeffience1*dp[h]>0.0) ? (yp[h]-coeffience1*dp[h]) : coeffience2*yp[h]); 
  319. }
  320. predp[h] = dp[h];
  321. prexp[h] = xp[h]; 
  322.         
  323.      //计算信号幅度
  324. amp[h] = sqrt( xp[h] );
  325.             
  326.         //计算了前129点的幅度，后面的127点利用FFT幅度的对称关系计算
  327.         if( h == 0 || h == 128 )
  328.             ;
  329.         else
  330.             amp[256-h] = amp[h];  
  331. }
  333.     //做IFFT   
  334. for (h = 0; h < FRAMELEN; h++) 
  335. {
  336.         fft1[h*2] = amp[h]*cos(sita[h]);         //IFFT变换输出结果的实部赋初值（输入信号的虚部）  
  337.         fft1[h*2+1] = -amp[h]*sin(sita[h]);      //IFFT变换输出结果的虚部赋初值（输入信号的实部）
  338.     }
  339.     DSPF_sp_cfftr2_dit(fft1, w1, FRAMELEN);   
  340.     bit_rev(fft1, FRAMELEN);
  342.     for(h=0; h < FRAMELEN; h++)
  343. { 
  344.         yo[h] = fft1[h*2]/FRAMELEN;
  345.     }
  346. }
  349. void Enhance(void)
  350. {
  351. int t, h;
  352. float const coeffience4 = 4.0; //3.0
  353. void Stastic(void);
  355. p = read_data();
  357. for(t = 0; t < 128; t++)
  358. {
  359. dm[t+128] = (float)p[t]; 
  360. }
  362. for (h = 0; h < FRAMELEN; h++)
  363. {
  364. d1[h] = dm[h]*hamming[h];   //加hamming窗处理
  365. }
  367. Stastic();
  369. for(t = 0; t < 128; t++)
  370. { 
  371.     cm[t] = (int16)( (yo[t]+out1[t])*0.5*coeffience4 ); 
  372. out1[t] = yo[t+128];   
  373. }
  374.   
  375. for(t=0; t < 128; t++)
  376. {
  377. dm[t] = dm[t+128];
  378. }
  380. }
  381. ///////////////////////////////////////////
  383. /**本函数的目的是训练信道******
  384. ***输入:读入10帧数据     ******
  385. ***输出:得到average_noiseenergy值和energy_threshhold值*/
  386. void train(void)
  387. {
  388. int i;
  389. int j;
  390. for(i=0; i<10; i++)
  391. {
  392. noise_energy[i] = 0.0;
  393. }
  394. for(i=0; i<10; i++)
  395. {
  396. p = read_data();
  397. for(j=0; j<128; j++)
  398. {
  399. input_signal[j] = (float)p[j];
  400. noise_energy[i] += input_signal[j]*input_signal[j]; 
  401. qq[j] = input_signal[j];
  402. }
  403. noise_energy[i]/=128;
  404. compress_signal();//训练的时候默认是关断输出
  405. write_data(qq);
  406. }
  407. average_noiseenergy = 0.0;
  408. for(i=0; i<10; i++)
  409. {
  410. average_noiseenergy += noise_energy[i];
  411. }
  412. average_noiseenergy /= 10;
  414. //能量判决门限初始化为起始10帧数据的平均能量值;        
  415. energy_threshhold = average_noiseenergy;
  417. }//训练结束
  419. /*****功能:读取一帧数据，并计算出signal_energy****
  420. ******输入:无                                 ****
  421. ******输出:一帧数据和此数据帧的signal_energy值***/
  422. void read_signal(void)
  423. {
  424. int i;
  425. // p = read_data();
  426. signal_energy = 0.0;
  427. for(i=0; i<128; i++)
  428. {
  429. input_signal[i] = (float)cm[i];
  430. qq[i] = (int16)input_signal[i];
  431. signal_energy += input_signal[i]*input_signal[i];
  432.     
  433. }     
  434. signal_energy /= 128;
  435. }
  437. /****功能:对qq[128]赋值零****
  438. *****输入:无             ****
  439. *****输出:qq[128]        ***/
  440. void compress_signal(void)
  441. {
  442. int i;
  443. for(i=0; i<128; i++)
  444.     {
  445. qq[i] = 0;
  446. }
  447. }
  450. /*****功能:把一帧数据分成32个子帧，计算出子帧      ****
  451. ******的frame_energyvariance与frame_energyreference****
  452. ******输入:一帧数据                                ****
  453. ******输出:frame_energyvariance与frame_energyreference值***/
  454. void subframe_energyvar(void)
  455. {
  456. int i;
  457. int j;
  458. int subframe_number = 32;
  459. float subframe_total;
  460. float subframelength=128/subframe_number;
  461.         
  462. for(i=0; i<subframe_number; i++)
  463. {
  464. subframe_energy[i]=0;
  465. }
  466. for(i=0; i<subframe_number; i++)
  467. {
  468. for(j=0; j<subframelength; j++)
  469. subframe_energy[i] += input_signal[i*4+j]*input_signal[i*4+j];
  470. subframe_energy[i] /= subframelength;
  471. }
  472. subframe_total = 0;
  473. for(i=0; i<subframe_number; i++)
  474. {
  475. subframe_total += subframe_energy[i];
  476. }
  477. frame_energyreference = subframe_total/subframe_number;
  478. frame_energyvariance = 0.0;
  479. for(i=0; i<subframe_number; i++)
  480. {
  481. frame_energyvariance += (subframe_energy[i]-frame_energyreference)*(subframe_energy[i]-frame_energyreference);
  482. }
  483. frame_energyvariance = sqrt(frame_energyvariance);
  484. //frame_energyvariance = (frame_energyvariance);
  486. average_noiseenergy = 0.0;
  487. for(i=0; i<10; i++)
  488. {
  489. average_noiseenergy += noise_energy[i];
  490. }
  491. average_noiseenergy /= 10;
  492. }
  495. /*****功能:更新门限energy_threshhold****
  496. ******使之能自适应信道的变化        ****
  497. ******输入:一帧数据                 ****
  498. ******输出:门限energy_threshhold值  ***/
  499. void noise_update(void)
  500. {
  501. int i;
  502. float old_noiseenergyvar;
  503. float new_noiseenergyvar;
  504. float ratio;
  505. float t;
  507.         
  508. average_noiseenergy = 0.0;
  509. for(i=0; i<10; i++)
  510. {
  511. average_noiseenergy += noise_energy[i];
  512. }
  513. average_noiseenergy /= 10;
  514.         
  515. old_noiseenergyvar = 0.0;
  516. for(i=0; i<10; i++)
  517. old_noiseenergyvar += (noise_energy[i]-average_noiseenergy)*(noise_energy[i]-average_noiseenergy);
  518.         
  519. for(i=0; i<9; i++) //这里i最高只能取8！！！        
  520. {
  521. noise_energy[i+1] = noise_energy[i];
  522. noise_energy[0] =  signal_energy;
  523. }
  524. average_noiseenergy = 0.0;
  525. for(i=0; i<10; i++)
  526. {
  527. average_noiseenergy += noise_energy[i];
  528. }
  529. average_noiseenergy /= 10;
  530. new_noiseenergyvar = 0.0;
  531. for(i=0; i<10; i++)
  532. new_noiseenergyvar += (noise_energy[i]-average_noiseenergy)*(noise_energy[i]-average_noiseenergy);
  533. old_noiseenergyvar = sqrt(old_noiseenergyvar);
  534. new_noiseenergyvar = sqrt(new_noiseenergyvar);
  535. //old_noiseenergyvar = (old_noiseenergyvar);
  536. //new_noiseenergyvar = (new_noiseenergyvar);
  537. //根据当前噪声能量方差与先澳芰糠讲畹谋戎道炊詐赋值,借此自适应的跟踪信道的噪声变化;                    
  538.         
  539. ratio = new_noiseenergyvar/old_noiseenergyvar;
  540. if(ratio>=1.25)
  541. t=0.15;
  542. else if(ratio>=1.10)
  543. t=0.10;
  544. else if(ratio>=1.00)
  545. t=0.08;        
  546. else
  547. t=0.05;
  548. energy_threshhold = energy_threshhold*(1-t)+t*noise_energy[0];
  549.        
  551. }
  555. int main(void)
  556. {
  557. float a; //avv判决语音起始点的倍数
  558. float b;  //avv判决语音结束点的倍数
  559. float c; //第一级能量倍数
  560. float d;   //第二级能量倍数
  561. float f;
  562. int dip1,dip2,dip3,dip4;
  563. int value;  
  564. bool flag;
  566.     void Enhance(void);
  568. CSR &= (~0x00000001);
  569. IER = 0;
  571. data_init();
  572. buf_init();
  573. timer1_init();
  574. spark_led();
  575. sys_init();
  577. for(int t = 0; t < 128; t++)
  578. {
  579. out1[t] = 0.0;
  580.         dm[t] = 0.0;
  581. }
  582.     for(int t = 0; t < 129; t++)
  583. {
  584.         predp[t] = 0.0;
  585. prexp[t] = 0.0;
  586. }
  588. for(int i = 0; i < 200; i++)   //取200帧，用于能量直方图的更新，放音           
  589. {
  590. p = read_data();
  592.         for(int t = 0; t < 128; t++)
  593.         {
  594. dm[t+128] = (float)p[t];   
  595. }
  597. for (int h = 0; h < FRAMELEN; h++)
  598. {
  599. d1[h] = dm[h]*hamming[h];   //加hamming窗处理
  600. }
  602.         //计算信号能量
  603. pre_energy[i] = 0.0;
  604. for(int h = 0; h < FRAMELEN; h++)
  605. {
  606. pre_energy[i] += d1[h]*d1[h];
  607. }
  609. for(int t = 0; t < 128; t++)
  610.         {
  611. cm[t] = (int16)( (d1[t]+out1[t])*0.5 ); 
  612.      out1[t] = d1[t+128]; 
  613.      }
  615. write_data(cm);
  617. for(int t = 0; t < 128; t++)
  618. {
  619. dm[t] = dm[t+128];
  620. }
  621. }
  623. //循环判断每帧数据    
  625. while(1)
  626. {         
  627. //用十帧数据来训练整个算法,并得到相关参数.
  628. train();
  629. flag = false;//初始化flag:语音有无标志
  630. //找语音的起始点
  631.         
  632. while(!flag)
  633. {            
  634. value = REG32(GPIO_GPVAL);
  635. dip1 = value & 0x00000001;
  636. dip2 = value & 0x00000080;
  637. dip3 = value & 0x00000040;
  638. dip4 = value & 0x00000020; 
  640. if((!dip1) && (dip2) && (dip3) && (dip4))
  641. {
  642. a = 25;
  643. b = 1;
  644. c = 5;
  645. d = 3;
  646. f = 1.8;
  647. }
  649. else if((!dip1) && (dip2) && (dip3) && (!dip4))
  650. {
  651. a = 1.0;
  652. b = 1;
  653. c = 5;
  654. d = 4;
  655. f = 1.8;
  656. }
  658. else if((!dip1) && (dip2) && (!dip3) && (dip4))
  659. {
  660. a = 2;
  661. b = 1.5;
  662. c = 6;
  663. d = 4;
  664. f = 1.8;
  665. }
  668. else if((!dip1) && (dip2) && (!dip3) && (!dip4))
  669. {
  670. a = 7;
  671. b = 4;
  672. c = 6;
  673. d = 4;
  674. f=1.8;
  675. }
  676. else 
  677. ;
  678. Enhance();
  679. read_signal();
  680. //能量判决,如果读入帧的能量与门限值比较,如果大于门限,则输出                            
  681. if(signal_energy > c*energy_threshhold)
  682. {                  
  683. subframe_energyvar();
  684.           
  685. if(frame_energyvariance>(a)*(average_noiseenergy))
  686. {            
  687. flag = true;                       
  688. write_data(qq);   
  689. }
  690. else
  691. {
  692. compress_signal();
  693. flag = false;
  694. write_data(qq);
  695. noise_update();
  696. }
  698. }
  699.     //如果是d倍门限以上则需看avv;         
  700. else if(signal_energy > d*energy_threshhold)
  701. {
  702. subframe_energyvar();
  704. //avv判决           
  705. if(frame_energyvariance > (a)*(average_noiseenergy))
  706. {            
  707. flag = true;
  708. write_data(qq);
  709. }           
  710. else
  711. {                            
  712. compress_signal();
  713. flag = false;
  714. write_data(qq);
  715. noise_update();
  716. }
  717. }
  718.     
  719.         
  720. else if(signal_energy > 1.8*energy_threshhold)
  721. {                  
  722. subframe_energyvar();
  724. //avv判决;
  725. if(frame_energyvariance>a*(average_noiseenergy))
  726. {                        
  728. compress_signal();
  729. write_data(qq);
  730. Enhance();
  731. read_signal();
  732. subframe_energyvar();
  734. //avv判决;
  735. if(frame_energyvariance>(a)*(average_noiseenergy))
  736. {
  737. flag = true;
  738. write_data(qq);
  739. }
  740. else
  741. {
  742. compress_signal();
  743. write_data(qq);
  744. flag = false;
  745. noise_update();
  746. }
  747. }                
  748. //当判为静音帧时进行噪声更新;                  
  749. else                  
  750. {                        
  751. compress_signal();                        
  752. write_data(qq);
  753. flag = false;                        
  754. noise_update();                  
  755. }             
  756. }
  758. //小能量帧用avv判决 
  759. /* else
  760. {
  761. subframe_energyvar();
  762. if(frame_energyvariance>(a+0.5)*(average_noiseenergy))//文献中用的是frame_noisereference
  763. {
  764. compress_signal();
  765. write_data(qq);
  766. Enhance();
  767. read_signal();
  768. subframe_energyvar();
  770. //进一步avv判决;
  771. if(frame_energyvariance>(a+0.5)*(average_noiseenergy))
  772. {
  773. flag = true;
  774. write_data(qq);
  775. }
  776. else
  777. {
  778. compress_signal();
  779. write_data(qq);
  780. flag = false;
  781. noise_update();
  782. }
  783. }
  784. else
  785. {
  786. compress_signal();
  787. write_data(qq);
  788. flag = false;
  789. noise_update();
  790. }
  791. }*///if(signal_energy > 8*energy_threshhold)
  792. }//while(!flag)结束
  794.         //找语音的结束点
  795. //如果有连续        
  796. while(flag)
  797. {    
  798.     value = REG32(GPIO_GPVAL);
  799. dip1 = value & 0x00000001;
  800. dip2 = value & 0x00000080;
  801. dip3 = value & 0x00000040;
  802. dip4 = value & 0x00000020;
  804. if((!dip1) && (dip2) && (dip3) && (dip4))
  805. {
  806. a = 10;
  807. b = 1;
  808. c = 500;
  809. d = 300;
  810. f = 1.8;
  811. }
  813. else if((!dip1) && (dip2) && (dip3) && (!dip4))
  814. {
  815. a = 1.0;
  816. b = 1;
  817. c = 5;
  818. d = 4;
  819. f = 1.8;
  820. }
  822. else if((!dip1) && (dip2) && (!dip3) && (dip4))
  823. {
  824. a = 1.5;
  825. b = 1.5;
  826. c = 6;
  827. d = 4;
  828. f = 1.8;
  829. }
  832. else if((!dip1) && (dip2) && (!dip3) && (!dip4))
  833. {
  834. a = 3;
  835. b = 3;
  836. c = 6;
  837. d = 4;
  838. f = 2.0;
  839. }
  840. else 
  841. ;
  842. //这种判断方法是在50帧中如果有15帧的能量小于1.5倍门限则进一步用avv判决  
  843. int s = 100;
  844. int totalenergynum = 0;
  845. int totalavvnum = 0;
  846. int totalnum = 0;
  847. // read_signal();
  848. Enhance();
  849. read_signal();
  850. //能量判决,如果读入k帧的能量与门限值比较,如果大于门限,则输出,否则进一步用AVV判决;               
  851. while(s!=0)
  852. {
  853. if(signal_energy < f*energy_threshhold)
  854. {
  855. totalenergynum++;
  856. noise_update();
  857. }
  858. else if(signal_energy < 1.8*energy_threshhold)
  859. {
  860. totalnum++;
  861. }
  862. else
  863. ;
  865. subframe_energyvar();
  867. //根据子帧能量方差与子帧的平均能量比较来做判决;
  868. if(frame_energyvariance<(b)*(average_noiseenergy))
  869. {
  870. totalavvnum++;
  871. }
  872.                    
  873. write_data(qq);
  874. Enhance();
  875. read_signal();
  876. s--;
  877. }
  879. //if(totalnum>60 && totalavvnum<60)
  880. //{
  881. // flag = true;  
  882. // write_data(qq);
  883. //}
  884. //else
  885. {
  886. if(totalenergynum>80)
  887. {
  888. totalenergynum=0;
  889. //语音结束点，并更新噪声
  890. flag = false;
  891. compress_signal();
  892. write_data(qq);
  893. noise_update();//当判为静音帧时进行噪声更新          
  894. }//if(totalenergynum>70 && totalavvnum>50)结束
  895. else
  896. {
  897. flag = true;
  898. write_data(qq);
  899. }
  901. }//while(s!=0)结束
  903. }//while(flag)结束
  905.     }//while(1)结束
  907. }//主函数结束