C语言实现DSP篇——线性卷积、快速傅里叶变换等

已于 2023-01-19 15:37:06 修改
阅读量2.7k 收藏 57
点赞数 6
分类专栏： C/C++ 文章标签： DSP 数字信号处理 c语言
于 2021-12-01 23:02:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wayne6515/article/details/121666949
版权

文章目录

线性卷积：

/** Program for convolve **/

#include <math.h>

int N1,N2;		/*输入数组长度*/
int n;			/*输出数组长度*/
int m,i,k;
float x[20];
float h[20];
float y[20];	/*输出数组*/

main()
{	
   N1=10;                           /* x 长度*/
   N2=10;                           /* h 长度*/
   n=N1+N2-1;                      /* 输出 y 的长度*/  

   for(i=0;i<20;i++)               /* 初始化数组 */
   {
    
     x[i]=0;
     h[i]=0;
     y[i]=0;
    
   }

   for(i=0;i<n;i++)		/* 给x数组赋值 */              
   {
      if(i<N1)
      {
         x[i]=i;
  	  }
      
      else
      {
         x[i]=0;
      }
   }

   for(i=0;i<=n;i++)	/* 给h数组赋值 */
   {
      if(i<N2)
      {
         h[i]=1;
      }
      
      else
      {
         h[i]=0;
      }
   }

   for(i=0;i<n;i++)  	/* 计算卷积 */
   {
   	  for (k=0;k<=i;k++)
   	  	y[i]=y[i]+h[k]*x[i-k];    /* */      
   }
}

N点FFT：

/* Program for FFT */

#include <math.h>
#include <stdio.h>


const float pi=3.1415926;
int N;							/* FFT点数 */
float x_re[300], x_im[300];	 	/* 输入信号序列 */
float y_re[300], y_im[300];		/* 输出频谱序列 */
float w_re, w_im;				/* 蝶形因子 */
int m;							/* 蝶形运算的级数,即Log2(N) */
float t_re, t_im, v_re, v_im;  	/* 临时变量 */
int j,i,k,f,n;   				
int a, b, c;


main()
{ 	
	N=64;

	/* 初始化数据空间 */
	for(i=0; i<300; i++)
	{
		x_re[i]=0;
		x_im[i]=0;
	}
	
	/* 设定输入信号序列为单边指数函数 */
	/* 考虑到实际衰减很快，因此可以忽略后面大半部分数值 */
	for(i=0;i<=N;i++)
	{
		 x_re[i]=exp(-i);
		 x_im[i]=0;		
	}
	
	/* 复制到输出数组 */
	for(i=0; i<300; i++)
	{
		y_re[i]=x_re[i];
		y_im[i]=x_im[i];
	}

	/* 用雷德算法对输入信号序列进行倒序重排 */
  	j=0;
  	for(i=0;i<N;i++)
  	{	
  		if(i<j)
  		{ 
  		  t_re=y_re[j]; 
  		  t_im=y_im[j]; 
  		  y_re[j]=y_re[i]; 
  		  y_im[j]=y_im[i];
  		  y_re[i]=t_re;
		  y_im[i]=t_im;
  		}
  		k=N/2;
  		while((k<=j)&(k>0))
  		{ 
  		  j=j-k; 
  		  k=k/2;
  		}
  		j=j+k;
    }
    
    /* 计算蝶形运算的级数log2(N) */
	f=N;
	for(m=1; (f=f/2)!=1; m++);
	
    
    /*** FFT ***/
    for(n=1; n<=m; n++)
    {   
    	a=1;				/* a=2的n次方 */
    	for(i=0;i<n;i++)
    		a=a*2;
    	
    	b=a/2;
    	
    	v_re=1.0; 			/* 蝶形因子 */
    	v_im=0.0;
    	w_re=cos(pi/b);		
    	w_im=-sin(pi/b);
    	
    	for(j=0;j<b;j++)	/* 蝶形运算 */
    	{
    		for(i=j;i<N;i=i+a)
    		{
    			c=i+b;
   
       			t_re=y_re[c]*v_re-y_im[c]*v_im;
    			t_im=y_re[c]*v_im+y_im[c]*v_re;
    			
    			y_re[c]=y_re[i]-t_re;
    			y_im[c]=y_im[i]-t_im;
    			
    			y_re[i]=y_re[i]+t_re;
    			y_im[i]=y_im[i]+t_im;
    		}
    		
    		t_re=v_re*w_re-v_im*w_im;
    		t_im=v_re*w_im+v_im*w_re;
    		
    		v_re=t_re;
    		v_im=t_im;
    	}
    }
    
}

