DSP28335通过FFT变换实现高频滤波

最新推荐文章于 2023-06-22 10:29:25 发布
最新推荐文章于 2023-06-22 10:29:25 发布
阅读量2.1k 收藏 39
点赞数 2
分类专栏： 经验 文章标签： DSP28335 FFT变换 高频滤波
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36538991/article/details/89297556
版权

这次项目中，由于AD采集到的高频开关噪声大，对数据处理存在极大干扰，经过示波器测量，发现噪声频率主要集中在80kHz，寻求老师帮助，老师推荐使用FFT滤波，有同学使用的是FIR滤波，通过Matlab中自带的FDA工具获得参数，效果在噪声幅值大于0.6V存在阶段性下滑，我使用的FFT滤波，由于网上资料有限，网上都是推荐的是直接使用FIR滤波这类的滤波器，FFT滤波可能会存在一些问题，但是目前对于本次项目，我还是觉得尝试一下FFT滤波，查看一下效果如何。
首先使用的Matlab进行仿真，代码如下

SampleFreq =	800000;			%为滤去80k高频 需大于2*80k的采样频率
S1_Freq	=	20000;			%模拟的初始信号频率
S2_Freq		=80000;		%高频开关噪声的频率
SAMPLE_NODES = 32;  
i = 1:SAMPLE_NODES;  

wt1=2*pi*i*S1_Freq;
wt1=wt1/SampleFreq;
wt2=2*pi*i*S2_Freq;
wt2=wt2/SampleFreq;

x = sin(wt1) +0.2*cos(wt2)+2; %获得20KHz基波+80KHz谐波信号,
							  %其中+2幅值是为了保证（实际采集到的）输入信号始终为正

subplot(2,2,1); plot(x);title('Inputs');  
axis([0 SAMPLE_NODES 0 5]);  


y = fft(x, SAMPLE_NODES);       %对x进行fft变换
subplot(2,2,2); plot(abs(y));title('FFT');  
axis([0 SAMPLE_NODES 0 80]);  

for m=3:31                                  %对fft变换后的x进行滤波
    y(m) = 0;
end



z = ifft(y, SAMPLE_NODES);  %对滤波后的y进行IFFT
subplot(2,2,3); plot(abs(z));title('IFFT');  
axis([0 SAMPLE_NODES 0 5]);  

subplot(2,2,4);; plot(abs(y));title('IFFT-FFT');  
axis([0 SAMPLE_NODES 0 80]);

32点800Khz采样Matlab仿真图
在经过matlab仿真后,发现能达到预期滤波效果，动手！
在网上查阅各种资料，发现本科期间学过fft但是没怎么使用过，对FFT原理不太有印象了，恰好发现一篇神文：
https://zhuanlan.zhihu.com/p/19763358
对知识点进行了巩固哈哈哈哈

从而得到了以下FFT实现代码
头文件.h

/*
 * DSP_2833x_FFT.h
 *
 *  Created on: 2019年4月1日
 *      Author: ChenQingye
 */
/* 	日期      	实现功能
 * 	0327	实现FFT变换，能成功滤掉高频部分，但还需完善：IFFT变换，2k频率以内进行滤波
 * 			Graph坐标轴值：x轴：X(n) = (fs/N)*n		Y(n) = (N/2)*A	A为初始幅值默认1024
 * 	0328	完善FFT功能，满足200kHZ采样频率采到80kHZ高频噪声。
 * 	0401	自己编写ifft程序，需优化代码
 * 	0402	使用256点的FFT时钟周期需310,048个时钟周期，总814,224时钟周期
 * 			使用128点的FFT需要103,892个时钟周期，总386,111时钟周期
 * 			使用64点的FFT需要69,980个时钟周期，总183,774时钟周期
 * 			使用32点的FFT需要83,462个时钟周期，总83,462时钟周期
 *
 *
 *
 * */
#ifndef DSP_2833X_FFT_H_
#define DSP_2833X_FFT_H_


