⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 main.lst

📁 快速傅立叶变化的fft算法的C语言实现。
💻 LST
字号:
C51 COMPILER V7.50   MAIN                                                                  01/11/2006 17:49:09 PAGE 1   


C51 COMPILER V7.50, COMPILATION OF MODULE MAIN
OBJECT MODULE PLACED IN main.OBJ
COMPILER INVOKED BY: C:\Program Files\Keil\C51\BIN\C51.EXE main.c LARGE BROWSE DEBUG OBJECTEXTEND

line level    source

   1          #include "include.h"
   2          #include <math.h>
   3          
   4          #if FFT_SAMPLE
   5          
   6          int hd_u[3][(FFT_N/2)-2];                       /* 三相电压2-15次谐波畸变率*/
   7          int hd_i[3][(FFT_N/2)-2];                       /* 三相电流2-15次谐波畸变率*/
   8          int thd_u[3];                /* 三相电压谐波总畸变率 */
   9          int thd_i[3];                /* 三相电流谐波总畸变率 */
  10          int thd_u_even[3];           /* 三相电压偶次谐波畸变率 */
  11          int thd_u_odd[3];            /* 三相电压奇次谐波畸变率 */
  12          int thd_i_even[3];           /* 三相电流偶次谐波畸变率 */
  13          int thd_i_odd[3];            /* 三相电流奇次谐波畸变率 */
  14          int k_i[3];                     /* 电流K因子 */
  15          int k_u[3];                      /* 电压K因子 */
  16          
  17          
  18          /* 2005.9.16为了解决局部变量太多导致堆栈溢出的问题,
  19          把fft模块定义的局部变量定义为全局变量 */
  20          double ur[FFT_N/2], ui[FFT_N/2], ir[FFT_N/2], ii[FFT_N/2];  /*电压电流的实部和虚部*/
  21          complex k[FFT_N];               /*fft算法模块输入输出值*/
  22          double u_even_sum, u_odd_sum, u_total_sum, i_even_sum, i_odd_sum, i_total_sum;/*电压电流畸变率计算中间值*/
  23          double k_sum_u, sum_u, k_sum_i, sum_i;  /*K因子计算中间值*/
  24          #endif
  25          
  26          const int demo_u_sample[64] = 
  27          {
  28                          0,527,609,823,945,1126,1249,1402,
  29                          1511,1635,1720,1817,1878,1938,1964,1995,
  30                  1990,1981,1944,1902,1826,1755,1650,1545,
  31                  1413,1284,1131,980,805,647,453,301,
  32                  0,-301,-453,-647,-805,-980,-1131,-1284,
  33                  -1413,-1545,-1650,-1755,-1826,-1902,-1944,-1981,
  34                  -1990,-1995,-1964,-1938,-1878,-1817,-1720,-1635,
  35                  -1511,-1402,-1249,-1126,-945,-823,-609,-527             
  36          };
  37          
  38          const int demo_i_sample[64] = 
  39          {
  40                          0,851,821,1053,1114,1289,1362,1506,
  41                          1572,1691,1744,1832,1862,1920,1924,1951,
  42                          1928,1925,1874,1842,1766,1700,1600,1507,
  43                          1380,1274,1122,1001,830,699,507,401,
  44                          0,-401,-507,-699,-830,-1001,-1122,-1274,
  45                          -1380,-1507,-1600,-1700,-1766,-1842,-1874,-1925,
  46                          -1928,-1951,-1924,-1920,-1862,-1832,-1744,-1691,
  47                          -1572,-1506,-1362,-1289,-1114,-1053,-821,-851   
  48          };
  49          
  50          void fft_calc();
  51          
  52          void main()
  53          {
  54   1              
  55   1      
C51 COMPILER V7.50   MAIN                                                                  01/11/2006 17:49:09 PAGE 2   

  56   1              while(1)
  57   1              {
  58   2                      fft_calc();     
  59   2              }
  60   1      
  61   1      } 
  62          
  63          void fft_calc()
  64          {
  65   1              unsigned char i,j,l;
  66   1      
  67   1              for( i = 0; i < 3;i ++ )
  68   1              {
  69   2                      l = 64 / FFT_N;
  70   2                      for (j=0;j<FFT_N;j++)   /* 输入的电流电压实序列,组成一个复序列*/
  71   2                      {
  72   3                              k[j].r = demo_u_sample[j*l];
  73   3                              k[j].i = demo_i_sample[j*l];
  74   3                      }
  75   2      
  76   2                      fft( FFT_N,&k );
  77   2      
  78   2      
  79   2                      /* 根据傅立叶计算公式,计算结果除以N/2*/
  80   2                      for (j=1;j<(FFT_N/2);j++)    
  81   2                      {
  82   3                              ur[j] = (k[j].r+k[FFT_N-j].r)/FFT_N;
  83   3                              ui[j] = (k[j].i-k[FFT_N-j].i)/FFT_N;
  84   3                              ir[j] = (k[j].i+k[FFT_N-j].i)/FFT_N;
  85   3                              ii[j] = (k[FFT_N-j].r-k[j].r)/FFT_N;
  86   3      
  87   3                      }
  88   2                      
  89   2      
  90   2                      /*   只需要对(N/2-1)次以下的谐波进行分析    */ 
  91   2                      /*   幅值X(k)=sqrt(ak^2+bk^2)          */
  92   2                      for( j = 1; j <(FFT_N/2); j ++ )
  93   2                      {
  94   3                              k[j].r=fSqrt(ur[j]*ur[j]+ui[j]*ui[j]);
  95   3                              k[j].i=fSqrt(ir[j]*ir[j]+ii[j]*ii[j]);
  96   3      
  97   3                              /*  计算谐波有效值时幅值除以根号2 */
  98   3                              k[j].r = k[j].r * 0.7071068;
  99   3                              k[j].i = k[j].i * 0.7071068;
 100   3                      }
 101   2      
 102   2      
 103   2                      /* ********计算谐波畸变率和K因子*************/
 104   2                      u_even_sum = u_odd_sum = u_total_sum = 0;
 105   2                      i_even_sum  = i_odd_sum  = i_total_sum = 0;
 106   2                      for ( j = 2; j < (FFT_N/2); j ++ )
 107   2                      {
 108   3                              u_total_sum += k[j].r * k[j].r;
 109   3                              i_total_sum += k[j].i * k[j].i ;
 110   3      
 111   3                              if( (j-1) % 2 == 0)
 112   3                              {
 113   4                                      u_odd_sum += k[j].r * k[j].r ;
 114   4                                      i_odd_sum += k[j].i * k[j].i ;
 115   4                              }
 116   3      
 117   3                              if( j % 2 == 0)
C51 COMPILER V7.50   MAIN                                                                  01/11/2006 17:49:09 PAGE 3   

 118   3                              {
 119   4                                      u_even_sum += k[j].r * k[j].r ;
 120   4                                      i_even_sum += k[j].i * k[j].i ;
 121   4                              }
 122   3      
 123   3                              hd_u[i][j-2] =  k[j].r * 10000L / k[1].r ; /*各次谐波畸变率*/
 124   3                              hd_i[i][j-2] =  k[j].i * 10000L / k[1].i;
 125   3                              
 126   3                      }
 127   2      
 128   2                      k_sum_u= sum_u = k_sum_i= sum_i  = 0;
 129   2                      for ( j = 1; j < (FFT_N/2); j ++ )
 130   2                      {
 131   3                              k_sum_u += k[j].r * k[j].r * j * j;
 132   3                              sum_u += k[j].r * k[j].r;
 133   3                              k_sum_i += k[j].i * k[j].i * j * j;
 134   3                              sum_i += k[j].i * k[j].i;
 135   3                      }
 136   2      
 137   2                      /* 谐波畸变率单位%,保留1位小数*/
 138   2                      thd_u[i] = fSqrt( u_total_sum ) * 10000L / k[1].r;
 139   2                      thd_u_odd[i] =  fSqrt( u_odd_sum ) * 10000L / k[1].r;
 140   2                      thd_u_even[i] = fSqrt( u_even_sum ) * 10000L / k[1].r;
 141   2                      thd_i[i] = fSqrt( i_total_sum ) * 10000L / k[1].i;
 142   2                      thd_i_odd[i] = fSqrt( i_odd_sum ) * 10000L /k[1].i;
 143   2                      thd_i_even[i] = fSqrt( i_even_sum ) * 10000L / k[1].i;
 144   2      
 145   2                      /* 计算K因子,保留1位小数*/
 146   2                      k_i[i] =  ( k_sum_i / sum_i ) * 100L;    
 147   2                      k_u[i] = ( k_sum_u / sum_u )* 100L; 
 148   2      
 149   2                      /**********谐波畸变率和K因子计算结束*********/
 150   2      
 151   2      #if 0   /* 不需要计算基波及谐波的幅值 */
                              for ( j = 2; j < (FFT_N/2); j ++ )
                              {
                                      /* 电压保留两位小数,电流保留3位小数*/
                                      /* 计算结果为一次侧的值*/
              
                                      k[j].r = (k[j].r * 19250L / 10000L) * volts_scale;
                                      k[j].i = (k[j].i * 10728L / 10000L) * amps_scale;
                              }
              #endif
 161   2                      
 162   2              }
 163   1      
 164   1      
 165   1      }


MODULE INFORMATION:   STATIC OVERLAYABLE
   CODE SIZE        =   2732    ----
   CONSTANT SIZE    =   ----    ----
   XDATA SIZE       =   1024       3
   PDATA SIZE       =   ----    ----
   DATA SIZE        =   ----    ----
   IDATA SIZE       =   ----    ----
   BIT SIZE         =   ----    ----
END OF MODULE INFORMATION.


C51 COMPILATION COMPLETE.  0 WARNING(S),  0 ERROR(S)

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -