arm_signal_converge_example_f32.c

/* ----------------------------------------------------------------------     
* Copyright (C) 2011 ARM Limited. All rights reserved. 
*     
* $Date:        15. December 2011   
* $Revision:    V2.0.0  
*     
* Project:      Cortex-R4 DSP Library 
* Title:        arm_signal_converge_example_f32.c         
*  
* Description:  Example code demonstrating convergence of an adaptive 
*               filter. 
* 
* Target Processor:          Cortex-R4
*
* Version 2.0.0 2011/12/15
*     Final release. 
* 
* ---------------------------------------------------------------------------- */ 
 
#include "arm_math.h" 
#include "math_helper.h" 
 
/* ---------------------------------------------------------------------- 
** Global defines for the simulation 
* ------------------------------------------------------------------- */ 
 
#define TEST_LENGTH_SAMPLES 1536 
#define NUMTAPS             32 
#define BLOCKSIZE           32 
#define DELTA_ERROR         0.000001f 
#define DELTA_COEFF         0.0001f 
#define MU                  0.5f 
 
#define NUMFRAMES (TEST_LENGTH_SAMPLES / BLOCKSIZE) 
 
/* ---------------------------------------------------------------------- 
* Declare FIR state buffers and structure  
* ------------------------------------------------------------------- */ 
  
float32_t firStateF32[NUMTAPS + BLOCKSIZE];  
arm_fir_instance_f32 LPF_instance; 
 
/* ---------------------------------------------------------------------- 
* Declare LMSNorm state buffers and structure  
* ------------------------------------------------------------------- */ 
  
float32_t lmsStateF32[NUMTAPS + BLOCKSIZE];  
float32_t errOutput[TEST_LENGTH_SAMPLES]; 
arm_lms_norm_instance_f32 lmsNorm_instance; 
 
 
/* ---------------------------------------------------------------------- 
* Function Declarations for Signal Convergence Example  
* ------------------------------------------------------------------- */ 
 
arm_status test_signal_converge_example( void ); 
 
 
/* ---------------------------------------------------------------------- 
* Internal functions 
* ------------------------------------------------------------------- */ 
arm_status test_signal_converge(float32_t* err_signal, 
                                 uint32_t blockSize); 
 
void getinput(float32_t* input, 
         uint32_t fr_cnt,  
         uint32_t blockSize);  
 
/* ---------------------------------------------------------------------- 
* External Declarations for FIR F32 module Test 
* ------------------------------------------------------------------- */ 
extern float32_t testInput_f32[TEST_LENGTH_SAMPLES]; 
extern float32_t lmsNormCoeff_f32[32]; 
extern const float32_t FIRCoeff_f32[32]; 
extern arm_lms_norm_instance_f32 lmsNorm_instance; 
 
/* ---------------------------------------------------------------------- 
* Declare I/O buffers  
* ------------------------------------------------------------------- */ 
 
float32_t wire1[BLOCKSIZE]; 
float32_t wire2[BLOCKSIZE]; 
float32_t wire3[BLOCKSIZE]; 
float32_t err_signal[BLOCKSIZE]; 
 
/* ---------------------------------------------------------------------- 
* Signal converge test 
* ------------------------------------------------------------------- */ 
 
int32_t main(void) 
{ 
  uint32_t i; 
  arm_status status; 
  uint32_t index; 
  float32_t minValue; 
 
  /* Initialize the LMSNorm data structure */ 
  arm_lms_norm_init_f32(&lmsNorm_instance, NUMTAPS, lmsNormCoeff_f32, lmsStateF32, MU, BLOCKSIZE); 
 
  /* Initialize the FIR data structure */ 
  arm_fir_init_f32(&LPF_instance, NUMTAPS, (float32_t *)FIRCoeff_f32, firStateF32, BLOCKSIZE); 
 
  /* ---------------------------------------------------------------------- 
  * Loop over the frames of data and execute each of the processing 
  * functions in the system. 
  * ------------------------------------------------------------------- */ 
 
  for(i=0; i < NUMFRAMES; i++)  
    { 
      /* Read the input data - uniformly distributed random noise - into wire1 */  
      arm_copy_f32(testInput_f32 + (i * BLOCKSIZE), wire1, BLOCKSIZE); 
 
      /* Execute the FIR processing function.  Input wire1 and output wire2 */  
      arm_fir_f32(&LPF_instance, wire1, wire2, BLOCKSIZE); 
       
      /* Execute the LMS Norm processing function*/  
 
      arm_lms_norm_f32(&lmsNorm_instance, /* LMSNorm instance */ 
               wire1,                     /* Input signal */  
               wire2,                     /* Reference Signal */ 
               wire3,                     /* Converged Signal */ 
               err_signal,                /* Error Signal, this will become small as the signal converges */ 
               BLOCKSIZE);                /* BlockSize */ 
 
      /* apply overall gain */  
      arm_scale_f32(wire3, 5, wire3, BLOCKSIZE);     /* in-place buffer */  
    } 
 
  status = ARM_MATH_SUCCESS; 
 
  /* ------------------------------------------------------------------------------- 
  * Test whether the error signal has reached towards 0. 
  * ----------------------------------------------------------------------------- */ 
 
  arm_abs_f32(err_signal, err_signal, BLOCKSIZE); 
  arm_min_f32(err_signal, BLOCKSIZE, &minValue, &index); 
 
  if (minValue > DELTA_ERROR) 
  { 
      status = ARM_MATH_TEST_FAILURE; 
  } 
 
  /* ---------------------------------------------------------------------- 
  * Test whether the filter coefficients have converged. 
  * ------------------------------------------------------------------- */ 
 
  arm_sub_f32((float32_t *)FIRCoeff_f32, lmsNormCoeff_f32, lmsNormCoeff_f32, NUMTAPS); 
 
  arm_abs_f32(lmsNormCoeff_f32, lmsNormCoeff_f32, NUMTAPS); 
  arm_min_f32(lmsNormCoeff_f32, NUMTAPS, &minValue, &index); 
 
  if (minValue > DELTA_COEFF) 
  { 
      status = ARM_MATH_TEST_FAILURE; 
  } 
 
  /* ---------------------------------------------------------------------- 
  * Loop here if the signals did not pass the convergence check. 
  * This denotes a test failure 
  * ------------------------------------------------------------------- */ 
 
  if( status != ARM_MATH_SUCCESS) 
  { 
      while(1); 
  } 
}