相关估计：

/** (Ex5_2.c)  of (Project Ex5_2 )**/
/** Program for Correlation Algorithm **/

#include "math.h"

float x[50],y[50];   /* 两个输入数组 */
float r[50];         /* 输出的相关函数估计值 */
int mode;	         /* 选择参数：0-无偏相关估计;1-有偏相关估计*/
int m;      		 /* 输出数组长度 */
int n;               /* 参与估计的输入数组长度 */
int k;				 /* 相关系数的阶数 */
int i,j;			 /* 将要用到的循环变量 */
float sum;           /* 将要用到的变量 */


main()
{  /* 参数初始化 */  
   mode=0; 
   m=10;                        
   n=40;
   k=0;
   sum=0;

   for(i=0;i<50;i++)
   {
      x[i]=0;
      y[i]=0;
      r[i]=0;   
   }

   for(i=0;i<n;i++)
   {
      x[i]=1;
	  y[i]=i;
   }

   for(k=0;k<m;k++)
   {
      sum=0;

      for(j=0;j<n-k;j++)  /* 对x[j+k]*y[j]求和，j从1到n-k-1 */
      {
         sum=sum+x[j+k]*y[j];    
      }

      if(mode==0)        /* 无偏估计 */
      {
         r[k]=sum/(float)(n-k);
      }

      else 				/* 有偏估计 */
      {
         r[k]=sum/(float)n;
      }
   }    
}

离散余弦变换：

/* Program for DCT */

#include <math.h>
#include <stdio.h>


const float pi=3.1415926;
int N;							/* FFT点数 */
int N2;							/* N2=2*N */
float x_re[300], x_im[300];	 	/* 输入信号序列 */
float y_re[300], y_im[300];		/* 输出频谱序列 */
float ck[300];					/* 离散余弦变换系数 */
float w_re, w_im;				/* 蝶形因子 */
int m;							/* 蝶形运算的级数,即Log2(N) */
float t_re, t_im, v_re, v_im;  	/* 临时变量 */
int j,i,k,f,n;   				
int a, b, c;


main()
{ 	
	N=8;
	N2=2*N;

	/* 初始化数据空间 */
	for(i=0; i<300; i++)
	{
		x_re[i]=0;
		x_im[i]=0;
		ck[i]=0;
	}
	
	/* 设定输入信号序列为单边指数函数 */
	/* 考虑到实际衰减很快，因此可以忽略后面大半部分数值 */
	for(i=0;i<N;i++)
	{
		 x_re[i]=exp(-i);
		 x_im[i]=0;		
	}
	
	/* 对信号序列进行延拓 */
	for(i=N;i<N2;i++);
	
	/* 复制到输出数组 */
	for(i=0; i<300; i++)
	{
		y_re[i]=x_re[i];
		y_im[i]=x_im[i];
	}

	/* 用雷德算法对输入信号序列进行倒序重排 */
  	j=0;
  	for(i=0;i<N2;i++)
  	{	
  		if(i<j)
  		{ 
  		  t_re=y_re[j]; 
  		  t_im=y_im[j]; 
  		  y_re[j]=y_re[i]; 
  		  y_im[j]=y_im[i];
  		  y_re[i]=t_re;
		  y_im[i]=t_im;
  		}
  		k=N2/2;
  		while((k<=j)&(k>0))
  		{ 
  		  j=j-k; 
  		  k=k/2;
  		}
  		j=j+k;
    }
    
    /* 计算蝶形运算的级数log2(N) */
	f=N2;
	for(m=1; (f=f/2)!=1; m++);
	
    
    /*** FFT ***/
    for(n=1; n<=m; n++)
    {   
    	a=1;				/* a=2的n次方 */
    	for(i=0;i<n;i++)
    		a=a*2;
    	
    	b=a/2;
    	
    	v_re=1.0; 			/* 蝶形因子 */
    	v_im=0.0;
    	w_re=cos(pi/b);		
    	w_im=-sin(pi/b);
    	
    	for(j=0;j<b;j++)	/* 蝶形运算 */
    	{
    		for(i=j;i<N2;i=i+a)
    		{
    			c=i+b;
   
       			t_re=y_re[c]*v_re-y_im[c]*v_im;
    			t_im=y_re[c]*v_im+y_im[c]*v_re;
    			
    			y_re[c]=y_re[i]-t_re;
    			y_im[c]=y_im[i]-t_im;
    			
    			y_re[i]=y_re[i]+t_re;
    			y_im[i]=y_im[i]+t_im;
    		}
    		
    		t_re=v_re*w_re-v_im*w_im;
    		t_im=v_re*w_im+v_im*w_re;
    		
    		v_re=t_re;
    		v_im=t_im;
    	}
    }
    
    /* 提取实部作为离散余弦变换的系数 */
    
   	for(i=0;i<N;i++)
   	{
   		ck[0]=ck[0]+x_re[i];
   	}
   	ck[0]=ck[0]/sqrt((float)N);
   	
    for(i=1;i<N;i++)
    {
    	ck[i]=cos((i*pi)/N2)*y_re[i]-sin(-(i*pi)/N2)*y_im[i];
    	ck[i]=sqrt(2.0/N)*ck[i];
    }
}

