FFT求得的相位一直在变化

h418452224

请教各位大虾。小弟我通过ADC和DMA双缓冲模式在20ms内采样交流电压256个点。做完fft变换后，通过atan2（b,a）求得的相位一直在0~360之间变化。（b和a是fft处理后数组的第2个点的虚部和实部）。这是软件哪里有问题没有处理好么？检查了好几遍不知该如何入手解决此问题。附上我的fft处理的程序：

1. <blockquote>//DSP运算函数

复制代码

eric2013

等我发布案例，最近没顾上整了，忙于ThreadX

FFT加窗插值修正后，求解多次谐波频率，幅值，相位的精度杠杠的
http://www.armbbs.cn/forum.php?m ... id=97787&fromuid=58
(出处: 硬汉嵌入式论坛)

h418452224

eric2013 发表于 2020-6-11 11:46
等我发布案例，最近没顾上整了，忙于ThreadX

FFT加窗插值修正后，求解多次谐波频率，幅值，相位的精度杠 ...

硬汉哥，我现在对精度的要求还不是特别高。就是软件处理上有疑问。求相位的时候是不是要取多个周期的波形来求啊？我现在的相位角会在0~360之间变化

h418452224

1. void DSP_Process(void)
   
2. {               
   
3.                 u16 i=0,a=0;
   
4.                 //初始化scfft结构体，设定FFT相关参数
   
5.                 arm_cfft_radix4_init_f32(&scfft,FFT_LENGTH,0,1);
   
6.           float GLYS_A=0,GLYS_B=0,GLYS_C=0;
   
7.                 float PowerA=0,PowerB=0,PowerC=0;
   
8.           if(Conv_flag)//DMA有准备好的数据了
   
9.                 {
   
10.                            a=DMA_GetCurrentMemoryTarget(DMA2_Stream0);
    
11.                                  if(a == DMA_Memory_0)
    
12.                                  {
    
13.                                          ADC_ConvertedValueptr = uAD_Buff_B;
    
14.                                  }
    
15.                                  else
    
16.                                  {
    
17.                                          ADC_ConvertedValueptr = uAD_Buff_A;
    
18.                                  }
    
19.                                 for(i=0;i<FFT_LENGTH;i++)
    
20.                                 {
    
21.                                                 ADC_Three_V[0][i]=ADC_ConvertedValueptr[i*6];
    
22.                                                 ADC_Three_V[1][i]=ADC_ConvertedValueptr[1+i*6];
    
23.                                                 ADC_Three_V[2][i]=ADC_ConvertedValueptr[2+i*6];
    
24.                                                 True_Three_V[0][i]=(VDDA_VAL*(ADC_Three_V[0][i]-VOLTAGE_Zero-Voltage_A_Devi))/4096/R2*R1;
    
25.                                                 True_Three_V[1][i]=(VDDA_VAL*(ADC_Three_V[1][i]-VOLTAGE_Zero-Voltage_B_Devi))/4096/R2*R1;
    
26.                                                 True_Three_V[2][i]=(VDDA_VAL*(ADC_Three_V[2][i]-VOLTAGE_Zero-Voltage_C_Devi))/4096/R2*R1;
    
27.                                                 fft_inputbuf_V[0][2*i]=True_Three_V[0][i];        //实部
    
28.                                                 fft_inputbuf_V[0][2*i+1]=0;//虚部全部为0
    
29.                                                 fft_inputbuf_V[1][2*i]=True_Three_V[1][i];        //实部
    
30.                                                 fft_inputbuf_V[1][2*i+1]=0;//虚部全部为0
    
31.                                                 fft_inputbuf_V[2][2*i]=True_Three_V[2][i];        //实部
    
32.                                                 fft_inputbuf_V[2][2*i+1]=0;//虚部全部为0                       
    
33.                                                 ADC_Three_I[0][i]=ADC_ConvertedValueptr[3+i*6];
    
34.                                                 ADC_Three_I[1][i]=ADC_ConvertedValueptr[4+i*6];
    
35.                                                 ADC_Three_I[2][i]=ADC_ConvertedValueptr[5+i*6];
    
36.                                                 True_Three_I[0][i]=(VDDA_VAL*(ADC_Three_I[0][i]-VOLTAGE_Zero-Current_A_Devi))/4096/R3*3000;
    
37.                                                 True_Three_I[1][i]=(VDDA_VAL*(ADC_Three_I[1][i]-VOLTAGE_Zero-Current_B_Devi))/4096/R3*3000;
    
38.                                                 True_Three_I[2][i]=(VDDA_VAL*(ADC_Three_I[2][i]-VOLTAGE_Zero-Current_C_Devi))/4096/R3*3000;
    
39.                                                 fft_inputbuf_I[0][2*i]=True_Three_I[0][i];        //实部
    
40.                                                 fft_inputbuf_I[0][2*i+1]=0;//虚部全部为0
    
41.                                                 fft_inputbuf_I[1][2*i]=True_Three_I[1][i];        //实部
    
42.                                                 fft_inputbuf_I[1][2*i+1]=0;//虚部全部为0
    
43.                                                 fft_inputbuf_I[2][2*i]=True_Three_I[2][i];        //实部
    
44.                                                 fft_inputbuf_I[2][2*i+1]=0;//虚部全部为0
    
45.                                 }               
    
46.                                 //电压电流有效值
    
47.                                 arm_rms_f32(True_Three_V[0],FFT_LENGTH,&VARms);
    
48.                                 arm_rms_f32(True_Three_V[1],FFT_LENGTH,&VBRms);   
    
49.                                 arm_rms_f32(True_Three_V[2],FFT_LENGTH,&VCRms);   
    
50.                                 arm_rms_f32(True_Three_I[0],FFT_LENGTH,&IARms);  
    
51.                                 arm_rms_f32(True_Three_I[1],FFT_LENGTH,&IBRms);   
    
52.                                 arm_rms_f32(True_Three_I[2],FFT_LENGTH,&ICRms);
    
53.                                 //电压数据FFT计算（基4）
    
54.                                 arm_cfft_radix4_f32(&scfft,fft_inputbuf_V[0]);
    
55.                                 arm_cfft_radix4_f32(&scfft,fft_inputbuf_V[1]);
    
56.                                 arm_cfft_radix4_f32(&scfft,fft_inputbuf_V[2]);               
    
57.                                 //电流数据FFT计算（基4）
    
58.                                 arm_cfft_radix4_f32(&scfft,fft_inputbuf_I[0]);
    
59.                                 arm_cfft_radix4_f32(&scfft,fft_inputbuf_I[1]);
    
60.                                 arm_cfft_radix4_f32(&scfft,fft_inputbuf_I[2]);       
    
61. //        MaxVA=(float)(sqrt(fft_inputbuf_V[0][2]*fft_inputbuf_V[0][2]+fft_inputbuf_V[0][3]*fft_inputbuf_V[0][3]))/128;
    
62.                                 //角度
    
63.                                 jiaodu_VA=JiaoDu_Process(fft_inputbuf_V[0]);
    
64.                                 if(jiaodu_VA<0)
    
65.                                 jiaodu_VA+=360.0;
    
66.                                 jiaodu_VB=JiaoDu_Process(fft_inputbuf_V[1]);
    
67.                                 if(jiaodu_VB<0)
    
68.                                 jiaodu_VB+=360.0;                               
    
69.                                 jiaodu_VC=JiaoDu_Process(fft_inputbuf_V[2]);
    
70.                                 if(jiaodu_VC<0)
    
71.                                 jiaodu_VC+=360.0;               
    
72.                                 jiaodu_IA=JiaoDu_Process(fft_inputbuf_I[0]);
    
73.                                 jiaodu_IB=JiaoDu_Process(fft_inputbuf_I[1]);
    
74.                                 jiaodu_IC=JiaoDu_Process(fft_inputbuf_I[2]);
    
75.                                
    
76.                                 //功率因素
    
77.                                 GLYS_A=Factor_Process(fft_inputbuf_V[0],fft_inputbuf_I[0]);
    
78.                                 GLYS_B=Factor_Process(fft_inputbuf_V[1],fft_inputbuf_I[1]);
    
79.                                 GLYS_C=Factor_Process(fft_inputbuf_V[2],fft_inputbuf_I[2]);
    
80.                                
    
81.                                
    
82.                                 PowerA=VARms*IARms*GLYS_A;
    
83.                                 PowerB=VARms*IARms*GLYS_B;
    
84.                                 PowerC=VARms*IARms*GLYS_C;
    
85.                                
    
86.                                 Tol_Power=PowerA+PowerB+PowerC;
    
87.                                 Tol_QPower=VARms*IARms+VARms*IARms+VARms*IARms;
    
88.                                 Tol_Factor=(GLYS_A+GLYS_B+GLYS_C)/3;
    
89.                                 Conv_flag=0;
    
90.            }
    
91. }
    
