fft(matlab)3

最新推荐文章于 2024-03-23 09:36:36 发布
最新推荐文章于 2024-03-23 09:36:36 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： 数字信号处理 文章标签： matlab fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45834157/article/details/124417825
版权

clc
clear all
fs=1*10^6;
f=50*10^3;
N=260;

L=1000;
t=0:L-1;
t=t/fs;

s=sin(2*pi*f*t);

a=abs((fft(s,N)));
subplot(211);
plot(t(1:100)*1000,s(1:100));
xlabel('时间（ms）');
ylabel('幅度（v）');

subplot(212)
n=0:N-1;
stem(n,a);
xlabel('FFT的位置');
ylabel('FFT变换的模');

clc
clear all
fs=1*10^6;
f1=50*10^3;
f2=39.0625*10^3;   
N=260;

L=1000;
t=0:L-1;
t=t/fs;

s=sin(2*pi*f1*t)+sin(2*pi*f2*t);

a=abs(fft(s,N));

subplot(211)
plot(t(1:100)*1000,s(1:100));
xlabel('时间(ms)');ylabel('幅度（v）');
legend('频率叠加信号的时域波形');

subplot(212)
n=0:N-1;
stem(n,a);
xlabel('fft位置');ylabel('fft变换的模');
legend('频率叠加信号的频域波形');

f1=2; 
f2=2.05;
fs=10;

N=128;
n=0:N-1;
xn1=sin(2*pi*f1*n/fs)+sin(2*pi*f2*n/fs);

a=fft(xn1);
a1=abs(a(1:N/2));

M=512;
xn2=[xn1 zeros(1,M-N)];
b=fft(xn2);
b1=abs(b(1:M/2));

n=0:M-1;
xn3=sin(2*pi*f1*n/fs)+sin(2*pi*f2*n/fs);
c=fft(xn3);
c1=abs(c(1:M/2));

subplot(321);
x1=0:N-1;
plot(x1,xn1);xlabel('n','fontsize',8);title('128点x(n)','fontsize',8);
subplot(322);
k1=(0:N/2-1)*fs/N;
plot(k1,a1);xlabel('f(Hz)','fontsize',8);title('128点x(n)的fft','fontsize',8);
subplot(323);
x2=0:M-1;
plot(x2,xn2);xlabel('n','fontsize',8);title('512点补零的x(n)','fontsize',8);
subplot(324);
k2=(0:M/2-1)*fs/M;
plot(k2,b1);xlabel('f(Hz)','fontsize',8);title('512点补零的x(n)fft','fontsize',8);
subplot(325);
plot(x2,xn3);xlabel('n','fontsize',8);title('512点的x(n)','fontsize',8);
subplot(326);
plot(k2,c1);xlabel('f(Hz)','fontsize',8);title('512点的x(n)fft','fontsize',8);

fs=50*10^6;
f1=1*10^6;
f2=2*10^6;
f3=3*10^6;

N=512;
t=0:1/fs:511/fs;
s1=sin(2*pi*f1*t);
s2=sin(2*pi*f2*t);
s3=sin(2*pi*f3*t);
s=s1+s2+s3;
a=abs(fft(s1,N));
a1=abs(fft(s2,N));
a2=abs(fft(s3,N));
a3=abs(fft(s,N));
subplot(411)
plot(a); title('1mHz信号的频谱');
subplot(412)
plot(a1); title('2mHz信号的频谱');
subplot(413)
plot(a2); title('3mHz信号的频谱');

subplot(414)
plot(a3); title('合成信号的频谱');
s=s/max(abs(s));
da=round(s*127);
L=8;
fid=fopen('d:\data.txt','w');
for i=1:length(da)
 da1=dec2bin(da(i)+(da(i)<0)*2^L,L)   
  for j=1:L
      if da1(j)=='1'
       tb=1;
      else 
       tb=0;
      end
      fprintf(fid,'%d',tb);
  end
     fprintf(fid,'\r\n');