IIR滤波器：

/* Program for IIR */

#include <math.h>
#include <stdlib.h>

#define pi 3.1415925

float fp,fr,fs;		/* 通带截止频率、阻带截止频率、抽样频率 */
float ap, ar;		/* 容限(dB) */
float ptr_a[50],ptr_b[50]; /* 系统函数H(z)的分母系数和分子系数 */
float hwdb[50];				/* 幅频响应值 */
float b_real[50],b_imag[50];
float b1_real[50],b1_imag[50],b2_real[50],b2_imag[50];
float d[50],e[50],g[50];
float f1[2],f2[2],h[50];


/* 函数定义 */

void bcg(float ap,float as,float wp,float ws,int *n,float *h)                     /*求H(s)分母系数*/
{
   int i,k;
   float a,p,wc,cs1,cs2;
   float c;

   c=(pow(10.0,0.1*as)-1.0)/(pow(10.0,0.1*ap)-1.0);
   *n=(int)(fabs(log10(c)/log10(ws/wp)/2.0)+0.99999);                                     /*求N*/
   wc=wp;
   a=pow(wc,(double)(*n));

   for(i=0;i<*n;i++)                           /*求极点*/
   {
      p=pi*(0.5+(2.0*i+1.0)/(2.0*(*n)));
      b_real[i]=wc*cos(p);
      b_imag[i]=wc*sin(p);
   }     

   b1_real[0]=-(b_real[0]);
   b1_imag[0]=-(b_imag[0]);
   b1_real[1]=1.0;
   b1_imag[1]=0.0;

   if(*n!=1)
   {
      for(i=1;i<*n;i++)
      {
         for(k=0;k<i;k++)
         {
            cs1=b1_real[k]-b1_real[k+1]*b_real[i];
            cs2=b1_imag[k]-b1_real[k+1]*b_imag[i];
            b2_real[k+1]=cs1+b1_imag[k+1]*b_imag[i];
            b2_imag[k+1]=cs2-b1_imag[k+1]*b_real[i];
         }

         b2_real[0]=-(b1_real[0]*b_real[i]-b1_imag[0]*b_imag[i]);
         b2_imag[0]=-(b1_real[0]*b_imag[i]+b1_imag[0]*b_real[i]);
         b2_real[i+1]=b1_real[i];
         b2_imag[i+1]=b1_imag[i];

         for(k=0;k<=i+1;k++)
         {
            b1_real[k]=b2_real[k];
            b1_imag[k]=b2_imag[k];
            b2_real[k]=0.0;
            b2_imag[k]=0.0;
         }
      }
   }

   for(i=0;i<=*n;i++)
      h[i]=b1_real[i]/a;
}

