Adaptive filter

1、LMS Filter Module simulation , Output will diverge , Mainly mu The value selection is inappropriate , Just choose a smaller value

2、 You can put online m File by matlab coder The tool is directly converted to C file （ Can't be used directly , Can be compared with reference ）

3、 Revised the online C Code for reference

#include "LMS.h"

/* xn-------- Input signal sequence （ Column vector ）
 * itr------- The number of iterations , Scalar , The default is xn The length of ,M<itr<sizeof(xn)
 * en-------- Error sequence （itr*1） Column vector 
 * dn-------- Desired response sequence （ Column vector ）
 * M--------- The order of the filter （ Scalar ）
 * mu-------- Convergence factor （ step ） Scalar 
 * W--------- Filter weight matrix , The size is M*itr
 * yn-------- Actual output sequence （ Column vector ）*/


/*LMS Concrete algorithm */
float * LMS_Filter(int itr, const float *xn, const float *dn, double mu, int length)
{
    static int i = 0;
    static int k = 0;
    static float y = 0.0;
    static float en[F_COUNT];
    static float W[M][F_COUNT];
    static float x[M];
    static float yn[F_COUNT];

    /* Create a en All zero matrix ,en(k) It means the first one k The error between the expected output and the actual input in the second iteration */
    for (i=0; i<itr; i++)
    {
        en[i] = 0;
    }

    /* Create a W All zero matrix , Each line represents a weighting parameter , Each column represents an iteration */
    for (i=0; i<M; i++)
        for (k=0; k<itr; k++)
            W[i][k] = 0;

    /* Create a x All zero matrix */
    for (i=0; i<M; i++)
        x[i] = 0;

    /* Iterative calculation */
    for (k=M; k<=itr; k++)
    {
        /*  filter M Input of two taps ： from xn The first k-1 Take out the values in reverse order M Put the values of samples into x
         * y Output for filter ：W Of the K-2 Column and x Sum of products of */
        for (i=0; i<M; i++)
        {
            x[i] = xn[k-i-1];
            y += W[i][k-2] * x[i];
        }        

        en[k-1] = dn[k-1] - y;  // The first k The error of each iteration 

        /* Iterative formula for filter weight calculation */
        for (i=0; i<M; i++)
        {
            W[i][k-1] = W[i][k-2] + 2*mu*en[k-1]*x[i];
        }

        y = 0.0;
    }

    /* Create a yn Full infinite matrix , Dimension and xn equally */
    for (i=0; i<itr; i++)
    {
        yn[i] = 0.0;
    }

    /* When finding the optimal output sequence of the filter */
    for (k=M; k<=length; k++)
    {
        for (i=0; i<M; i++)
        {
            x[i] = xn[k-i-1];
            y += W[i][k-2]*x[i];
        }

        yn[k-1] = y;
        y = 0.0;

    }

    return yn;
}