#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File
#include"math.h"
#define SampleFreq 	1000000			// 为滤去80k高频 需大于2*80k的采样频率
#define S1_Freq		20000			// 模拟的初始信号频率
#define S2_Freq		80000			// 高频开关噪声的频率
#define PI 3.1415926
#define SAMPLENUMBER 32			// 0-256个FFT样本点涵盖了一个低频信号0-FS的所有频率信息，FS是采样频率。
#define M log(SAMPLENUMBER)/log(2) 	// 变更FFT点数修改fft子程序方便的需要	2^8 = 256->M = 8;log(SAMPLENUMBER)/log(2)

void InitForFFT();
void FFT256(float32 dataR[SAMPLENUMBER],float32 dataI[SAMPLENUMBER]);//新加x7
void FFT128(float32 dataR[SAMPLENUMBER],float32 dataI[SAMPLENUMBER]);
void FFT64(float32 dataR[SAMPLENUMBER],float32 dataI[SAMPLENUMBER]);//去掉x6
void FFT32(float32 dataR[SAMPLENUMBER],float32 dataI[SAMPLENUMBER]);//去掉x5
void IFFT();
void FilterFFT();//实现FFT滤波器
void MakeFFTOut();
void MakeIFFTOut();
void CLearFFtData();
//void FFT(float dataR[SAMPLENUMBER],float dataI[SAMPLENUMBER]);

extern int16 INPUT[SAMPLENUMBER],FFTDATA[SAMPLENUMBER],IFFTDATA[SAMPLENUMBER];
extern float32 DATAR[SAMPLENUMBER],DATAI[SAMPLENUMBER];
extern float32 sin_tab[SAMPLENUMBER],cos_tab[SAMPLENUMBER];



#endif /* DSP_2833X_FFT_H_ */

实现代码

/*
 * DSP_2833x_FFT.c
 *
 *  Created on: 2019年4月3日
 *      Author: ChenQingye
 */
#include "DSP_2833x_FFT.h"


int16 INPUT[SAMPLENUMBER],FFTDATA[SAMPLENUMBER],IFFTDATA[SAMPLENUMBER];
float32 DATAR[SAMPLENUMBER],DATAI[SAMPLENUMBER];
float32 sin_tab[SAMPLENUMBER],cos_tab[SAMPLENUMBER];


void InitForFFT()//蝶形运算系数表计算
{
	int16 i;

	float32 wt1,wt2;


	for ( i=0;i<SAMPLENUMBER;i++ )
	{
		// 生成蝶形运算需要的三角表
		sin_tab[i]=sin(PI*2*i/SAMPLENUMBER);
		cos_tab[i]=cos(PI*2*i/SAMPLENUMBER);		// f = w/2pi =1hz

		// 生成模拟信号
		wt1=2*PI*i*S1_Freq;
		wt1=wt1/SampleFreq;

		wt2=2*PI*i*S2_Freq;
		wt2=wt2/SampleFreq;

		INPUT[i]=sin(wt1)*1024+0.2*cos(wt2)*1024+1024;		//f = w/2pi = 3hz
	}
	//初始化输入数据以及清空输出数组
	for ( i=0;i<SAMPLENUMBER;i++ )
		{
			DATAR[i] = INPUT[i];
			DATAI[i] = 0.0f;
			FFTDATA[i] = 0.0f;
			IFFTDATA[i] = 0.0f;
		}
}