void pnpe(float *a,int m,int n,float *b,int *mn)                               
{	
	/*多项式相乘的展开系数*/
   
   int i,j,k,nk;
   float c[50];

   *mn=m*n;

   for(i=0;i<*mn+1;i++)
   {
      c[i]=0;
      b[i]=0;
   }

   if(n==0)
      b[0]=1.00;
   else
   {
      for(i=0;i<=m;i++)
         b[i]=a[i];
      if(n==1)
      {
         for(i=0;i<=m;i++)
            b[i]=a[i];
      }
      else
      {
         nk=m+1;
         for(i=1;i<n;i++)
         {
            for(j=0;j<=m;j++)
            {
               for(k=0;k<nk;k++)
                  c[k+j]+=a[j]*b[k];
            }

            nk+=m;

            for(k=0;k<nk;k++)
            {
               b[k]=c[k];
               c[k]=0;
            }
         }
      }
   }
}



void ypmp(float *a,int m,float *b,int n,float *c,int *mn)
{
   int i,j;

   *mn=m+n;

   for(i=0;i<*mn+1;i++)
      c[i]=0;

   for(i=0;i<=m;i++)
   {
      for(j=0;j<=n;j++)
         c[i+j]+=a[i]*b[j];
   }
}


void bsf(float *c,int ni,float *f1,float *f2,int nf,float *ptr_a,float *ptr_b,int *no)
{
   
   int i,j,nd,ne,ng;

   /*计算分子系数*/
   pnpe(f2,nf,ni,ptr_a,no);                                            

   for(i=0;i<*no+2;i++)
      ptr_b[i]=0;

   /*计算分母系数*/
   for(i=0;i<=ni;i++)                                                           
   {
      pnpe(f1,nf,i,d,&nd);
      pnpe(f2,nf,ni-i,e,&ne);
      ypmp(d,nd,e,ne,g,&ng);

      for(j=0;j<=ng;j++)
         ptr_b[j]+=c[i]*g[j];
   }
}


//*** 主函数 ***//
main()
{
   int N,nf,ns,nz,i,k;
   float hwdb1_real,hwdb1_imag;	/* 系统函数的分子部分 */
   float hwdb2_real,hwdb2_imag; /* 系统函数的分母部分 */
   float wp,ws,jw,amp1,amp2;

   N=50;

   /* 初始化数据空间 */
   for(i=0;i<50;i++)
   {
      b_real[i]=0;
      b_imag[i]=0;
      b1_real[i]=0;
      b1_imag[i]=0;
      b2_real[i]=0;
      b2_imag[i]=0;
      d[i]=0;
      e[i]=0;
      g[i]=0;
      ptr_a[i]=0;
      ptr_b[i]=0;
      hwdb[i]=0;
   }

	/* 滤波器设计参量 */
   fp=100;	/* Hz */
   fr=300;
   fs=1000;
   ap=3;	/* db */
   ar=20;
   wp=tan(pi*fp/fs);	/* 双线性变换 */
   ws=tan(pi*fr/fs);
   *f1=-1.0;
   *(f1+1)=1.0;
   *f2=1.0;
   *(f2+1)=1.0;
   nf=1;
   
   /* 求系统函数 H(s) */
   bcg(ap,ar,wp,ws,&ns,h);            
   
   /* 由H(s)转换成H(z) */
   bsf(h,ns,f1,f2,nf,ptr_b,ptr_a,&nz);           

   /* 用exp(jw)代替z */
   for(k=0;k<N;k++)
    {
      jw=k*pi/N;
      hwdb1_real=0;  hwdb1_imag=0;
      hwdb2_real=0;  hwdb2_imag=0;

      for(i=0;i<=nz;i++)
      {
		/* 分子 */      
         hwdb1_real+=ptr_b[i]*cos(i*jw);
         hwdb1_imag+=ptr_b[i]*sin(i*jw);
        /* 分母 */
         hwdb2_real+=ptr_a[i]*cos(i*jw);
         hwdb2_imag+=ptr_a[i]*sin(i*jw);
      }
      
      /* 求幅频响应 */
      amp1=(pow(hwdb1_real,2)+pow(hwdb1_imag,2));
      amp2=(pow(hwdb2_real,2)+pow(hwdb2_imag,2));          
      hwdb[k]=10*log10(amp1/amp2);
      if(hwdb[k]<-200)  hwdb[k]=-200;        
   }
}

