小男孩‘自慰网亚洲一区二区,亚洲一级在线播放毛片,亚洲中文字幕av每天更新,黄aⅴ永久免费无码,91成人午夜在线精品,色网站免费在线观看,亚洲欧洲wwwww在线观看

搜索
分享

[數(shù)字信號處理]IIR濾波器的間接設(shè)計(jì)（C代碼）

 oskycar 2016-09-08








1.模擬濾波器的設(shè)計(jì)

      1.1巴特沃斯濾波器的次數(shù)

        根據(jù)給定的參數(shù)設(shè)計(jì)模擬濾波器，然后進(jìn)行變數(shù)變換，求取數(shù)字濾波器的方法，稱為濾波器的間接設(shè)計(jì)。做為數(shù)字濾波器的設(shè)計(jì)基礎(chǔ)的模擬濾波器，稱之為原型濾波器。這里，我們首先介紹的是最簡單最基礎(chǔ)的原型濾波器，巴特沃斯低通濾波器。由于IIR濾波器不具有線性相位特性，因此不必考慮相位特性，直接考慮其振幅特性。

       在這里，N是濾波器的次數(shù)，Ωc是截止頻率。從上式的振幅特性可以看出，這個(gè)是單調(diào)遞減的函數(shù)，其振幅特性是不存在紋波的。設(shè)計(jì)的時(shí)候，一般需要先計(jì)算跟所需要設(shè)計(jì)參數(shù)相符合的次數(shù)N。首先，就需要先由阻帶頻率，計(jì)算出阻帶衰減
將巴特沃斯低通濾波器的振幅特性，直接帶入上式，則有

最后，可以解得次數(shù)N為

當(dāng)然，這里的N只能為正數(shù)，因此，若結(jié)果為小數(shù)，則舍棄小數(shù)，向上取整。

      1.2巴特沃斯濾波器的傳遞函數(shù)

         巴特沃斯低通濾波器的傳遞函數(shù)，可由其振幅特性的分母多項(xiàng)式求得。其分母多項(xiàng)式

根據(jù)S解開，可以得到極點(diǎn)。這里，為了方便處理，我們分為兩種情況去解這個(gè)方程。當(dāng)N為偶數(shù)的時(shí)候，

這里，使用了歐拉公式。同樣的，當(dāng)N為奇數(shù)的時(shí)候，


同樣的，這里也使用了歐拉公式。歸納以上，極點(diǎn)的解為


上式所求得的極點(diǎn)，是在s平面內(nèi)，在半徑為Ωc的圓上等間距的點(diǎn)，其數(shù)量為2N個(gè)。為了使得其IIR濾波器穩(wěn)定，那么，只能選取極點(diǎn)在S平面左半平面的點(diǎn)。選定了穩(wěn)定的極點(diǎn)之后，其模擬濾波器的傳遞函數(shù)就可由下式求得。


       1.3巴特沃斯濾波器的實(shí)現(xiàn)（C語言）

          首先，是次數(shù)的計(jì)算。次數(shù)的計(jì)算，我們可以由下式求得。
         
其對應(yīng)的C語言程序?yàn)?

  1. N = Ceil(0.5*( log10 ( pow (10, Stopband_attenuation/10) - 1) /   
  2.             log10 (Stopband/Cotoff) ));  

         然后是極點(diǎn)的選擇，這里由于涉及到復(fù)數(shù)的操作，我們就聲明一個(gè)復(fù)數(shù)結(jié)構(gòu)體就可以了。最重要的是，極點(diǎn)的計(jì)算含有自然指數(shù)函數(shù)，這點(diǎn)對于計(jì)算機(jī)來講，不是太方便，所以，我們將其替換為三角函數(shù)，