92. 
    
93. 
    
94. float Factor_Process(float *fft_Data_V,float *fft_Data_I)
    
95. {
    
96.             float Real_V,Imaginary_V,hudu_V,Real_C,Imaginary_C,hudu_C,GLYS;
    
97.                         Real_V      = fft_Data_V[2];         //timeout3=15
    
98.                         Imaginary_V = fft_Data_V[3];
    
99.                   hudu_V = atan2(Imaginary_V , Real_V);
    
100.                         Real_C      = fft_Data_I[2];
     
101.                         Imaginary_C = fft_Data_I[3];
     
102.                         hudu_C = atan2(Imaginary_C , Real_C);
     
103.                         GLYS=cos(hudu_V-hudu_C); //功率因素       
     
104.       return GLYS;
     
105. }
     
106. 
     
107. float JiaoDu_Process(float *fft_Data)
     
108. {
     
109.                   float Real,Imaginary,hudu,jiaodu;
     
110.                         Real      = fft_Data[2];         //timeout3=15
     
111.                         Imaginary = fft_Data[3];
     
112.                   hudu = atan2(Imaginary , Real);
     
113.                         jiaodu = (float)(hudu* 180 / Pi);
     
114.       return jiaodu;
     
115. }

复制代码

eric2013

h418452224 发表于 2020-6-11 13:12