LMS自适应滤波：

/* Program for LMS */

#include <math.h>

#define pi 3.1415926

float x[500];		/* 输入信号序列 */
float y[500];		/* 输出信号序列 */
float d[500];		/* 期望输出序列 */
float e[500];		/* 输出误差序列, e(n)=d(n)-y(n) */
float w[50];		/* 横向滤波器系数 */
int L;				/* 实际信号长度 */
int N;				/* 横向滤波器级数 */
int i, j;
float u;			/* 梯度算法步长 */


main()
{ 
   	L=500;
   	N=5;
	u=0.00001;

   	/* 初始化数据空间 */
   	for(i=0;i<500;i++)
   	{ 
   		x[i]=0;
      	d[i]=0;
      	e[i]=0;
      	y[i]=0;
   	}                                                                   

   	/* 设定输入信号为正弦信号
	   期望输出设为比实际输入超前两个单位时间的信号 */
   	for(i=0;i<L;i++)
   	{ 
      	x[i]=(float)10*sin(pi*i/20);
      	d[i]=x[i-2];
   	}

   	/* 初始化滤波器系数 */
   	for(i=0;i<N;i++)
    {  	
    	w[i]=0;
    }

	/* 梯度算法 */
   	for(i=N;i<L;i++)
   	{        
      /*sum=0;*/
      	for(j=0;j<N;j++)
         	y[i]=y[i]+w[j]*x[i-j];
      /*y[i]=sum;*/
      	e[i]=d[i]-y[i];		/* 计算误差 */
      	
      	for(j=0;j<N;j++)	/* 根据误差修正滤波器系数 */
         	w[j]=w[j]+2*u*e[i]*x[i-j];
   }   
}

窗函数法设计FIR滤波器：

/** Program to design an FIR **/

#include "math.h"

float hd[51];	/* 理想的冲击响应系数序列 */
float h[51];	/* 加窗后的冲击响应系数序列 */
float w[51];	/* 窗函数的离散值序列 */
float db[300];  /* 幅度响应数组（对数值）�*/
float pi;		/* 圆周率pi */
float wc;		/* (截止频率/pi) */
int n;			/* 窗函数序列的长度，也是加窗后的响应序列的长度 */
int m;			/* 选择参数(1-5):选择不同的窗函数 */
int l;			/* l>>n */
float im,re;
float a,b,p,wf,d;
int k,i;