這樣的話，實(shí)部與虛部就還可以分開來計(jì)算。其代碼實(shí)現(xiàn)為

  1. typedef struct   
  2. {  
  3.     double Real_part;  
  4.     double Imag_Part;  
  5. } COMPLEX;  
  6.   
  7.   
  8. COMPLEX poles[N];  
  9.   
  10. for(k = 0;k <= ((2*N)-1) ; k++)  
  11. {  
  12.     if(Cotoff*cos((k+dk)*(pi/N)) < 0)  
  13.     {  
  14.         poles[count].Real_part = -Cotoff*cos((k+dk)*(pi/N));  
  15.     　　poles[count].Imag_Part= -Cotoff*sin((k+dk)*(pi/N));        
  16.         count++;  
  17.         if (count == N) break;  
  18.     }  
  19. }   

       計(jì)算出穩(wěn)定的極點(diǎn)之后，就可以進(jìn)行傳遞函數(shù)的計(jì)算了。傳遞的函數(shù)的計(jì)算，就像下式一樣


這里，為了得到模擬濾波器的系數(shù)，需要將分母乘開。很顯然，這里的極點(diǎn)不一定是整數(shù)，或者來說，這里的乘開需要做復(fù)數(shù)運(yùn)算。其復(fù)數(shù)的乘法代碼如下，

  1. int Complex_Multiple(COMPLEX a,COMPLEX b,  
  2.                  double *Res_Real,double *Res_Imag)  
  3.       
  4. {  
  5.        *(Res_Real) =  (a.Real_part)*(b.Real_part) - (a.Imag_Part)*(b.Imag_Part);  
  6.        *(Res_Imag)=  (a.Imag_Part)*(b.Real_part) + (a.Real_part)*(b.Imag_Part);      
  7.      return (int)1;   
  8. }  
有了乘法代碼之后，我們現(xiàn)在簡單的情況下，看看其如何計(jì)算其濾波器系數(shù)。我們做如下假設(shè)

這個(gè)時(shí)候，其傳遞函數(shù)為

將其乘開，其大致的關(guān)系就像下圖所示一樣。


計(jì)算的關(guān)系一目了然，這樣的話，實(shí)現(xiàn)就簡單多了。高階的情況下也一樣，重復(fù)這種計(jì)算就可以了。其代碼為

  1.  Res[0].Real_part = poles[0].Real_part;   
  2.  Res[0].Imag_Part= poles[0].Imag_Part;  
  3.  Res[1].Real_part = 1;   
  4.  Res[1].Imag_Part= 0;  
  5.   
  6. for(count_1 = 0;count_1 < N-1;count_1++)  
  7. {  
  8.   for(count = 0;count <= count_1 + 2;count++)  
  9.   {  
  10.       if(0 == count)  
  11.  　{  
  12.               Complex_Multiple(Res[count], poles[count_1+1],  
  13.                    &(Res_Save[count].Real_part),  
  14.                    &(Res_Save[count].Imag_Part));  
  15.       }  
  16.       else if((count_1 + 2) == count)  
  17.       {  
  18.             Res_Save[count].Real_part  += Res[count - 1].Real_part;  
  19.    　Res_Save[count].Imag_Part += Res[count - 1].Imag_Part;  
  20.       }         
  21.   　else   
  22.   　{  
  23.               Complex_Multiple(Res[count], poles[count_1+1],  
  24.                    &(Res_Save[count].Real_part),  
  25.                    &(Res_Save[count].Imag_Part));                 
  26. 1   　　Res_Save[count].Real_part  += Res[count - 1].Real_part;  
  27.   　　 Res_Save[count].Imag_Part += Res[count - 1].Imag_Part;  
  28.  　}  
  29.   }  
  30.  　　*(b+N) = *(a+N);  
到此，我們就可以得到一個(gè)模擬濾波器巴特沃斯低通濾波器了。

2.雙1次z變換

      2.1雙1次z變換的原理

        我們?yōu)榱藢⒛M濾波器轉(zhuǎn)換為數(shù)字濾波器的，可以用的方法很多。這里著重說說雙1次z變換。我們希望通過雙1次z變換，建立一個(gè)s平面到z平面的映射關(guān)系，將模擬濾波器轉(zhuǎn)換為數(shù)字濾波器。
        和之前的例子一樣，我們假設(shè)有如下模擬濾波器的傳遞函數(shù)。

