- Main Page
- Modules
- Data Structures
- Files
- Examples

- File List
- Globals

# arm_lms_f32.c

Go to the documentation of this file.

    00001 /* ----------------------------------------------------------------------
    00002 * Copyright (C) 2010 ARM Limited. All rights reserved.
    00003 *
    00004 * $Date:        29. November 2010
    00005 * $Revision:    V1.0.3
    00006 *
    00007 * Project:      CMSIS DSP Library
    00008 * Title:        arm_lms_f32.c
    00009 *
    00010 * Description:  Processing function for the floating-point LMS filter.
    00011 *
    00012 * Target Processor: Cortex-M4/Cortex-M3
    00013 *
    00014 * Version 1.0.3 2010/11/29
    00015 *    Re-organized the CMSIS folders and updated documentation.
    00016 *
    00017 * Version 1.0.2 2010/11/11
    00018 *    Documentation updated.
    00019 *
    00020 * Version 1.0.1 2010/10/05
    00021 *    Production release and review comments incorporated.
    00022 *
    00023 * Version 1.0.0 2010/09/20
    00024 *    Production release and review comments incorporated
    00025 *
    00026 * Version 0.0.7  2010/06/10
    00027 *    Misra-C changes done
    00028 * -------------------------------------------------------------------- */
    00029
    00030 #include "arm_math.h"
    00031
    00164 void arm_lms_f32(
    00165   const arm_lms_instance_f32 * S,
    00166   float32_t * pSrc,
    00167   float32_t * pRef,
    00168   float32_t * pOut,
    00169   float32_t * pErr,
    00170   uint32_t blockSize)
    00171 {
    00172   float32_t *pState = S->pState;                 /* State pointer */
    00173   float32_t *pCoeffs = S->pCoeffs;               /* Coefficient pointer */
    00174   float32_t *pStateCurnt;                        /* Points to the current sample of the state */
    00175   float32_t *px, *pb;                            /* Temporary pointers for state and coefficient buffers */
    00176   float32_t mu = S->mu;                          /* Adaptive factor */
    00177   uint32_t numTaps = S->numTaps;                 /* Number of filter coefficients in the filter */
    00178   uint32_t tapCnt, blkCnt;                       /* Loop counters */
    00179   float32_t sum, e, d;                           /* accumulator, error, reference data sample */
    00180   float32_t w = 0.0f;                            /* weight factor */
    00181
    00182   e = 0.0f;
    00183   d = 0.0f;
    00184
    00185   /* S->pState points to state array which contains previous frame (numTaps - 1) samples */
    00186   /* pStateCurnt points to the location where the new input data should be written */
    00187   pStateCurnt = &(S->pState[(numTaps - 1u)]);
    00188
    00189   blkCnt = blockSize;
    00190
    00191   while(blkCnt > 0u)
    00192   {
    00193     /* Copy the new input sample into the state buffer */
    00194     *pStateCurnt++ = *pSrc++;
    00195
    00196     /* Initialize pState pointer */
    00197     px = pState;
    00198
    00199     /* Initialize coeff pointer */
    00200     pb = (pCoeffs);
    00201
    00202     /* Set the accumulator to zero */
    00203     sum = 0.0f;
    00204
    00205     /* Loop unrolling.  Process 4 taps at a time. */
    00206     tapCnt = numTaps >> 2;
    00207
    00208     while(tapCnt > 0u)
    00209     {
    00210       /* Perform the multiply-accumulate */
    00211       sum += (*px++) * (*pb++);
    00212       sum += (*px++) * (*pb++);
    00213       sum += (*px++) * (*pb++);
    00214       sum += (*px++) * (*pb++);
    00215
    00216       /* Decrement the loop counter */
    00217       tapCnt--;
    00218     }
    00219
    00220     /* If the filter length is not a multiple of 4, compute the remaining filter taps */
    00221     tapCnt = numTaps % 0x4u;
    00222
    00223     while(tapCnt > 0u)
    00224     {
    00225       /* Perform the multiply-accumulate */
    00226       sum += (*px++) * (*pb++);
    00227
    00228       /* Decrement the loop counter */
    00229       tapCnt--;
    00230     }
    00231
    00232     /* The result in the accumulator, store in the destination buffer. */
    00233     *pOut++ = sum;
    00234
    00235     /* Compute and store error */
    00236     d = (float32_t) (*pRef++);
    00237     e = d - sum;
    00238     *pErr++ = e;
    00239
    00240     /* Calculation of Weighting factor for the updating filter coefficients */
    00241     w = e * mu;
    00242
    00243     /* Initialize pState pointer */
    00244     px = pState;
    00245
    00246     /* Initialize coeff pointer */
    00247     pb = (pCoeffs);
    00248
    00249     /* Loop unrolling.  Process 4 taps at a time. */
    00250     tapCnt = numTaps >> 2;
    00251
    00252     /* Update filter coefficients */
    00253     while(tapCnt > 0u)
    00254     {
    00255       /* Perform the multiply-accumulate */
    00256       *pb = *pb + (w * (*px++));
    00257       pb++;
    00258
    00259       *pb = *pb + (w * (*px++));
    00260       pb++;
    00261
    00262       *pb = *pb + (w * (*px++));
    00263       pb++;
    00264
    00265       *pb = *pb + (w * (*px++));
    00266       pb++;
    00267
    00268       /* Decrement the loop counter */
    00269       tapCnt--;
    00270     }
    00271
    00272     /* If the filter length is not a multiple of 4, compute the remaining filter taps */
    00273     tapCnt = numTaps % 0x4u;
    00274
    00275     while(tapCnt > 0u)
    00276     {
    00277       /* Perform the multiply-accumulate */
    00278       *pb = *pb + (w * (*px++));
    00279       pb++;
    00280
    00281       /* Decrement the loop counter */
    00282       tapCnt--;
    00283     }
    00284
    00285     /* Advance state pointer by 1 for the next sample */
    00286     pState = pState + 1;
    00287
    00288     /* Decrement the loop counter */
    00289     blkCnt--;
    00290   }
    00291
    00292
    00293   /* Processing is complete. Now copy the last numTaps - 1 samples to the
    00294      satrt of the state buffer. This prepares the state buffer for the
    00295      next function call. */
    00296
    00297   /* Points to the start of the pState buffer */
    00298   pStateCurnt = S->pState;
    00299
    00300   /* Loop unrolling for (numTaps - 1u) samples copy */
    00301   tapCnt = (numTaps - 1u) >> 2u;
    00302
    00303   /* copy data */
    00304   while(tapCnt > 0u)
    00305   {
    00306     *pStateCurnt++ = *pState++;
    00307     *pStateCurnt++ = *pState++;
    00308     *pStateCurnt++ = *pState++;
    00309     *pStateCurnt++ = *pState++;
    00310
    00311     /* Decrement the loop counter */
    00312     tapCnt--;
    00313   }
    00314
    00315   /* Calculate remaining number of copies */
    00316   tapCnt = (numTaps - 1u) % 0x4u;
    00317
    00318   /* Copy the remaining q31_t data */
    00319   while(tapCnt > 0u)
    00320   {
    00321     *pStateCurnt++ = *pState++;
    00322
    00323     /* Decrement the loop counter */
    00324     tapCnt--;
    00325   }
    00326 }
    00327

All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Defines