adaptive_filter.c

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

/*****************************************************************************/
/*                                                                           */
/* FILENAME                                                                  */
/* 	adaptive_filter.c                                                        */
/*                                                                           */
/* DESCRIPTION                                                               */
/*   Using an adaptive filter to identify a waveform from the analog to      */
/*   digital converter (ADC) and compare it with a reference waveform        */
/*   generated from a table.                                                 */
/*                                                                           */
/* REVISION                                                                  */
/*   Revision: 1.00	                                                         */
/*   Author  : Richard Sikora                                                */
/*---------------------------------------------------------------------------*/
/*                                                                           */
/* HISTORY                                                                   */
/*   Revision 1.00                                                           */
/*   6th April 2002. Created by Richard Sikora.                              */
/*                                                                           */
/*****************************************************************************/


/*****************************************************************************/
/* Constants                                                                 */
/*---------------------------------------------------------------------------*/
/* Here N is number of elements in adaptive filter.                          */
/* BETA is the amount of the output used for feedback to determine the new   */
/* filter weights. 56 represents 56/32767 i.e. 0.002                         */
/* We could also approximate 0.002 to 1/512 i.e. divide by 2 ^ 9             */
/*****************************************************************************/

#define N 16                                          
#define BETA 560

/*****************************************************************************/
/* Variables                                                                 */
/*---------------------------------------------------------------------------*/
/* Two arrays are required. One to contain the input samples and the other   */
/* to contain the weights.                                                   */
/*                                                                           */
/*****************************************************************************/

static signed int X[N];  /* Array to hold input samples */
static signed int W[N];  /* Weights (adaptive filter coefficients)*/


/*****************************************************************************/
/* adaptive_filter_initialize()                                              */
/*****************************************************************************/
/*                                                                           */
/* Start with all inputs and adaptive filter coefficients at zero.           */
/*                                                                           */
/*****************************************************************************/
                                                                               
void adaptive_filter_initialize(void)
{
 unsigned int i;
 
 for ( i = 0 ; i < N ; i++)
   {
      W[i] = 0;
      X[i] = 0;
   } 


}                                                                               
                                                                               

/*****************************************************************************/
/* adaptive_filter()                                                         */
/*---------------------------------------------------------------------------*/
/*                                                                           */
/* INPUT 1: desired (or reference) waveform.                                 */
/* INPUT 2: input signal (unknown) to be compared with the reference.        */
/*                                                                           */ 
/* RETURNS: Filter output y in high word. Error in low word                  */
/*                                                                           */
/*****************************************************************************/

  
signed long adaptive_filter( signed int desired, signed int latest_measurement)
{
  signed int i;
  signed long y;            /* Output of adaptive filter */
  signed long difference;  
  static signed int error = 0; /* Difference between desired (reference) and actual. */

  /* Shuffle first and update */

  for ( i = N-1 ; i > 0 ; i--)
    {
      X[i] = X[i-1];
    }

  X[0] = latest_measurement;
 
  difference = (long) (error * BETA);
  
  error = (signed int) (difference >> 15); /* Update error */
 
  y = 0; /* Start accumulation at zero */ 

  /* Use error from last time through */

  for ( i = N-1 ; i >= 0 ; i--)
    {
      y += ( (long)(X[i] * W[i]) >> 0 ); /* Prevent overflows */
   
      difference =  ((long)( error * X[i] ) >> 14);
   
      /* Remove fractional part then update coeffient W[i] */ 
   
      if ( difference & 0x0001)
        {
          if ( difference >= 0)
            {
              difference++ ; /* Round up when above zero */
            }
          else
            {
              difference--;  /* Round down when below zero */
            }    
        } 
            
      W[i] += (signed int) ( difference >> 1);  
    } 
      
  y >>= 15;  /* Remove remains of fractional part */
    
  error = desired - (signed int) y;

  return(  ( y << 16 ) | (long) error ); /* Return y OR error */
  
}

/*****************************************************************************/
/* adaptive_filter_unoptimized()                                             */
/*---------------------------------------------------------------------------*/
/*                                                                           */
/* INPUT 1: desired (or reference) waveform.                                 */
/* INPUT 2: input signal (unknown) to be compared with the reference.        */
/*                                                                           */ 
/* RETURNS: Filter output y in high word. Error in low word                  */
/*                                                                           */
/*****************************************************************************/

signed long adaptive_filter_unoptimized( signed int desired, signed int latest_measurement)
{
  signed int i;
  signed long y;            /* Output of adaptive filter */
  signed long difference;  
  static signed int error = 0; /* Difference between desired (reference) and actual. */

  /* Shuffle first and update */

  for ( i = N-1 ; i > 0 ; i--)
    {
      X[i] = X[i-1];
    }

  X[0] = latest_measurement;
 
  difference = ( (long) error * BETA);
  
  error = (signed int) (difference >> 15); /* Update error */
 
  y = 0; /* Start accumulation at zero */ 

  /* Use error from last time through */

  for ( i = N-1 ; i >= 0 ; i--)
    {
      y += ( ((long)X[i] * W[i]) >> 0 ); /* Prevent overflows */
   
      difference =  (((long) error * W[i] ) >> 14);
   
      /* Remove fractional part then update coeffient W[i] */ 
   
      if ( difference & 0x0001)
        {
          if ( difference >= 0)
            {
              difference++ ; /* Round up when above zero */
            }
          else
            {
              difference--;  /* Round down when below zero */
            }    
        } 
            
      W[i] += (signed int) ( difference >> 1);  
    } 
      
  y >>= 15;  /* Remove remains of fractional part */
    
  error = desired - (signed int) y;

  return(  ( y << 16 ) | (long) error ); /* Return y OR error */
  
}
  
/*****************************************************************************/
/* End of adaptive_filter.c                                                  */
/*****************************************************************************/