將其做拉普拉斯逆變換，可得到其時(shí)間域內(nèi)的連續(xù)微分方程式，

其中，x(t)表示輸入，y(t)表示輸出。然后我們需要將其離散化，假設(shè)其采樣周期是T，用差分方程去近似的替代微分方程，可以得到下面結(jié)果

然后使用z變換，再將其化簡?？傻玫饺缦陆Y(jié)果

從而，我們可以得到了s平面到z平面的映射關(guān)系，即

由于所有的高階系統(tǒng)都可以視為一階系統(tǒng)的并聯(lián)，所以，這個(gè)映射關(guān)系在高階系統(tǒng)中，也是成立的。

然后，將關(guān)系式

帶入上式，可得

到這里，我們可以就可以得到Ω與ω的對應(yīng)關(guān)系了。


         這里的Ω與ω的對應(yīng)關(guān)系很重要。我們最終的目的設(shè)計(jì)的是數(shù)字濾波器，所以，設(shè)計(jì)時(shí)候給的參數(shù)必定是數(shù)字濾波器的指標(biāo)。而我們通過間接設(shè)計(jì)設(shè)計(jì)IIR濾波器時(shí)候，首先是要設(shè)計(jì)模擬濾波器，再通過變換，得到數(shù)字濾波器。那么，我們首先需要做的，就是將數(shù)字濾波器的指標(biāo)，轉(zhuǎn)換為模擬濾波器的指標(biāo)，基于這個(gè)指標(biāo)去設(shè)計(jì)模擬濾波器。另外，這里的采樣時(shí)間T的取值很隨意，為了方便計(jì)算，一般取1s就可以。

       2.2雙1次z變換的實(shí)現(xiàn)（C語言）

         我們設(shè)計(jì)好的巴特沃斯低通濾波器的傳遞函數(shù)如下所示。
     
我們將其進(jìn)行雙1次z變換，我們可以得到如下式子