void FilterFFT()//实现FFT滤波器
{
	int16 i = 0;
	int16 upLimit,downLimit;
	switch(SAMPLENUMBER)
		{
		case 32:
			upLimit = 31;
			downLimit = 3;
			break;
		case 64:
			upLimit = 62;
			downLimit = 4;
			break;
		case 128:
			upLimit = 120;
			downLimit = 9;
			break;
		case 256:
			upLimit = 240;
			downLimit = 12;
			break;
		default:
			break;
		}

	for(i = downLimit;i < upLimit;i++)//100kHZ采样 256点
	{
		DATAR[i] = 0;
		DATAI[i] = 0;
	}
}
void IFFT()
{
	int16 k = 0;

	for (k=0; k<=SAMPLENUMBER-1; k++) {
		DATAI[k] = -DATAI[k];
	}

	switch(SAMPLENUMBER)
	{
	case 32:
		FFT32(DATAR,DATAI);
		break;
	case 64:
		FFT64(DATAR,DATAI);
		break;
	case 128:
		FFT128(DATAR,DATAI);
		break;
	case 256:
		FFT256(DATAR,DATAI);
		break;
	default:
		break;
	}
//
//	if(SAMPLENUMBER == 256)/* using FFT */
//		FFT256(DATAR,DATAI);
//	else if(SAMPLENUMBER == 128)
//		FFT128(DATAR,DATAI);
//	else if(SAMPLENUMBER == 64)
//		FFT64(DATAR,DATAI);
//	else if(SAMPLENUMBER == 32)
//			FFT32(DATAR,DATAI);

	for (k=0; k<=SAMPLENUMBER-1; k++) {
		DATAR[k] = DATAR[k] / SAMPLENUMBER;
		DATAI[k] = -DATAI[k] / SAMPLENUMBER;
	}

}
void MakeFFTOut()
{
	Uint16 i;
	for ( i=0;i<SAMPLENUMBER;i++ )
	{
		FFTDATA[i]=sqrt(DATAR[i]*DATAR[i]+DATAI[i]*DATAI[i]);
	}
}

void MakeIFFTOut()
{
	Uint16 i;
	for ( i=0;i<SAMPLENUMBER;i++ )
	{
		IFFTDATA[i]=sqrt(DATAR[i]*DATAR[i]+DATAI[i]*DATAI[i]);
	}
}


void FFT256(float32 dataR[SAMPLENUMBER],float32 dataI[SAMPLENUMBER])//新加x7	310,048个时钟周期
{
	int16 x0,x1,x2,x3,x4,x5,x6,xx,x7;//x7
	int16 i,j,k,b,p,L;
	float32 TR,TI,temp;

	/********** following code invert sequence ************/
	for ( i=0;i<SAMPLENUMBER;i++ )
	{
		x0=x1=x2=x3=x4=x5=x6=0;
		x0=i&0x01; x1=(i/2)&0x01; x2=(i/4)&0x01; x3=(i/8)&0x01;x4=(i/16)&0x01; x5=(i/32)&0x01; x6=(i/64)&0x01;x7=(i/128)&0x01;//x7
		xx=x0*128+x1*64+x2*32+x3*16+x4*8+x5*4+x6*2+x7;
		dataI[xx]=dataR[i];
	}
	for ( i=0;i<SAMPLENUMBER;i++ )
	{
		dataR[i]=dataI[i]; dataI[i]=0;
	}

	/************** following code FFT *******************/
	for ( L=1;L<=M;L++ )
	{ /* for(1) */
		b=1; i=L-1;
		while ( i>0 )
		{
			b=b*2; i--;
		} /* b= 2^(L-1) */
		for ( j=0;j<=b-1;j++ ) /* for (2) */
		{
			p=1; i=M-L;
			while ( i>0 ) /* p=pow(2,M-L)*j; */
			{
				p=p*2; i--;
			}
			p=p*j;
			for ( k=j;k<SAMPLENUMBER;k=k+2*b ) /* for (3) */
			{
				TR=dataR[k]; TI=dataI[k]; temp=dataR[k+b];
				dataR[k]=dataR[k]+dataR[k+b]*cos_tab[p]+dataI[k+b]*sin_tab[p];
				dataI[k]=dataI[k]-dataR[k+b]*sin_tab[p]+dataI[k+b]*cos_tab[p];
				dataR[k+b]=TR-dataR[k+b]*cos_tab[p]-dataI[k+b]*sin_tab[p];
				dataI[k+b]=TI+temp*sin_tab[p]-dataI[k+b]*cos_tab[p];
			} /* END for (3) */
		} /* END for (2) */
	} /* END for (1) */
	for ( i=0;i<SAMPLENUMBER;i++ )
	{
		DATAR[i] = dataR[i];
		DATAI[i] = dataI[i];
	}
} /* END FFT */