main()
{
   	  /* 参数初始化 */
      for(i=0;i<51;i++)
      {		
      	hd[i]=0;
      	h[i]=0;
      	w[i]=0;
      }

	  for(i=0;i<300;i++)
      {		
      	db[i]=0;
      }
            
      m=5;
      n=21;    /* n<=51, 为奇数 */
      wc=0.2;  /* wc=0.10-0.90 */
      l=300;   
      a=(n-1)/2;
      pi=4.0*atan(1.0);

      for(i=0;i<n;i++)
      {	/* 理想矩形函数（频域）的时域形式 */
         if(i==a)
            hd[i]=wc;
         else
         {
            b=i-a;
            hd[i]=sin(pi*b*wc)/(pi*b);
         }
      }

      switch(m)  /* 根据m的值选择不同的窗函数 */
      {
		/* m=1时用矩形窗 */
         case 1:    			
            for(i=0;i<n;i++)
            w[i]=1.0;  			
         break;
         
		/* m=2时用三角窗(巴特莱特窗) */
         case 2:   				
            for(i=0;i<n;i++)
            {
               if(i>=a)
               w[i]=2.0-2.0*i/(n-1);
               else
               w[i]=2.0*i/(n-1);
            }
         break;


		/* m=3时用汉宁窗 */
         case 3:   			
            for(i=0;i<n;i++)
              w[i]=0.5*(1.0-cos(2.0*pi*i/(n-1)));
            break;


		/* m=4时用汉明窗 */
         case 4:
            for(i=0;i<n;i++)
              w[i]=0.54-0.46*cos(2.0*pi*(float)i/(n-1));
            break;


		/* m=5时用布莱克曼窗 */
         case 5:
            for(i=0;i<n;i++)
              w[i]=0.42-0.5*cos(2.0*pi*i/(n-1))+0.08*cos(4.0*pi*i/(n-1));
         break;
      }


      for(i=0;i<n;i++)
         h[i]=hd[i]*w[i];  /* 对理想冲击响应加窗（时域相乘） */

      p=pi/l;

      
      /* 对加窗后的响应序列进行傅里叶变换，观察其幅频响应 */
      for(k=0;k<=l-1;k++)
      {
         wf=(pi*k)/l;
         re=0.0;
         im=0.0;
         
         for(i=0;i<n;i++)
         {
            re=re+h[i]*cos((float)i*wf);
            im=im+h[i]*sin((float)i*wf);
         }
         
         d=sqrt(pow(re,2)+pow(im,2)); /*求模(幅度)*/
         db[k]=20.0*log10(d);         /*转换为对数表示形式*/
      }
}
鹅毛在路上了
关注
  • 6
    点赞
  • 踩
  • 57
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Juanji.rar_C语言线性卷积_线性卷积
09-21
完整的用C语言实现线性卷积代码，运行环境：Visual C++ 6.0
DSP仿真：快速卷积的DSP实现
05-13
快速卷积的DSP实现； 含word报告、实验代码程序； 亲测可行、有详细注释和MATLAB仿真
DSP课程设计——卷积编译码的DSP实现（含完整报告和代码）
11-08
课题名称:卷积编译码的DSP实现 课题要求： （1）系统硬件设计； （2）卷积编译码MATLAB仿真； （3）卷积编译码DSP实现；
快速傅里叶变换和卷积算法（努斯鲍默）pdf
01-08
快速傅里叶变换和卷积算法（努斯鲍默）快速傅里叶变换和卷积算法（努斯鲍默）
线性卷积
热门推荐
xiahouzuoxin
11-22 1万+
==================== 持续更新，敬请指正 ================= 1. 线性卷积的基本理论 线性卷积是对线性移不变（LSI）系统的输入输出关系的描述，体现系统的特性。 线性卷积的表达式为 一般情况，现实的系统为因果系统，有k 此时输出y(n)也为因果信号。 若x(n)是一个N点序列，h(n)是一个m点序列，
【DSP】基于c语言的线性卷积、循环卷积计算器
最新发布
yuzexuan666的博客
04-06 253
为了直观理解线性卷积和循环卷积的联系，以及方便自己计算，于是结合gpt有了这段程序。
写出DSP上实现FFT算法的C语言主程序；
weixin_42594427的博客
02-09 129
以下是实现FFT算法的C语言代码： #include <math.h> #include <complex.h> #define N 128 // 数组长度 void FFT(double complex *x, int n) { int i, j, k, m; double complex w, t; for (m = n; m >= 2...
DSP操作教程 4-7 快速傅立叶变换（FFT）算法（CCS显示）
Tronlongtech的博客
09-20 1350
在计算机上进行的DFT，使用的输入值是时域的信号值，输入采样点的数量决定了转换的计算规模。FFT和FFT 逆变换函数中的第五个参数brev是指向包含64个表项的位反转表的指针，因此程序中需要提供64个表项，程序中的位反向表是计算出来的，可以通过代码提前转换的。离散傅里叶变换作为信号处理中最基本和最常用的运算，在信号处理领域占有基础性的地位，如果直接按照离散傅里叶变换的公式进行计算，求出N点X(k)需要N^2次复数运算、N(N-1)次复数加法，当N很大时，运算量是非常大的，这对于实时处理是无法接受的。
【DSP实验】快速卷积的DSP实现（Visual DSP++仿真实验）
点赞的都能无bug通过！
05-13 1335
快速卷积实现思路 序列x(n)和h(n)的长差不多，设x(n)的长为N_1，h(n)的长为N_2，则 为使两有限长序列的线性卷积可用其循环卷积代替而不发生混叠，必须选择循环卷积长度N≥N_1+N_2-1，若采用基2-FFT完成卷积运算，要求N=2^m（m为整数） 用补零方法使x(n)和h(n)变成列长为N的序列 用FFT计算x(n)和h(n)的N点离散傅里叶变换 完成X(k)和H(k)乘积，Y(k)=X(k)H(k)  用FFT计算Y(k)的离散傅里叶反变换得 7. 此外，为防止当两个卷积项
DSP-快速傅里叶变换（FFT）
vizio.blog.csdn.net
11-19 2079
DSP-快速傅里叶变换（FFT）
C语言实现利用分段保留计算卷积+线性卷积+圆周卷积
08-07
利用C语言实现分段保留法计算卷积，直接计算线性卷积，圆周卷积，代码能够在VS2010中正确运行
DSP day7：第二、三、四、五、六章总集篇
jieyannn的博客
10-26 855
CHAPTER 2 1.给定差分方程表征的系统，已知y[n0]，输入x[n]=f(n)，求系统的输出y[n] 2.给定差分方程表征的系统，求系统的冲激响应 3.给定系统框图，求系统的冲激响应 4.给定输出序列y[n]，系统序列h[n]，求输入序列x[n] 5.给定y[n]=f(sinω,cosω)（y[n]由sin和cos组成），求基波周期N CHAPTER 3 1.给定h[n],求DTFT H...
设计一个三阶巴特沃斯滤波器_用双线性变换法设计一个3阶Butterworth数字带通滤波器...
weixin_26731219的博客
12-24 1678
展开全部这是C语言的实现形式，可以直接使用的：/******************************************************************************//* 3rd Order Band Pass Butterworth *//*双线性变换 (S域 --&g...
双线性变换c语言实现,[转载]双线性变换（Bilinear transform）
weixin_39615402的博客
05-22 516
来源：http://en.wikipedia.org/wiki/Bilinear_transform双线性变换(Bilinear transform)The bilinear transform (also known as Tustin'smethod) is used in digital signal processing anddiscrete-time control theory to...
DSP卷积算法
qq_36159785的博客
09-07 5611
卷积和（简称卷积）是信号处理中常用的算法之一。数字卷积运算通常采用两种方法：线性卷积和圆卷积。为了能使卷积运算在C54x系列DSP上的实现方法，首先要对数字卷积的基本概念作深入了解。使大家从根本上掌握卷积的实现方法，我们以模拟信号的卷积和数字信号的卷积为主，以及他们在C54x系列DSP上的实现方法。 1．卷积的基本原理和公式 卷积和：Y(n)= ∑X(m)H(n−m)=X(n)*H(n)
stm32 adc输入电压范围_使用STM32提供的DSP库进行FFT（附详细代码）
weixin_39946767的博客
11-20 1275
最近，因为项目需要在 STM32F103系列处理器上，对采集的音频信号进行 FFT运算，然而 STM32F103毕竟不是 STM32F4系列的处理器，对于一般的 FFT运算程序还是比较缓慢的。幸亏官方提供了针对FFT的官方库，但是去官网找了半天居然找不到那个库的下载，好像官方早就把那个库下架了，估计是为了给带DSP指令集的F4系列让路。然后就只好从别人的项目中把这个官方库给扒出来了……下...
快速傅里叶变换(FFT)c语言实现
AlepH_Sin的博客
01-01 7407
按时间抽取基2FFT，C语言实现与详解
DSP28335做FFT傅里叶变换
weixin_30390075的博客
09-20 2892
1. 看了一下例程，居然没有FFT的例程，难道这个DSP28335不能做FFT吗？对了C2000系列是有C2000 ware这个库的。方便很多，不过目前不确定在C5000上运行的FFT能直接迁移到DSP28335上行不？测试了一下，是可以的，因为都是用的math.h，下面的一些正弦函数基本一样的 2. 硬件简介，其中DSP28335和TLV320AIC23B之间使用I2C接口进行寄存器配置，...
【DSP】DSP5509A的FFT算法实现（附：完整代码及疑点解惑）
Yngz_Miao的博客
12-10 1万+
傅里叶变换及FFT原理 说起傅里叶变换，每个人第一反应都是从时域转换到频域的手段，如下图所示： 但除了这一点之外呢？原理呢，推导呢？大概都是一头雾水…… 而FFT并不是一种新的变换，它是离散傅立叶变换（DFT）的一种快速算法。 DFT的算法速度： 由于我们在计算DFT时一次复数乘法需用四次实数乘法和二次实数加法；一次复数加法则需二次实数加法。每运算一个 X（k）需要 4N 次复数乘法...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

鹅毛在路上了

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值