end
  fprintf(fid,':');
  fclose(fid);

dn=[100,zeros(1,511)];

plot(abs(fft(dn)));
N=8;
fid=fopen('d:\data.txt','w');
for i=1:length(dn)
 da1=dec2bin(dn(i)+(dn(i)<0)*2^N,N)   
  for j=1:N
      if da1(j)=='1'
       tb=1;
      else 
       tb=0;
      end
      fprintf(fid,'%d',tb);
  end
     fprintf(fid,'\r\n');
end
  fprintf(fid,':');
  fclose(fid);

4.

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date:    08:53:12 05/10/2021 
// Design Name: 
// Module Name:    fftm 
// Project Name: 
// Target Devices: 
// Tool versions: 
// Description: 
//
// Dependencies: 
//
// Revision: 
// Revision 0.01 - File Created
// Additional Comments: 
//
//
module fftm(
      input clk,
        input start,
        output div,  //dv成功
        output [7:0]xk     //输出谱线位置
     
    );
             wire dv,rfd,done,busy,edone;
             wire [8:0]xk_index;
             wire  [8:0] xn_index; 
             wire  [17:0] xk_im ;
             wire [7:0] sine;
             wire  signed [17:0]  dout;
            ddsm u0 (
              .clk(clk), // input clk
              .we(1'b1), // input we
              .data(16'd1311), // input [15 : 0] data
              .sine(sine) // output [7 : 0] sine
            );

            mfft u1(
              .clk(clk), // input clk
              .start(start), // input start
              .unload(1'b1), // input unload
              .xn_re(sine), // input [7 : 0] xn_re
              .xn_im(8'd0), // input [7 : 0] xn_im
              .fwd_inv(1'b1), // input fwd_inv
              .fwd_inv_we(1'b1), // input fwd_inv_we
              .rfd(rfd), // output rfd
              .xn_index(xn_index), // output [8 : 0] xn_index
              .busy(busy), // output busy
              .edone(edone), // output edone
              .done(done), // output done
              .dv(dv), // output dv
              .xk_index(xk_index), // output [8 : 0] xk_index
              .xk_re(dout), // output [17 : 0] xk_re
              .xk_im(xk_im) // output [17 : 0] xk_im
            );


            reg ce=0;

            always@(posedge clk)
                 if(xk_index==256)
                 ce<=1;
                     
            assign div=ce;

             reg signed [21:0] data_max=0;
             reg [8:0] n=0;
             reg  [8:0] p=0;
             always@(posedge clk)
              if((dv==1)&&(xk_index<256))   begin
              if(dout>data_max) begin
                  data_max<=dout;
                  n<=xk_index;
                  end
                  end
                  else begin
                  p<=n;
                  end
      
    assign xk=p;  

6.

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date:    18:55:32 05/11/2021 
// Design Name: 
// Module Name:    signed_detect 
// Project Name: 
// Target Devices: 
// Tool versions: 
// Description: 
//
// Dependencies: 
//
// Revision: 
// Revision 0.01 - File Created
// Additional Comments: 
//
//
module signed_detect(
    input clk,
     input [7:0]rx_data,
     output ce,
     output reg [7:0] tx_data 
     
    
    );
     
    
    reg [30:0] cnt3=0;
    reg clk9600hz=0;
    
      always@(posedge clk )
           if(cnt3==2603/*50*/)    
            begin
                clk9600hz<=~clk9600hz;
                cnt3<=0;
                end
            else 
             cnt3<=cnt3+1;
        reg ce=0;     
    always@(posedge clk9600hz)
          if((rx_data==8'haa)&&(div))
             ce<=1;
          else
            ce<=0;

       
    reg [15:0]cn4=0;
  reg  [4:0]s=0;
    always@(posedge clk9600hz)    
     begin
       if (cn4<9599)
         cn4<=cn4+1;
       else if (cn4==9599)
        begin
             cn4<=0;
              s<=s+1;
      end
     end                
             
    
        always@(*)
        case(s)
        1:tx_data<=f1;
        2:tx_data<=f2;
        3:tx_data<=f3;
       4:tx_data<=pow1[7:0];
       5:tx_data<=pow1[15:8];
       6:tx_data<=pow1[23:16];
        7:tx_data<=pow1[31:24];
        8:tx_data<=pow1[35:32];
        9:tx_data<=pow2[7:0];
       10:tx_data<=pow2[15:8];
       11:tx_data<=pow2[23:16];
        12:tx_data<=pow2[31:24];
        13:tx_data<=pow2[35:32];
        14:tx_data<=pow3[7:0];
       15:tx_data<=pow3[15:8];
       16:tx_data<=pow3[23:16];
        17:tx_data<=pow3[31:24];
        18:tx_data<=pow3[35:32];
        default:tx_data<=8'hbb;
        endcase
             
         
            
     
   reg [7:0] f1;
    reg [7:0]f2;
   reg  [7:0] f3;     
   reg [35:0] pow1;
    reg [35:0] pow2;
   reg [35:0] pow3;      
  
     reg div;
wire [8:0]xk_index;
    wire signed [17:0]xk_re,xk_im;
    wire[35:0]xk_rsq,xk_isq,power2;
    reg[35:0]power3,power4;
    reg dv1,dv2;
    reg[8:0]xk_index1;
    wire signed [7:0] xn;
     wire signed [5:0]sine,sine1,sine2; 
    
    dds1 ua (
  .clk(clk), // input clk
  .we(1'b1), // input we
  .data(16'd1311), // input [15 : 0] data
  .sine(sine) // output [5 : 0] sine
);
    
    
    dds1 ub (
  .clk(clk), // input clk
  .we(1'b1), // input we
  .data(16'd2323), // input [15 : 0] data
  .sine(sine1) // output [5 : 0] sine
);
    
    dds1 uc (
  .clk(clk), // input clk
  .we(1'b1), // input we
  .data(16'd3933), // input [15 : 0] data
  .sine(sine2) // output [5 : 0] sine
);
    
    
    
    assign xn=sine-sine1-sine2;
    
    
    //例化512点FFT核
    fft512 u1 (
  .clk(clk), // input clk
  .start(1'b1), // input start
  .unload(1'b1), // input unload
  .xn_re(xn), // input [7 : 0] xn_re
  .xn_im(8'd0), // input [7 : 0] xn_im
  .fwd_inv(1'b1), // input fwd_inv
  .fwd_inv_we(1'b1), // input fwd_inv_we
  .rfd(rfd), // output rfd
  .xn_index(xn_index), // output [8 : 0] xn_index
  .busy(busy), // output busy
  .edone(edone), // output edone
  .done(done), // output done
  .dv(dv), // output dv
  .xk_index(xk_index), // output [8 : 0] xk_index
  .xk_re(xk_re), // output [17 : 0] xk_re
  .xk_im(xk_im) // output [17 : 0] xk_im
);
//计算谱线的功率，乘法运算二级流水
    mult18 u2 (
    .clk(clk), // input clk
    .a(xk_re), // input [17 : 0] a
    .b(xk_re), // input [17 : 0] b
    .p(xk_rsq) // output [35 : 0] p
    );
    mult18 u3 (
    .clk(clk), // input clk
    .a(xk_im), // input [17 : 0] a
    .b(xk_im), // input [17 : 0] b
    .p(xk_isq) // output [35 : 0] p
    );
    assign power2=xk_rsq+xk_isq;
    
    reg [8:0]xk_0;
    reg dv_0;
    always@(posedge clk)
    begin
     xk_0<=xk_index;
     dv_0<=dv;
     end
     
     always@(posedge clk)
        begin
            dv1<=dv_0;
//            dv2<=dv1;
            power3<=power2;
            power4<=power3;
            xk_index1<=xk_0;
//            xk_index2<=xk_index1;    
        end
        
      reg [7:0] ft1;
      reg [7:0] ft2;
      reg [7:0] ft3;
      reg [35:0]powt1;
     reg  [35:0] powt2;
     reg  [35:0] powt3;      
    

        reg [1:0] cnt=0;
    always@(posedge clk)
        //FFT变换完成，只判断正频率部分谱线
        if((dv1)&(xk_index1<9'd256))begin
        //判断是否出现波峰，且幅度大于0.03v的谱线
        if((power3>power2)&(power3>power4)&(power3>36'd951327))
       begin
         if(cnt==0)
          begin
          ft1<=xk_index1;
          powt1<=power3;
          cnt<=cnt+1;
          end
          if(cnt==1)
          begin
          ft2<=xk_index1;
          powt2<=power3;
          cnt<=cnt+1;
          end
         if(cnt==2)
          begin
          ft3<=xk_index1;
          powt3<=power3;
          cnt<=3;
          end
         end
         end
        else
        begin
        cnt<=0;
        ft1<=0;
        ft2<=0;
        ft3<=0;
        powt1<=0;
        powt2<=0;
        powt3<=0;
        end
        
    always@(posedge clk)
     if(xk_index1==256)
        begin
        f1<=ft1;
          f2<=ft2;
          f3<=ft3;
          pow1<=powt1;
          pow2<=powt2;
          pow3<=powt3;
          end
                 
      
    always@(posedge clk)
         if(cnt>0)
            div<=1'b1;
           else
            div<=0;
                
         
         
         
         
endmodule
 

fpga入门选手
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
matlab的fftn,matlab fftn
weixin_32859127的博客
03-16 1149
(X,m,n) fftn 进行 n 维快速傅立叶变换(反变换用 ifftn) 语法:Y=ffn(X) \\ Y=fftn(X,siz) fftshift 快速傅立叶变换的 DC 组件移到光谱中心 语法:......(X,m,n) fftn 进行 n 维快速傅立叶变换(反变换用 ifftn) 语法:Y=ffn(X) \\ Y=fftn(X,siz) fftshift 快速傅立叶变换的 DC 组件移到...
matlab实现混合基fft算法,一种基于实时性处理的混合基fft方法
weixin_35668158的博客
03-17 1162
一种基于实时性处理的混合基fft方法【专利摘要】本发明公开了一种基于实时性处理的混合基FFT方法，适用于FFT点数满足级数为s=s1+s2的情况。第一步根据实时性的要求，将输入数据分配到r2个存储器中，每个存储器深度为第二步，采用流水方法读取多个存储器，对r2个N′点进行DFT运算；在读取过程中，第n+1个存储器读取时序延后第n个存储器；第三步，采用并行方法对多个存储器读取，对N′个r2点进行DF...
matlab 三维傅里叶快速算法 fft
07-15
用matlab实现三维傅里叶快速算法，方法快速简单有效，可以对任意三维数据进行处理。
matlab 高阶（三）—— 插值（fft、）
weixin_30847271的博客
02-22 1243
1. FFT 插值 y = interpft(x,n) y = [0, .5, 1., 1.5, 2., 1.5, 1., .5, 0, -.5, -1, -1.5, -2., -1.5, -1., -.5, 0]; N = length(y); L = 5; % 插值因子，interpolation factor，即插值后数组的长度是原先...
DFT的matlab源代码-Napa-FFT3:CL中更快，位反转的FFT
05-26
DFT的matlab源代码Napa-FFT3：概述 Napa-FFT3是Napa-FFT的完整重写（版本2是已终止的实验）。 目标仍然是相同的：通过混合使用缓存友好的算法和代码生成功能，在Common Lisp中提供FFT例程，以提供与现有技术相当的性能。 在这方面，它是成功的：根据使用方式的不同，Napa-FFT3最多慢于中小型输入的FFTW的三倍，并且可以快于大型输入的FFTW。 完整的画面比这更复杂。 有关详细信息，请参见性能部分。 Napa-FFT3的目标不仅是提供离散傅立叶变换（DFT）例程，而且（而是）提供构件块来表达涉及DFT的常见操作：滤波，卷积等。这就是启用Napa-FFT的原因在不优化装配水平的情况下实现如此高的性能。 Easy Interface部分对于大多数开发人员来说已经足够了。 底层接口将在另一部分中介绍，并且可能对某些接口很有用。 Napa-FFT3还明确支持对实际数据进行FFT，并将FFT反向转换为实际数据。 Real Interface部分描述了该功能，并与Easy Interface结合使用。 最后，请参阅“安装”部分以获取安装说明，并参见“实现”部
基于FFT算法的MTALAB傅里叶级数3D可视化研究（Matlab代码实现）
weixin_66436111的博客
03-07 878
值得注意的是，基于FFT算法的MATLAB傅里叶级数3D可视化研究需要一定的数学和编程基础，以熟悉FFT算法的原理和MATLAB的使用。但是，通过这样的研究，您可以更深入地了解周期信号的频域特性，并了解傅里叶级数在信号分析和处理中的应用。通过这种方法，可以将输入信号通过傅里叶级数展开成一系列正弦和余弦函数的叠加，然后将其可视化为3D图形。基于FFT算法的MATLAB傅里叶级数3D可视化研究意味着使用MATLAB中的FFT函数来计算傅里叶级数，并将结果可视化为3D图形。xlabel('频域角度');
FFT.rar_fft matlab_nestnk3
09-24
标题中的“FFT.rar_fft matlab_nestnk3”表明这是一个与快速傅里叶变换（FFT）相关的资源，且可能使用了MATLAB编程语言，并涉及到“nestnk3”这一特定的算法或函数。描述中的“进行FFT DE CHENGUX 挺好的 欢迎下载”...
fft.rar_fft matlab
09-21
标题中的"fft.rar_fft matlab"表明这是一个关于快速傅里叶变换(FFT)的MATLAB实现。FFT是一种在数字信号处理领域广泛应用的算法，用于将时域信号转换到频域，以便分析信号的频率成分。 在描述中提到"FFT的仿真程序，...
FFT_fft_matlab_
09-30
标题中的"FFT_fft_matlab_"表明我们关注的主题是快速傅里叶变换（FFT）在MATLAB环境中的应用以及如何用C语言实现相同的功能。FFT是一种高效计算离散傅里叶变换（DFT）的算法，广泛应用于信号处理、图像处理、数字...
fft_fft_matlab_
10-02
3. 在处理实数信号时，`fft`会返回对称的复数结果，实际的频谱信息只存在于前半部分。 4. 采样率和信号长度的选择对分析结果有直接影响，必须确保无混叠（采样定理）。 了解这些基本概念和MATLAB的使用方法，将有助...
FFT_3octave_A_倍频程_1/3倍频程计算_existui9_1/3octave_1/3倍频程_
10-01
1/3倍频程的实现，先fft然后计算上下限频率。
实用MATLABfft程序
02-25
3. **窗函数应用**：在进行FFT分析时，为了避免截断效应，通常会结合使用窗函数，如汉明窗、哈特莱窗等。MATLAB中的`hamming`、`hanning`等函数可以生成不同类型的窗函数，与原始信号相乘后再进行FFT，可以改善频谱...
FFT
andyc_03的博客
05-24 172
【算法简介】 FFT主要用于处理多项式乘法的问题，时间复杂度可以优化到O(NlogN) 整体思路是把两个多项式转换为点值表达，然后用O(N)进行乘法 这个问题的瓶颈就在于如何用更快的方式转换为点值 这里就要引入傅里叶的方法了： 我们取一些特殊的点计算点值，也就是把复数的单位圆平均分成n分的值带入 然后我们再针对这个进行加速，也就是快速傅里叶变换 这样我们就可以证明在N*logN的复杂度进行一些操作 继续优化：把数组分到最后的位置，我们可以发现一些规律 如果一个点位置..
MATLAB下fft(Fast Fourier Transform)函数的使用
zhiTjun的博客
10-27 3802
MATLAB下fft(Fast Fourier Transform)函数的使用 直到现在才意识到，DFT或FFT无论是在信号处理、还是在图像分析、又或是模式识别中的地位和重要性，以至于在大学竟然没有自己写过信号的FFT的程序，果然出来混迟早是要还的，大学欠下的债现在该还了。花了一天看DFT、FFT，去证明蝶形运算、快速算法，又花了一天去写程序，去验证Fourier的理论，去实现自己的想法。 1、S...
Matlab fftshift 详解
热门推荐
魔法森林博客
05-08 12万+
说明：本文为转载加上自己的编辑，转载请注明出处。 Matlab fftshift 详解 一.实信号情况 因为实信号以fs为采样速率的信号在 fs/2处混叠，所以实信号fft的结果中前半部分对应[0, fs/2],后半部分对应[ -fs/2, 0] 1）实信号fft的结果前半部分对应[0, fs/2]是正频率的结果,后半部分对应[ -fs/2, 0]是负频率的结果。大于fs/2的部分的频谱实...
MATLAB——FFT(快速傅里叶变换)
m0_46155417的博客
03-10 5万+
MATLAB——快速傅里叶变换
探索FFTW3：高效傅里叶变换库的奥秘
最新发布
gitblog_00020的博客
03-23 527
探索FFTW3：高效傅里叶变换库的奥秘 项目地址:https://gitcode.com/FFTW/fftw3 FFTW3 是一个开源的、高度优化的C语言库，用于执行离散傅里叶变换（DFT）及其逆变换。FFTW在学术界和工业界都享有盛誉，因其卓越的性能和广泛的适用性而备受赞誉。 项目简介 FFTW，全称为“不是快速傅里叶变换”的快速傅里叶变换，是一个双关语，既幽默又揭示了其核心价值——提供一种比其...
xilinx 的FFT IP核的使用手册及仿真结果，matlab仿真结果对比，适合初学者学习
weiyunguan8611的博客
08-24 7782
1、FFT的IP核的信号分析 clk：时钟信号，上升沿有效 start：FFT的启动信号，高电平有效。当此信号变高时，开始输入数据，随后直接进行FFT转换操作和数据输出。一个STATRT脉冲，允许对一帧进行FFT转换。如果每N个时钟有一个START脉冲或者START始终为高，则都可以连续进行FFT。如果在最初的START前还没有fwd_inv_we、scale_sch_we信号，则START变高以...
matlab 三维时频幅值图
qingfengxd1的博客
05-13 6210
1、内容简介 略 269 2、内容说明 时频分析（JTFA）即时频联合域分析，作为分析时变非平稳信号的有力工具，清楚地描述了信号频率随时间的变化关系。 时频图清楚地描述了信号频率随时间的变化关系，并且还通过颜色表达了对应的振幅大小。 （属于三维空间 H（w，t）） 答1疑2咨3询4企q鹅q号：1762016542 3、仿真分析 clc close all clear data1 = load('1.txt');t1 = data1(:,1);x1 = data1(:,2);y1 = data
fft matlab
07-28
在Matlab中，您可以使用内置的fft函数来执行傅里叶变换（FFT）操作。fft函数可以用于计算一维、二维或多维数据的FFT。 下面是一个使用Matlab的fft函数计算一维FFT的示例： ```matlab % 输入信号 x = [1, 2, 3, 4, ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值