你这种干求不行的。相位当然是乱跳。

h418452224

eric2013 发表于 2020-6-11 13:20
你这种干求不行的。相位当然是乱跳。

是要选个点做参考么？硬汉哥求指点

eric2013

h418452224 发表于 2020-6-11 13:25
是要选个点做参考么？硬汉哥求指点

最简单情况下，如果波形的频率是固定的，至少跳动非常微小的情况下，采样率是此周期的整数倍，一个周期有100个点就行，采集几个周期求FFT，这种情况求解出来的还算准。

如果频率是跳转的范围，就不行了。

h418452224

eric2013 发表于 2020-6-11 13:31
最简单情况下，如果波形的频率是固定的，至少跳动非常微小的情况下，采样率是此周期的整数倍，一个周期有 ...

好的，好的。我试试看

h418452224

eric2013 发表于 2020-6-11 13:31
最简单情况下，如果波形的频率是固定的，至少跳动非常微小的情况下，采样率是此周期的整数倍，一个周期有 ...

硬汉哥。（采集几个周期求FFT）有什么比较简便的思路么？小弟我刚刚试着实现采4个周期。程序for循环了4遍。这部分看着好臃肿啊

h418452224

eric2013 发表于 2020-6-11 13:31
最简单情况下，如果波形的频率是固定的，至少跳动非常微小的情况下，采样率是此周期的整数倍，一个周期有 ...

虽然程序臃肿，但是还是可以用。可是结果算出来的相位角还是会在0~360之间规律的变化

252514251

对的，你的adc 定时器 有误差，不能锁定初始采样的相位，0-360，缓慢连续变化，就没有问题

云琴箫龙

仿真算一下相互之间的相位差，只要相位差不变，算法就没问题，最终的功率应该也是稳定的。

713042507

老哥，我最近也在做这个，有空交流一下哇