可以看出，我們還是需要將式子乘開，進(jìn)行合并同類項(xiàng)，這個(gè)跟之前說的算法相差不大。其代碼為。

  1. for(Count = 0;Count<=N;Count++)  
  2.     {         
  3.           　for(Count_Z = 0;Count_Z <= N;Count_Z++)  
  4.             {  
  5.                  Res[Count_Z] = 0;  
  6.              Res_Save[Count_Z] = 0;    
  7.             }  
  8.                 Res_Save [0] = 1;  
  9.          　 for(Count_1 = 0; Count_1 < N-Count;Count_1++)  
  10.             {  
  11.             　　for(Count_2 = 0; Count_2 <= Count_1+1;Count_2++)  
  12.                 {  
  13.                     if(Count_2 == 0)  Res[Count_2] += Res_Save[Count_2];      
  14. 　　　　　　　　　        　else if((Count_2 == (Count_1+1))&&(Count_1 != 0))    
  15.                        　    Res[Count_2] += -Res_Save[Count_2 - 1];   
  16. 　　　　　　　　　　        else  Res[Count_2] += Res_Save[Count_2] - Res_Save[Count_2 - 1];  
  17. 　　           　for(Count_Z = 0;Count_Z<= N;Count_Z++)  
  18.               　　　{  
  19.                     　 Res_Save[Count_Z]  =  Res[Count_Z] ;  
  20.                    　　Res[Count_Z]  = 0;  
  21.               　　　}            
  22.             }  
  23.         for(Count_1 = (N-Count); Count_1 < N;Count_1++)  
  24.             {  
  25.                         for(Count_2 = 0; Count_2 <= Count_1+1;Count_2++)  
  26.                 {  
  27.                      if(Count_2 == 0) 　Res[Count_2] += Res_Save[Count_2];     
  28.                  else if((Count_2 == (Count_1+1))&&(Count_1 != 0))    
  29.                       　　　　　　　 Res[Count_2] += Res_Save[Count_2 - 1];  
  30.                  else    
  31.                        Res[Count_2] += Res_Save[Count_2] + Res_Save[Count_2 - 1];     
  32.             　}  
  33.                   for(Count_Z = 0;Count_Z<= N;Count_Z++)  
  34.                   {  
  35.                        Res_Save[Count_Z]  =  Res[Count_Z] ;  
  36.                    Res[Count_Z]  = 0;  
  37.                   }  
  38.             }  
  39.             for(Count_Z = 0;Count_Z<= N;Count_Z++)  
  40.         {  
  41.                     *(az+Count_Z) += 　pow(2,N-Count) * (*(as+Count)) *  
  42. 　　　　　　　　　　　      　　　　 　Res_Save[Count_Z];  
  43.                 *(bz+Count_Z) +=  (*(bs+Count)) * Res_Save[Count_Z];               
  44.          }    
  45.     }  
到此，我們就已經(jīng)實(shí)現(xiàn)了一個(gè)數(shù)字濾波器。


3.IIR濾波器的間接設(shè)計(jì)代碼（C語言）

  1. #include <stdio.h>  
  2. #include <math.h>  
  3. #include <malloc.h>  
  4. #include <string.h>  
  5.   
  6.   
  7. #define     pi     ((double)3.1415926)  
  8.   
  9.   
  10. struct DESIGN_SPECIFICATION  
  11. {  
  12.     double Cotoff;     
  13.     double Stopband;  
  14.     double Stopband_attenuation;  
  15. };  
  16.   
  17. typedef struct   
  18. {  
  19.     double Real_part;  
  20.     double Imag_Part;  
  21. } COMPLEX;  
  22.   
  23.   
  24.   
  25. int Ceil(double input)  
  26. {  
  27.      if(input != (int)input) return ((int)input) +1;  
  28.      else return ((int)input);   
  29. }  
  30.   
  31.   
  32. int Complex_Multiple(COMPLEX a,COMPLEX b  
  33.                                      ,double *Res_Real,double *Res_Imag)  
  34.       
  35. {  
  36.        *(Res_Real) =  (a.Real_part)*(b.Real_part) - (a.Imag_Part)*(b.Imag_Part);  
  37.        *(Res_Imag)=  (a.Imag_Part)*(b.Real_part) + (a.Real_part)*(b.Imag_Part);      
  38.      return (int)1;   
  39. }  
  40.   
  41.   
  42. int Buttord(double Cotoff,  
  43.                  double Stopband,  
  44.                  double Stopband_attenuation)  
  45. {  
  46.    int N;  
  47.   
  48.    printf("Wc =  %lf  [rad/sec] \n" ,Cotoff);  
  49.    printf("Ws =  %lf  [rad/sec] \n" ,Stopband);  
  50.    printf("As  =  %lf  [dB] \n" ,Stopband_attenuation);  
  51.    printf("--------------------------------------------------------\n" );  
  52.        
  53.    N = Ceil(0.5*( log10 ( pow (10, Stopband_attenuation/10) - 1) /   
  54.                     log10 (Stopband/Cotoff) ));  
  55.      
  56.      
  57.    return (int)N;  
  58. }  
  59.   
  60.   
  61. int Butter(int N, double Cotoff,  
  62.                double *a,  
  63.                double *b)  
  64. {  
  65.     double dk = 0;  
  66.     int k = 0;  
  67.     int count = 0,count_1 = 0;  
  68.     COMPLEX poles[N];  
  69.     COMPLEX Res[N+1],Res_Save[N+1];  
  70.   
  71.     if((N%2) == 0) dk = 0.5;  
  72.     else dk = 0;  
  73.   
  74.     for(k = 0;k <= ((2*N)-1) ; k++)  
  75.     {  
  76.          if(Cotoff*cos((k+dk)*(pi/N)) < 0)  
  77.          {  
  78.                poles[count].Real_part = -Cotoff*cos((k+dk)*(pi/N));  
  79.           poles[count].Imag_Part= -Cotoff*sin((k+dk)*(pi/N));        
  80.               count++;  
  81.             if (count == N) break;  
  82.          }  
  83.     }   
  84.   
  85.      printf("Pk =   \n" );     
  86.      for(count = 0;count < N ;count++)  
  87.      {  
  88.            printf("(%lf) + (%lf i) \n" ,-poles[count].Real_part  
  89.                                       ,-poles[count].Imag_Part);  
  90.      }  
  91.      printf("--------------------------------------------------------\n" );  
  92.        
  93.      Res[0].Real_part = poles[0].Real_part;   
  94.      Res[0].Imag_Part= poles[0].Imag_Part;  
  95.   
  96.      Res[1].Real_part = 1;   
  97.      Res[1].Imag_Part= 0;  
  98.   
  99.     for(count_1 = 0;count_1 < N-1;count_1++)  
  100.     {  
  101.          for(count = 0;count <= count_1 + 2;count++)  
  102.          {  
  103.               if(0 == count)  
  104.            {  
  105.                     Complex_Multiple(Res[count], poles[count_1+1],  
  106.                                    &(Res_Save[count].Real_part),  
  107.                                    &(Res_Save[count].Imag_Part));  
  108.                //printf( "Res_Save : (%lf) + (%lf i) \n" ,Res_Save[0].Real_part,Res_Save[0].Imag_Part);  
  109.               }  
  110.   
  111.               else if((count_1 + 2) == count)  
  112.               {  
  113.                      Res_Save[count].Real_part  += Res[count - 1].Real_part;  
  114.                 Res_Save[count].Imag_Part += Res[count - 1].Imag_Part;    
  115.               }         
  116.             else   
  117.             {  
  118.                      Complex_Multiple(Res[count], poles[count_1+1],  
  119.                                    &(Res_Save[count].Real_part),  
  120.                                    &(Res_Save[count].Imag_Part));  
  121.   
  122.                        //printf( "Res          : (%lf) + (%lf i) \n" ,Res[count - 1].Real_part,Res[count - 1].Imag_Part);  
  123.                 //printf( "Res_Save : (%lf) + (%lf i) \n" ,Res_Save[count].Real_part,Res_Save[count].Imag_Part);  
  124.                   
  125.                 Res_Save[count].Real_part  += Res[count - 1].Real_part;  
  126.                 Res_Save[count].Imag_Part += Res[count - 1].Imag_Part;  
  127.               
  128.                 //printf( "Res_Save : (%lf) + (%lf i) \n" ,Res_Save[count].Real_part,Res_Save[count].Imag_Part);  
  129.                   
  130.             }  
  131.             //printf("There \n" );  
  132.          }  
  133.   
  134.          for(count = 0;count <= N;count++)  
  135.          {  
  136.                Res[count].Real_part = Res_Save[count].Real_part;   
  137.                  Res[count].Imag_Part= Res_Save[count].Imag_Part;  
  138.                    
  139.             *(a + N - count) = Res[count].Real_part;  
  140.          }  
  141.            
  142.          //printf("There!! \n" );  
  143.            
  144.         }  
  145.   
  146.      *(b+N) = *(a+N);  
  147.   
  148.      //------------------------display---------------------------------//  
  149.      printf("bs =  [" );     
  150.      for(count = 0;count <= N ;count++)  
  151.      {  
  152.            printf("%lf ", *(b+count));  
  153.      }  
  154.      printf(" ] \n" );  
  155.   
  156.      printf("as =  [" );     
  157.      for(count = 0;count <= N ;count++)  
  158.      {  
  159.            printf("%lf ", *(a+count));  
  160.      }  
  161.      printf(" ] \n" );  
  162.   
  163.      printf("--------------------------------------------------------\n" );  
  164.   
  165.      return (int) 1;  
  166. }  
  167.   
  168.   
  169. int Bilinear(int N,   
  170.                  double *as,double *bs,  
  171.                  double *az,double *bz)  
  172. {  
  173.       int Count = 0,Count_1 = 0,Count_2 = 0,Count_Z = 0;  
  174.       double Res[N+1];  
  175.     double Res_Save[N+1];   
  176.   
  177.         for(Count_Z = 0;Count_Z <= N;Count_Z++)  
  178.     {  
  179.                  *(az+Count_Z)  = 0;  
  180.             *(bz+Count_Z)  = 0;  
  181.     }  
  182.   
  183.       
  184.     for(Count = 0;Count<=N;Count++)  
  185.     {         
  186.           for(Count_Z = 0;Count_Z <= N;Count_Z++)  
  187.             {  
  188.                  Res[Count_Z] = 0;  
  189.              Res_Save[Count_Z] = 0;    
  190.             }  
  191.              Res_Save [0] = 1;  
  192.       
  193.           for(Count_1 = 0; Count_1 < N-Count;Count_1++)  
  194.             {  
  195.             for(Count_2 = 0; Count_2 <= Count_1+1;Count_2++)  
  196.                 {  
  197.                      if(Count_2 == 0)    
  198.                  {  
  199.                        Res[Count_2] += Res_Save[Count_2];  
  200.                      //printf( "Res[%d] %lf  \n" , Count_2 ,Res[Count_2]);  
  201.                  }    
  202.   
  203.                  else if((Count_2 == (Count_1+1))&&(Count_1 != 0))    
  204.                  {  
  205.                        Res[Count_2] += -Res_Save[Count_2 - 1];     
  206.                               //printf( "Res[%d] %lf  \n" , Count_2 ,Res[Count_2]);  
  207.                  }   
  208.   
  209.                  else    
  210.                  {  
  211.                        Res[Count_2] += Res_Save[Count_2] - Res_Save[Count_2 - 1];  
  212.                     //printf( "Res[%d] %lf  \n" , Count_2 ,Res[Count_2]);  
  213.                  }                 
  214.             }  
  215.   
  216.                     //printf( "Res : ");  
  217.               for(Count_Z = 0;Count_Z<= N;Count_Z++)  
  218.               {  
  219.                      Res_Save[Count_Z]  =  Res[Count_Z] ;  
  220.                    Res[Count_Z]  = 0;  
  221.                 //printf( "[%d]  %lf  " ,Count_Z, Res_Save[Count_Z]);       
  222.               }  
  223.               //printf(" \n" );  
  224.               
  225.             }  
  226.   
  227.         for(Count_1 = (N-Count); Count_1 < N;Count_1++)  
  228.             {  
  229.                     for(Count_2 = 0; Count_2 <= Count_1+1;Count_2++)  
  230.                 {  
  231.                      if(Count_2 == 0)    
  232.                  {  
  233.                        Res[Count_2] += Res_Save[Count_2];  
  234.                      //printf( "Res[%d] %lf  \n" , Count_2 ,Res[Count_2]);  
  235.                  }    
  236.   
  237.                  else if((Count_2 == (Count_1+1))&&(Count_1 != 0))    
  238.                  {  
  239.                        Res[Count_2] += Res_Save[Count_2 - 1];  
  240.                               //printf( "Res[%d] %lf  \n" , Count_2 ,Res[Count_2]);  
  241.                   }   
  242.   
  243.                  else    
  244.                  {  
  245.                        Res[Count_2] += Res_Save[Count_2] + Res_Save[Count_2 - 1];  
  246.                      //printf( "Res[%d] %lf  \n" , Count_2 ,Res[Count_2]);  
  247.                  }                 
  248.             }  
  249.   
  250.                    //   printf( "Res : ");  
  251.               for(Count_Z = 0;Count_Z<= N;Count_Z++)  
  252.               {  
  253.                      Res_Save[Count_Z]  =  Res[Count_Z] ;  
  254.                    Res[Count_Z]  = 0;  
  255.                 //printf( "[%d]  %lf  " ,Count_Z, Res_Save[Count_Z]);       
  256.               }  
  257.                //printf(" \n" );  
  258.             }  
  259.   
  260.   
  261.              //printf( "Res : ");  
  262.         for(Count_Z = 0;Count_Z<= N;Count_Z++)  
  263.         {  
  264.                     *(az+Count_Z) +=  pow(2,N-Count)  *  (*(as+Count)) * Res_Save[Count_Z];  
  265.              *(bz+Count_Z) +=  (*(bs+Count)) * Res_Save[Count_Z];         
  266.                      //printf( "  %lf  " ,*(bz+Count_Z));           
  267.          }    
  268.          //printf(" \n" );  
  269.   
  270.     }  
  271.   
  272.   
  273.         
  274.      for(Count_Z = N;Count_Z >= 0;Count_Z--)  
  275.      {  
  276.           *(bz+Count_Z) =  (*(bz+Count_Z))/(*(az+0));  
  277.           *(az+Count_Z) =  (*(az+Count_Z))/(*(az+0));  
  278.      }  
  279.        
  280.   
  281.     //------------------------display---------------------------------//  
  282.       printf("bz =  [" );     
  283.       for(Count_Z= 0;Count_Z <= N ;Count_Z++)  
  284.       {  
  285.            printf("%lf ", *(bz+Count_Z));  
  286.       }  
  287.       printf(" ] \n" );  
  288.       printf("az =  [" );     
  289.       for(Count_Z= 0;Count_Z <= N ;Count_Z++)  
  290.       {  
  291.            printf("%lf ", *(az+Count_Z));  
  292.       }  
  293.       printf(" ] \n" );  
  294.       printf("--------------------------------------------------------\n" );  
  295.   
  296.       
  297.   
  298.      return (int) 1;  
  299. }  
  300.   
  301.   
  302.   
  303.   
  304.   
  305. int main(void)  
  306. {  
  307.      int count;  
  308.   
  309.      struct DESIGN_SPECIFICATION IIR_Filter;  
  310.   
  311.      IIR_Filter.Cotoff      = (double)(pi/2);         //[red]  
  312.      IIR_Filter.Stopband = (double)((pi*3)/4);   //[red]  
  313.      IIR_Filter.Stopband_attenuation = 30;        //[dB]  
  314.     
  315.      int N;  
  316.   
  317.      IIR_Filter.Cotoff = 2 * tan((IIR_Filter.Cotoff)/2);            //[red/sec]  
  318.      IIR_Filter.Stopband = 2 * tan((IIR_Filter.Stopband)/2);   //[red/sec]  
  319.   
  320.      N = Buttord(IIR_Filter.Cotoff,  
  321.                   IIR_Filter.Stopband,  
  322.                   IIR_Filter.Stopband_attenuation);  
  323.      printf("N:  %d  \n" ,N);  
  324.      printf("--------------------------------------------------------\n" );  
  325.   
  326.      double as[N+1] , bs[N+1];  
  327.      Butter(N,   
  328.                 IIR_Filter.Cotoff,  
  329.              as,  
  330.              bs);   
  331.   
  332.      double az[N+1] , bz[N+1];  
  333.        
  334.      Bilinear(N,   
  335.                as,bs,  
  336.                az,bz);  
  337.   
  338.      printf("Finish \n" );  
  339.      return (int)0;  
  340. }  


3.間接設(shè)計(jì)實(shí)現(xiàn)的IIR濾波器的性能

       3.1設(shè)計(jì)指標(biāo)

             

        3.2程序執(zhí)行結(jié)果

           使用上述程序，gcc編譯通過，執(zhí)行結(jié)果如下。
       其頻率響應(yīng)如下所示。博客地址：http://blog.csdn.net/thnh169/



頂
7

    本站是提供個(gè)人知識管理的網(wǎng)絡(luò)存儲空間，所有內(nèi)容均由用戶發(fā)布，不代表本站觀點(diǎn)。請注意甄別內(nèi)容中的聯(lián)系方式、誘導(dǎo)購買等信息，謹(jǐn)防詐騙。如發(fā)現(xiàn)有害或侵權(quán)內(nèi)容，請點(diǎn)擊一鍵舉報(bào)。
    轉(zhuǎn)藏 分享 獻(xiàn)花（0）

    0條評論

    發(fā)表

    請遵守用戶 評論公約

    類似文章 更多