void FFT128(float32 dataR[SAMPLENUMBER],float32 dataI[SAMPLENUMBER])	//103,892个时钟周期
{
	int16 x0,x1,x2,x3,x4,x5,x6,xx;
	int16 i,j,k,b,p,L;
	float32 TR,TI,temp;

	/********** following code invert sequence ************/
	for ( i=0;i<SAMPLENUMBER;i++ )
	{
		x0=x1=x2=x3=x4=x5=x6=0;
		x0=i&0x01; x1=(i/2)&0x01; x2=(i/4)&0x01; x3=(i/8)&0x01;x4=(i/16)&0x01; x5=(i/32)&0x01; x6=(i/64)&0x01;
		xx=x0*64+x1*32+x2*16+x3*8+x4*4+x5*2+x6;
		dataI[xx]=dataR[i];
	}
	for ( i=0;i<SAMPLENUMBER;i++ )
	{
		dataR[i]=dataI[i]; dataI[i]=0;
	}

	/************** following code FFT *******************/
	for ( L=1;L<=M;L++ )
	{ /* for(1) */
		b=1; i=L-1;
		while ( i>0 )
		{
			b=b*2; i--;
		} /* b= 2^(L-1) */
		for ( j=0;j<=b-1;j++ ) /* for (2) */
		{
			p=1; i=M-L;
			while ( i>0 ) /* p=pow(2,7-L)*j; */
			{
				p=p*2; i--;
			}
			p=p*j;
			for ( k=j;k<SAMPLENUMBER;k=k+2*b ) /* for (3) */
			{
				TR=dataR[k]; TI=dataI[k]; temp=dataR[k+b];
				dataR[k]=dataR[k]+dataR[k+b]*cos_tab[p]+dataI[k+b]*sin_tab[p];
				dataI[k]=dataI[k]-dataR[k+b]*sin_tab[p]+dataI[k+b]*cos_tab[p];
				dataR[k+b]=TR-dataR[k+b]*cos_tab[p]-dataI[k+b]*sin_tab[p];
				dataI[k+b]=TI+temp*sin_tab[p]-dataI[k+b]*cos_tab[p];
			} /* END for (3) */
		} /* END for (2) */
	} /* END for (1) */
	for ( i=0;i<SAMPLENUMBER;i++ )
	{
		DATAR[i] = dataR[i];
		DATAI[i] = dataI[i];
	}
} /* END FFT */



void FFT64(float32 dataR[SAMPLENUMBER],float32 dataI[SAMPLENUMBER])	//103,892个时钟周期
{
	int16 x0,x1,x2,x3,x4,x5,xx;
	int16 i,j,k,b,p,L;
	float32 TR,TI,temp;

	/********** following code invert sequence ************/
	for ( i=0;i<SAMPLENUMBER;i++ )
	{
		x0=x1=x2=x3=x4=x5=0;
		x0=i&0x01; x1=(i/2)&0x01; x2=(i/4)&0x01; x3=(i/8)&0x01;x4=(i/16)&0x01; x5=(i/32)&0x01;
		xx=x0*32+x1*16+x2*8+x3*4+x4*2+x5;
		dataI[xx]=dataR[i];
	}
	for ( i=0;i<SAMPLENUMBER;i++ )
	{
		dataR[i]=dataI[i]; dataI[i]=0;
	}

	/************** following code FFT *******************/
	for ( L=1;L<=M;L++ )
	{ /* for(1) */
		b=1; i=L-1;
		while ( i>0 )
		{
			b=b*2; i--;
		} /* b= 2^(L-1) */
		for ( j=0;j<=b-1;j++ ) /* for (2) */
		{
			p=1; i=M-L;
			while ( i>0 ) /* p=pow(2,7-L)*j; */
			{
				p=p*2; i--;
			}
			p=p*j;
			for ( k=j;k<SAMPLENUMBER;k=k+2*b ) /* for (3) */
			{
				TR=dataR[k]; TI=dataI[k]; temp=dataR[k+b];
				dataR[k]=dataR[k]+dataR[k+b]*cos_tab[p]+dataI[k+b]*sin_tab[p];
				dataI[k]=dataI[k]-dataR[k+b]*sin_tab[p]+dataI[k+b]*cos_tab[p];
				dataR[k+b]=TR-dataR[k+b]*cos_tab[p]-dataI[k+b]*sin_tab[p];
				dataI[k+b]=TI+temp*sin_tab[p]-dataI[k+b]*cos_tab[p];
			} /* END for (3) */
		} /* END for (2) */
	} /* END for (1) */
	for ( i=0;i<SAMPLENUMBER;i++ )
	{
		DATAR[i] = dataR[i];
		DATAI[i] = dataI[i];
	}
} /* END FFT */

