comb.c

TMS320C5416算法程序包。其中包括FFT

/*****************************************************************************/
/*                                                                           */
/* FILENAME                                                                  */
/* 	 comb.c                                                                  */
/*                                                                           */
/* DESCRIPTION                                                               */
/*   TMS320C5416 DSK.                                                        */
/*   Comb filters of variable length.                                        */
/*                                                                           */
/* REVISION                                                                  */
/*   Revision: 1.00	                                                         */
/*   Author  : Richard Sikora                                                */
/*---------------------------------------------------------------------------*/
/*                                                                           */
/* HISTORY                                                                   */
/*   Revision: 1.00                                                          */
/*   1st December 2002. Created by Richard Sikora.                           */
/*                                                                           */
/*****************************************************************************/

#include <stdio.h>

#define MAXIMUM_SIZE 96

#define FEEDBACK_PERCENTAGE 20000

/*****************************************************************************/
/* comb_notch_filter()                                                       */
/*---------------------------------------------------------------------------*/
/*                                                                           */
/* Implemented using a straight buffer. Uses an FIR configuration.           */
/*                                                                           */
/* INPUTS:  Input channel.                                                   */
/*          Number of delay elements                                         */
/*                                                                           */
/* RETURNS: Output of comb filter.                                           */
/*                                                                           */
/*****************************************************************************/

signed int comb_notch_filter ( signed int input, unsigned int size)
{
 static signed int delay_elements[MAXIMUM_SIZE];
 long output;   
 signed int i;

 if ( size < 2)
   {
     size = 2;      /* Minimum of two delay elementa */
   }
 else if ( size > ( MAXIMUM_SIZE - 1) )
   {
     size = MAXIMUM_SIZE - 1 ; /* Range limit to maximum of N elements */ 
   }  

 /* Output = input + longest delayed input */
 output = input + delay_elements[size-1];

 /* Shuffle values along one place */
 for ( i = size - 1; i > 0 ; i--)
   {
     delay_elements[i] = delay_elements[i-1];
   }

 /* Put input into start of delay_elements */
 delay_elements[0] = input;

 /* Scale output */
 return ( (signed int)(output) );  
}

/*****************************************************************************/
/* comb_notch_filter_circular()                                              */
/*---------------------------------------------------------------------------*/
/*                                                                           */
/* Implemented using a circular buffer. Uses an FIR configuration.           */
/*                                                                           */
/* INPUTS:  Input channel.                                                   */
/*          Number of delay elements                                         */
/*                                                                           */
/* RETURNS: Output of comb filter.                                           */
/*                                                                           */
/*****************************************************************************/

signed int comb_notch_filter_circular ( signed int input, unsigned int size)
{
 static signed int delay_elements[MAXIMUM_SIZE];
 long output;   
 static unsigned int offset = 0;

 if ( size < 2)
   {
     size = 2;      /* Minimum of two delay elementa */
   }
 else if ( size > ( MAXIMUM_SIZE - 1) )
   {
     size = MAXIMUM_SIZE - 1 ; /* Range limit to maximum of N elements */ 
   }  

 /* Output = input + longest delayed input */
 output = input + delay_elements[offset];

 /* Overwrite oldest element with newest */
 delay_elements[offset] = input;

 /* Point to next element along for next time */
 
 if ( offset < size - 1)
  {
    offset++; /* Not at end of buffer. Increment */
  }
 else
  {
    offset = 0; /* At end of buffer or out of range. */
  } 

 /* Scale output */
 return ( (signed int)(output) );  
}

/*****************************************************************************/
/* comb_bandpass_filter()                                                    */
/*---------------------------------------------------------------------------*/
/*                                                                           */
/* Implemented using a straight buffer. Uses an IIR configuration.           */
/*                                                                           */
/* INPUTS:  input channel.                                                   */
/*          number of delay elements                                         */
/*                                                                           */
/* RETURNS: Output of comb filter.                                           */
/*                                                                           */
/*****************************************************************************/

signed int comb_bandpass_filter ( signed int input, unsigned int size)
{
 static signed int delay_elements[MAXIMUM_SIZE];
 signed long output;   
 signed int i;

 if ( size < 2)
   {
     size = 2;      /* Minimum of two delay elementa */
   }
 else if ( size > ( MAXIMUM_SIZE - 1) )
   {
     size = MAXIMUM_SIZE - 1 ; /* Range limit to maximum of N elements */ 
   }  

 /* Output = input + longest delayed input */
 output = input + ((long)(delay_elements[size-1] * FEEDBACK_PERCENTAGE) >> 15);

 /* Range limit in event of out of range */
 if ( output > 32767 )
   {
     output = 32767;
   }
 else if ( output < -32767 )
   {
     output = -32767;
   } 

 /* Shuffle values along one place */
 for ( i = size - 1 ; i > 0 ; i--)
   {
     delay_elements[i] = delay_elements[i-1];
   }

 /* Put output into start of delay_elements */
 delay_elements[0] = (signed int) ( output ) ;

 /* Scale output */
 return ( (signed int) ( output >> 1) ); 
}

/*****************************************************************************/
/* comb_bandpass_filter_circular()                                           */
/*---------------------------------------------------------------------------*/
/*                                                                           */
/* Implemented using a circular buffer. Uses an IIR configuration.           */
/*                                                                           */
/* INPUTS:  input channel.                                                   */
/*          number of delay elements                                         */
/*                                                                           */
/* RETURNS: Output of comb filter.                                           */
/*                                                                           */
/*****************************************************************************/

signed int comb_bandpass_filter_circular ( signed int input, unsigned int size)
{
 static signed int delay_elements[MAXIMUM_SIZE];
 long output;   
 static unsigned int offset = 0;

 if ( size < 2)
   {
     size = 2;      /* Minimum of two delay elementa */
   }
 else if ( size > ( MAXIMUM_SIZE - 1) )
   {
     size = MAXIMUM_SIZE - 1 ; /* Range limit to maximum of N elements */ 
   }  

 /* Output = input + longest delayed input */
 output = input + ((long)(delay_elements[offset] * FEEDBACK_PERCENTAGE) >> 15);

 /* Range limit in event of out of range */
 if ( output > 32767 )
   {
     output = 32767;
   }
 else if ( output < -32767 )
   {
     output = -32767;
   }  

 /* Overwrite oldest element with newest */
 delay_elements[offset] = (signed int)( output ) ;

 /* Point to next element along for next time */
 
 if ( offset < size - 1)
  {
    offset++; /* Not at end of buffer. Increment */
  }
 else
  {
    offset = 0; /* At end of buffer or out of range. */
  } 
 
 /* Return output */
 return ( (signed int) (output >> 1) ); 
}

/*****************************************************************************/
/* End of comb.c                                                             */
/*****************************************************************************/