void FFT32(float32 dataR[SAMPLENUMBER],float32 dataI[SAMPLENUMBER])	//103,892个时钟周期
{
	int16 x0,x1,x2,x3,x4,xx;
	int16 i,j,k,b,p,L;
	float32 TR,TI,temp;

	/********** following code invert sequence ************/
	for ( i=0;i<SAMPLENUMBER;i++ )
	{
		x0=x1=x2=x3=x4=0;
		x0=i&0x01; x1=(i/2)&0x01; x2=(i/4)&0x01; x3=(i/8)&0x01;x4=(i/16)&0x01;
		xx=x0*16+x1*8+x2*4+x3*2+x4;
		dataI[xx]=dataR[i];
	}
	for ( i=0;i<SAMPLENUMBER;i++ )
	{
		dataR[i]=dataI[i]; dataI[i]=0;
	}

	/************** following code FFT *******************/
	for ( L=1;L<=M;L++ )
	{ /* for(1) */
		b=1; i=L-1;
		while ( i>0 )
		{
			b=b*2; i--;
		} /* b= 2^(L-1) */
		for ( j=0;j<=b-1;j++ ) /* for (2) */
		{
			p=1; i=M-L;
			while ( i>0 ) /* p=pow(2,7-L)*j; */
			{
				p=p*2; i--;
			}
			p=p*j;
			for ( k=j;k<SAMPLENUMBER;k=k+2*b ) /* for (3) */
			{
				TR=dataR[k]; TI=dataI[k]; temp=dataR[k+b];
				dataR[k]=dataR[k]+dataR[k+b]*cos_tab[p]+dataI[k+b]*sin_tab[p];
				dataI[k]=dataI[k]-dataR[k+b]*sin_tab[p]+dataI[k+b]*cos_tab[p];
				dataR[k+b]=TR-dataR[k+b]*cos_tab[p]-dataI[k+b]*sin_tab[p];
				dataI[k+b]=TI+temp*sin_tab[p]-dataI[k+b]*cos_tab[p];
			} /* END for (3) */
		} /* END for (2) */
	} /* END for (1) */
	for ( i=0;i<SAMPLENUMBER;i++ )
	{
		DATAR[i] = dataR[i];
		DATAI[i] = dataI[i];
	}
} /* END FFT */

最终采用的是800KHz采样频率，32个点。由于工程中PID调节的速度有限，32个点能满足滤波要求。理论中点数越多，滤波效果越好，800KHz/32点=25kHz，表示25KHz以下的频率无法滤除，而1.6MHz中50KHz以下都无法滤除，才导致滤波效果不好
效果如下：
在这里插入图片描述
参考文章：
https://blog.csdn.net/wang_0712/article/details/80543801
http://bbs.21ic.com/icview-818068-1-1.html
https://blog.csdn.net/dreamandxiaochouyu/article/details/45392723
以上。
另：在优化代码时，确定好点数后，将M的值log(SAMPLENUMBER)/log(2)修改为确定的一个数而不是调用math库进行运算，会增添许多不必要的运算时间，这点折腾了我好一会儿。

嘿嘿哈哈过日
关注
  • 2
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
DSP28335做简单的频谱分析（fft算法）
12-17
DSP28335AD采样后做fft变换，得出频谱 根据在RAM中调试的需要，这个项目配置成"boot to SARAM".2833x引导模式 表如下显示. 常用的还有"boot to Flash"模式，当程序在RAM调试完善后就 可以将代码烧进Flash中并使用"boot to Flash"引导模式.
python 傅立叶函数_python-如何从图像中去除高频内容以进行傅立叶逆变换
weixin_34293510的博客
02-19 1052
我在opencv中看到几个文档对此进行了解释,但是我的目标是使用numpy&卑鄙的我想我必须用某种圆形来遮盖频谱的外部区域,因为我用60×60矩形遮盖了频谱的中心以进行低频滤波.但我不知道如何.我想学习在使用numpy数组进行傅立叶逆变换之前,如何从幅度谱中去除高频分量.我提供了傅里叶变换和傅里叶逆变换(用于去除低频分量)的代码.我的目标是做类似的事情,但是这次我想删除高频分量,以便能够观...
三电平有源电力滤波器 软硬件介绍 基于DSP28335
2301_78835236的博客
06-22 273
5. 数字信号处理（DSP）：这是一种处理数字信号的技术，涉及到数字信号的获取、处理、分析和控制等方面。6. 电力电子：这是研究电力系统中电力的转换和控制的学科领域。电力电子技术广泛应用于电力系统中的各种设备和系统，包括电力滤波器、变频器、逆变器等。三电平有源电力滤波器是一种用于减小电力系统中谐波和电压波动的电力滤波器。它采用有源电力电子器件来实现滤波功能，能够有效地改善电力质量。三电平有源电力滤波器主要由一个有源电力电子器件（如IGBT或MOSFET）、控制电路和滤波电路组成。
小波变换在信号去噪声中的使用
热门推荐
Richard_Cai
10-31 7万+
关于小波变换      小波变换（wavelet transform，WT）是一种新的变换分析方法,能够在时间（空间）频率的局部化分析，通过伸缩平移运算对信号（函数)逐步进行多尺度细化，最终达到高频处时间细分，低频处频率细分，能自动适应时频信号分析的要求。去噪的必要性       一般来说信号中都是带有信号的，特别是信号的采集过程中，在接收端除了获取目标信号外还会引入噪声。常见的噪声包括高斯白噪声，
【DSP】运用FFT抑制一维数据中的高频分量（Python及Java安卓实现）
weixin_45780839的博客
04-24 4454
如果已经对傅里叶变换有深刻的理解，想直接看代码，建议直接往后点。 如果和我一样是一知半解的小白，也想更深一步地了解DFT，不妨慢慢看下去，然后一起探讨噢~ 有些东西还是想了很久才想通透的，但是不知道有没有表达通透呢… FFT与DFT FFT(Fast Fourier Transformation)，快速傅里叶变换，是一种快速实现离散傅里叶变换DFT的方法。该算法也是数字信号处理里非常重要的一个算法。由于时间关系，在这篇文章中，主要还是讲运用，就先不赘述FFT的详细原理了。关于FFT的原理，如果有机会再另开篇
[DSP学习笔记]基于TMS320F28335的FFT及加窗函数实现
luoqicou的博客
01-19 2924
基于TMS320F28335，实现了FFT和加窗的操作。
TMS320F28335调用官方库进行FFT频谱分析
橙子的博客
11-11 4358
TMS320F28335调用官方库进行FFT频谱分析
DSP28335实现FFT的工程实现方法
weixin_52940637的博客
05-13 1279
对于含有控制器的DSP来实现FFT，FFT的结果反映了控制的效果，FFT的结果不是控制的目标。因此，为了保证控制效果的可观测，在不使用谐波测量仪器的前提下，直接使用控制器的一些资源，计算出控制目标的谐波含量还是一个不错的方案。在FFT的工程应用的痛点就是它的蝶形运算的循环。对于采用FPGA+DSP的控制器架构实现FFT来看，利用FPGA的特性，使用FPGA实现高精度采样，DSP仅完成FFT的解算也是一个不错的方案，这将解决DSP控制中断与高速数据采样中断的冲突，使控制器资源最大化。
[DSP学习笔记]基于TMS320F28335的FIR滤波实现
luoqicou的博客
01-13 3057
基于TMS320F28335调用官方库完成FIR滤波
FFT在DSP28335中的使用
sysu_liuyang的博客
01-27 8489
引言： 在做谐波提取的过程中，用到了FFT，由于开关频率的限制，最开始考虑的是DFT以及滑窗DFT，之后又考虑过FFT。过程中走了许多弯路，记录之！ 1.傅里叶变换理论知识 1.1傅里叶级数 引用矩阵里面基的概念，一个非周期信号，可以用泰勒级数去展开，所选取的幂次信号就是一组基底，系数则是权重；于此对应，一个周期信号，就可以选取不同频率的正余弦信号作为基底，进行表示，从而得到傅里叶级数
dsp 28335的实验报告 带滤波的AD采样
01-14
内面附带完整源码和注释，这是我们学校的28335的研究生实验课的报道，关于计算采样周期，采样信号的周期，幅值等
DSP28335 实现FFT功能 CCS工程
08-16
DSP 28335 实现FFT功能 CCS工程 将导入的工程的 CMD 文件从“28335.cmd（烧写所用 CMD 文件）”替换成“28335_RAM_lnk.cmd（仿真所用 CMD 文件）”（注意：28335.cmd 和 28335_RAM_lnk.cmd 两者只能选其一参与编译，否则编译 器将无法识别具体的操作空间而出错），然后右击工程选择“Build Project”进行编译， 编译没有错误后会在 Workspace（工作区间）的工程文件夹下的 Debug 文件夹里产生一 个.out 文件），加载这个“.out”文件后即可进行仿真操作
dspF28335_FFT
05-28
该程序是基于dsp28335编写的FFT程序，有详细的FFT实现过程，方便理解FFT基本原理
DSP 基2 FFT算法的详细代码带注释（本人用F28335平台）
06-24
本人亲写亲测的DSP 基2 FFT算法的详细代码并带详细的注释，运行平台为TMS320F28335（其实这代码与平台无关）。有问题可联系 qq 179958414。
基于dsp28335的fft_fir算法程序
06-08
该程序是利用dsp28335编写的fft和fir算法，有效实现了对方波的分析，fir算法采用了基于汉宁窗的设计
JAVA实现对FFT变换的带通滤波算法
04-18
此代码为博客文中代码，博文地址：https://blog.csdn.net/systemlsy/article/details/89373321，主要实现对JAVA的FFT（快速傅里叶变换）并对其进行带通滤波。
FIR低通滤波器 ccs运行环境
05-13
FIR低通滤波器，主程序是c语言，汇编是辅助。完全的程序，可完全运行，注意是ccs软件！
适用于DSP的fft滤波程序
03-22
适用于DSP的fft滤波程序,适合在DSP5416型号
FFT.zip_28335_dsp_dsp28335实现FFT_fft_myselfeck
09-24
一个使用DSP28335的FFT经典例子，在南京某开发板上实现。
dsp28335 fft变换
最新发布
07-27
DSP28335是一款数字信号处理器，可以进行FFT（快速傅里叶变换）操作。引用\[1\]中提到，虽然例程中没有提供FFT的例程，但是可以使用C2000 ware库中的C2000系列库来进行FFT操作。同时，引用\[2\]中介绍了DSP28335的C28X_FPU_LIB.lib库中的CFFT_f32函数，该函数用于计算复数域的FFT。该函数需要传入一个CFFT_F32_STRUCT结构体作为参数，该结构体中包含了傅里叶变换的阶数和转化因子的计算。引用\[3\]中提到，可以使用CFFT_f32_sincostable函数来计算傅里叶变换的转化因子，只需要在结构体中对stage和FFTSize进行赋值即可。因此，通过使用C2000 ware库和C28X_FPU_LIB.lib库中的函数，可以在DSP28335上进行FFT变换。 #### 引用[.reference_title] - *1* [DSP28335做FFT傅里叶变换](https://blog.csdn.net/weixin_30390075/article/details/95330151)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [DSP：关于28335的FFT](https://blog.csdn.net/Jason_nuc/article/details/81975630)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值