【STM32H7的DSP教程】第49章 STM32H7的自适应滤波器实现，无需Matlab生成系数（支持实时滤波）

Simon223

发布于 2021-09-26 17:14:31

9090

发布于 2021-09-26 17:14:31

文章被收录于专栏：安富莱嵌入式技术分享

第49章 STM32H7的自适应滤波器实现，无需Matlab生成系数（支持实时滤波）

本章节讲解LMS最小均方自适应滤波器实现，无需Matlab生成系数，可以自学习。

49.1 初学者重要提示

49.2 自适应滤波器介绍

49.3 LMS最小均方自适应滤波器介绍

49.4 Matlab自适应滤波器实现

49.5 自适应滤波器设计

49.6 实验例程说明（MDK）

49.7 实验例程说明（IAR）

49.8 总结

49.1 初学者重要提示

ARM DSP库提供了LMS最小均方自适应滤波和归一化最小均方自适应滤波器，推荐使用归一化方式，因为归一化方法的步长更容易设置。
自适应滤波器的滤波因数步长设置比较考究，详见本章教程第5.3小结。

49.2 自适应滤波器介绍

自适应滤波器能够根据输入信号自动调整滤波系数进行数字滤波。作为对比，非自适应滤波器有静态的滤波器系数，这些静态系数一起组成传递函数。

对于一些应用来说，由于事先并不知道需要进行操作的参数，例如一些噪声信号的特性，所以要求使用自适应的系数进行处理。在这种情况下，通常使用自适应滤波器，自适应滤波器使用反馈来调整滤波器系数以及频率响应。

随着处理器性能的增强，自适应滤波器的应用越来越常见，时至今日它们已经广泛地用于手机以及其它通信设备、数码录像机和数码照相机以及医疗监测设备中。

49.3 LMS最小均方介绍

LMS 最小均方自适应滤波器能够"学习"未知的传输特性。LMS滤波器使用梯度下降方法，根据瞬时错误信号更新滤波系数。自适应滤波器常用于通信系统、均衡器和降噪。

LMS 滤波器由以下两个部分组成。第一部分是 FIR 滤波器。第二部分是系数更新机制。LMS 滤波器具有两个输入信号。x[n] 是FIR 滤波器输入，而参考输入d[n]对应 FIR 滤波器的预期输出。更新 FIR滤波器系数，以便 FIR滤波器的输出与参考输入匹配。滤波器系数更新机制基于 FIR 滤波器输出和参考输入之间的差异。当滤波器调整时，"错误信号"e[n]倾向于为零。LMS 处理功能接受输入和参考输入信号，并生成滤波器输出和错误信号。

输出信号 y[n] 由标准 FIR 滤波器计算：

y[n] = b[0] * x[n] + b[1] * x[n-1] + b[2] * x[n-2] + ...+ b[numTaps-1] * x[n-numTaps+1]

误差信号等于参考信号 d[n] 和滤波器输出之间的差值：

e[n] = d[n] - y[n]。

在计算每个样本的误差信号后，计算滤波器状态变量的瞬时能量：

E = x[n]^2 + x[n-1]^2 + ... + x[n-numTaps+1]^2。

然后在逐个样本的基础上更新滤波器系数 b[k]：

b[k] = b[k] + e[n] * (mu/E) * x[n-k]，对于 k=0, 1, ..., numTaps-1

其中 mu 是步长，并且控制系数收敛速度。在函数arm_lms_norm_init_f32中，pCoeffs 指向大小为 numTaps 的滤波器系数数组。系数按时间倒序存储：

{b[numTaps-1], b[numTaps-2], b[N-2], ..., b[1], b[0]}

pState 指向一个大小为 numTaps + blockSize - 1 的状态数组。状态缓冲区中的样本按顺序存储：

{x[n-numTaps+1], x[n-numTaps], x[n-numTaps-1], x[n-numTaps-2]....x[0], x[1], .. ., x[blockSize-1]}

注意，状态缓冲区的长度超过了滤波器系数数组的长度 blockSize-1 个样本。

49.4 Matlab自适应滤波器实现

首先创建两个混合信号，便于更好测试滤波器效果。

混合信号Mix_Signal_1 = 信号Signal_Original_1+白噪声。

混合信号Mix_Signal_2 = 信号Signal_Original_2+白噪声。

Fs = 1000;                                                          %采样率
N  = 1000;                                                          %采样点数
n  = 0:N-1;
t   = 0:1/Fs:1-1/Fs;                                                %时间序列
Signal_Original_1 =sin(2*pi*10*t)+sin(2*pi*20*t)+sin(2*pi*30*t);
Noise_White_1    = [0.3*randn(1,500), rand(1,500)]; %前500点高斯分部白噪声，后500点均匀分布白噪声
Mix_Signal_1   = Signal_Original_1 + Noise_White_1; %构造的混合信号

Signal_Original_2  =  [zeros(1,100), 20*ones(1,20), -2*ones(1,30), 5*ones(1,80), -5*ones(1,30), 9*ones(1,140), -4*ones(1,40), 3*ones(1,220), 
12*ones(1,100), 5*ones(1,20), 25*ones(1,30), 7 *ones(1,190)];

Noise_White_2     =  0.5*randn(1,1000);                             %高斯白噪声
Mix_Signal_2        =  Signal_Original_2 + Noise_White_2;           %构造的混合信号

滤波代码实现如下：

%****************************************************************************************
%  
%                信号Mix_Signal_1 和 Mix_Signal_2 分别作自适应滤波
%
%***************************************************************************************

%混合信号 Mix_Signal_1 自适应滤波
N=1000;                                             %输入信号抽样点数N
k=100;                                              %时域抽头LMS算法滤波器阶数
u=0.001;                                            %步长因子

%设置初值
yn_1=zeros(1,N);                            %output signal
yn_1(1:k)=Mix_Signal_1(1:k);                %将输入信号SignalAddNoise的前k个值作为输出yn_1的前k个值
w=zeros(1,k);                               %设置抽头加权初值
e=zeros(1,N);                               %误差信号

%用LMS算法迭代滤波
for i=(k+1):N
        XN=Mix_Signal_1((i-k+1):(i));
        yn_1(i)=w*XN';
        e(i)=Signal_Original_1(i)-yn_1(i);
        w=w+2*u*e(i)*XN;
end

subplot(4,1,1);
plot(Mix_Signal_1);                            %Mix_Signal_1 原始信号
axis([k+1,1000,-4,4]);
title('原始信号');

subplot(4,1,2);
plot(yn_1);                                     %Mix_Signal_1 自适应滤波后信号
axis([k+1,1000,-4,4]);
title('自适应滤波后信号');

%混合信号 Mix_Signal_2 自适应滤波
N=1000;                                           %输入信号抽样点数N
k=500;                                            %时域抽头LMS算法滤波器阶数
u=0.000011;                                       %步长因子

%设置初值
yn_1=zeros(1,N);                              %output signal
yn_1(1:k)=Mix_Signal_2(1:k);                  %将输入信号SignalAddNoise的前k个值作为输出yn_1的前k个值
w=zeros(1,k);                                 %设置抽头加权初值
e=zeros(1,N);                                 %误差信号

%用LMS算法迭代滤波
for i=(k+1):N
        XN=Mix_Signal_2((i-k+1):(i));
        yn_1(i)=w*XN';
        e(i)=Signal_Original_2(i)-yn_1(i);
        w=w+2*u*e(i)*XN;
end

subplot(4,1,3);
plot(Mix_Signal_2);                  %Mix_Signal_1 原始信号
axis([k+1,1000,-10,30]);
title('原始信号');

subplot(4,1,4);
plot(yn_1);                          %Mix_Signal_1 自适应滤波后信号
axis([k+1,1000,-10,30]);
title('自适应滤波后信号');

Matlab运行效果：

49.5 自适应器设计

自适应滤波器的主要通过下面两个函数实现，支持逐点实时滤波。

49.5.1 函数arm_lms_norm_init_f32

函数原型：

  void arm_lms_norm_init_f32(
        arm_lms_norm_instance_f32 * S,
        uint16_t numTaps,
        float32_t * pCoeffs,
        float32_t * pState,
        float32_t mu,
        uint32_t blockSize);

函数描述：

此函数用于自适应滤波器初始化。

函数参数：

第1个参数是arm_lms_norm_instance_f32类型结构体变量。
第2个参数是滤波因数个数。
第3个参数是滤波因数地址。
第4个参数指向状态变量数组，这个数组用于函数内部计算数据的缓存。
第5个参数用于设置滤波因数更新的步长。
第6个参数是每次处理的数据个数，最小可以每次处理1个数据，最大可以每次全部处理完。

49.5.2 函数arm_lms_norm_f32

函数原型：

  void arm_lms_norm_f32(
        arm_lms_norm_instance_f32 * S,
  const float32_t * pSrc,
        float32_t * pRef,
        float32_t * pOut,
        float32_t * pErr,
        uint32_t blockSize);

函数描述：

此函数用于自适应滤波器实时滤波。

函数参数：

第1个参数是arm_lms_norm_instance_f32类型结构体变量。
第2个参数是源数据地址。
第3个参数是参考数据地址，需要用户提供想要逼近的波形效果。
第4个参数是输出数据地址。
第5个参数是误差数据地址。
第6个参数是每次处理的数据个数，最小可以每次处理1个数据，最大可以每次全部处理完。

注意事项：

结构体arm_lms_norm_instance_f32的定义如下（在文件arm_math.h文件）：

  typedef struct
  {
          uint16_t numTaps;     /**< number of coefficients in the filter. */
          float32_t *pState;    /**< points to the state variable array. The array is of length
 numTaps+blockSize-1. */
          float32_t *pCoeffs;   /**< points to the coefficient array. The array is of length numTaps. */
          float32_t mu;         /**< step size that control filter coefficient updates. */
          float32_t energy;     /**< saves previous frame energy. */
          float32_t x0;         /**< saves previous input sample. */
  } arm_lms_norm_instance_f32;

1、参数numTaps用于设置滤波因数个数。

2、pState指向状态变量数组，这个数组用于函数内部计算数据的缓存。

3、参数pCoeffs指向滤波因数，滤波因数数组长度为numTaps。但要注意pCoeffs指向的滤波因数应该按照如下的逆序进行排列：

{b[numTaps-1], b[numTaps-2], b[N-2], ..., b[1], b[0]}

但满足线性相位特性的FIR滤波器具有奇对称或者偶对称的系数，偶对称时逆序排列还是他本身。

4、参数mu用于设置滤波因数更新的步长。

5、blockSize 这个参数的大小没有特殊要求，最小可以每次处理1个数据，最大可以每次全部处理完。

49.5.3 滤除200Hz正弦波测试（含不同步长测试，重要）

原始波形200Hz + 50Hz正弦波，滤除200Hz正弦波测试：

/*
*********************************************************************************************************
*    函 数 名: arm_lms_f32_test1
*    功能说明: 原始波形200Hz + 50Hz正弦波，滤除200Hz正弦波。
*    形    参: 无
*    返 回 值: 无
*********************************************************************************************************
*/
void arm_lms_f32_test1(void)
{
    uint32_t i;
    float32_t  *inputF32, *outputF32, *inputREF, *outputERR;
    arm_lms_norm_instance_f32 lmsS={0};

    
    for(i=0; i<TEST_LENGTH_SAMPLES; i++)
    {
        /* 50Hz正弦波+200Hz正弦波，采样率1KHz */
        testInput_f32_50Hz_200Hz[i] = arm_sin_f32(2*3.1415926f*50*i/1000) +
 arm_sin_f32(2*3.1415926f*200*i/1000);
        testInput_f32_REF[i] =  arm_sin_f32(2*3.1415926f*50*i/1000);
    }
    
    /* 如果是实时性的滤波，仅需清零一次 */
    memset(lmsCoeffs32,0,sizeof(lmsCoeffs32));
    memset(lmsStateF32,0,sizeof(lmsStateF32));    

    /* 初始化输入输出缓存指针 */
    inputF32 = (float32_t *)&testInput_f32_50Hz_200Hz[0]; /* 原始波形 */
    outputF32 = (float32_t *)&testOutput[0];              /* 滤波后输出波形 */
    inputREF = (float32_t *)&testInput_f32_REF[0];        /* 参考波形 */  
    outputERR = (float32_t *)&test_f32_ERR[0];            /* 误差数据 */  
 
    
    /* 归一化LMS初始化 */
    arm_lms_norm_init_f32 (&lmsS,                            /* LMS结构体 */
                           NUM_TAPS,                      /* 滤波器系数个数 */
                            (float32_t *)&lmsCoeffs32[0], /* 滤波 */ 
                            &lmsStateF32[0],              /* 滤波器系数 */
                            0.1,                          /* 步长 */
                            blockSize);                   /* 处理的数据个数 */



    /* 实现LMS自适应滤波，这里每次处理1个点 */
    for(i=0; i < numBlocks; i++)
    {
        
        arm_lms_norm_f32(&lmsS, /* LMS结构体 */
                        inputF32 + (i * blockSize),      /* 输入数据 */
                        inputREF + (i * blockSize),      /* 输出数据 */
                        outputF32 + (i * blockSize),     /* 参考数据 */
                        outputERR + (i * blockSize),     /* 误差数据 */
                        blockSize);                     /* 处理的数据个数 */

    }
    

    /* 打印滤波后结果 */
    for(i=0; i<TEST_LENGTH_SAMPLES; i++)
    {
        printf("%f, %f, %f\r\n", testInput_f32_50Hz_200Hz[i], outputF32[i], test_f32_ERR[i]);
    }
}

下面是滤波因数步长调节为0.1时的滤波器效果，浅蓝色是原始波形，黄色黄色是滤波后波形，绿色是误差值：

步长为0.01时效果，可以看到逼近参考波形的速度较慢：

步长为1的效果，逼近参考波形的速度更快，前面的波形由一段陡增。

关于步长，没有特别好的方式直接锁定那种步长大小更合适，一般的处理思路是按照10倍关系先锁定范围，比如先测试步长为1，0.1，0.001等来测试，然后进一步设置一个合适的值。

49.5.4 滤除白噪声测试（一）

原始波形由任意波形+ 高斯分布白噪声 + 均匀分布白噪声组成，滤除高斯分布白噪声 + 均匀分布白噪声。

/*
*********************************************************************************************************
*    函 数 名: arm_lms_f32_test2
*    功能说明: 原始波形由任意波形+ 高斯分布白噪声 + 均匀分布白噪声组成，滤除高斯分布白噪声 + 均匀分布白噪声。
*    形    参: 无
*    返 回 值: 无
*********************************************************************************************************
*/
void arm_lms_f32_test2(void)
{
    uint32_t i;
    arm_lms_norm_instance_f32 lmsS;
    float32_t  *inputF32, *outputF32, *inputREF, *outputERR;
    
    /* 如果是实时性的滤波，仅需清零一次 */
    memset(lmsCoeffs32,0,sizeof(lmsCoeffs32));
    memset(lmsStateF32,0,sizeof(lmsStateF32));        

    /* 初始化输入输出缓存指针 */
    inputF32 = (float32_t *)&MixData[0];       /* 原始波形 */
    outputF32 = (float32_t *)&testOutput[0];   /* 滤波后输出波形 */
    inputREF = (float32_t *)&OrigalData[0];    /* 参考波形 */  
    outputERR = (float32_t *)&test_f32_ERR[0]; /* 误差数据 */  

    
    /* 归一化LMS初始化 */
    arm_lms_norm_init_f32 (&lmsS,                         /* LMS结构体 */
                           NUM_TAPS,                      /* 滤波器系数个数 */
                            (float32_t *)&lmsCoeffs32[0], /* 滤波 */ 
                            &lmsStateF32[0],              /* 滤波器系数 */
                            0.01,                          /* 步长 */
                            blockSize);                   /* 处理的数据个数 */


    /* 实现LMS自适应滤波，这里每次处理1个点 */
    for(i=0; i < numBlocks; i++)
    {
        
        arm_lms_norm_f32(&lmsS, /* LMS结构体 */
                        inputF32 + (i * blockSize),   /* 输入数据 */
                        inputREF + (i * blockSize),   /* 输出数据 */
                        outputF32 + (i * blockSize),  /* 参考数据 */
                        outputERR + (i * blockSize),  /* 误差数据 */
                        blockSize);                      /* 处理的数据个数 */

    }
    
    
    /* 打印滤波后结果 */
    for(i=0; i<TEST_LENGTH_SAMPLES; i++)
    {
        printf("%f, %f, %f\r\n", MixData[i], outputF32[i], test_f32_ERR[i]);
    }
    
}

下面是滤波因数步长调节为0.01时的滤波器效果，浅蓝色是原始波形，黄色黄色是滤波后波形，绿色是误差值：

这个波形做了两个周期，前1024点和后1024点，后面1024点滤除白噪声的效果已经比较好，而前1024的点的前半段一直在逼近我们设置的参考波形中。另外从误差值波形中，我们可以看到原始波形跳变的地方，误差值也会有一个跳变，然后向0趋近。这是自适应滤波器特性决定的，不断的调节滤波器系数中。

我们再来看下将滤波因数步长调节为0.1时的效果：

可以看到逼近速度很快，但是逼近效果一般，也就是白噪声的滤除效果一般。

49.5.5 滤除白噪声测试（二）

原始波形10Hz正弦波 + 20Hz正弦波 + 30Hz正弦波 + 高斯分布白噪声 + 均匀分布白噪声。滤除高斯分布白噪声 + 均匀分布白噪声。

/*
*********************************************************************************************************
*    函 数 名: arm_lms_f32_test3
*    功能说明: 10Hz正弦波 + 20Hz正弦波 + 30Hz正弦波 + 高斯分布白噪声 + 均匀分布白噪声，滤除高斯分布白噪声 + 均匀分布白噪声
*    形    参: 无
*    返 回 值: 无
*********************************************************************************************************
*/
void arm_lms_f32_test3(void)
{    
    uint32_t i;
    arm_lms_norm_instance_f32 lmsS;
    float32_t  *inputF32, *outputF32, *inputREF, *outputERR;
    
    
    /* 如果是实时性的滤波，仅需清零一次 */
    memset(lmsCoeffs32,0,sizeof(lmsCoeffs32));
    memset(lmsStateF32,0,sizeof(lmsStateF32));    
    
    /* 初始化输入输出缓存指针 */
    inputF32 = (float32_t *)&MixData1[0];       /* 原始波形 */
    outputF32 = (float32_t *)&testOutput[0];    /* 滤波后输出波形 */
    inputREF = (float32_t *)&OrigalData1[0];    /* 参考波形 */  
    outputERR = (float32_t *)&test_f32_ERR[0];  /* 误差数据 */  

    /* 归一化LMS初始化 */
    arm_lms_norm_init_f32 (&lmsS,                         /* LMS结构体 */
                           NUM_TAPS,                      /* 滤波器系数个数 */
                            (float32_t *)&lmsCoeffs32[0], /* 滤波 */ 
                            &lmsStateF32[0],              /* 滤波器系数 */
                            0.1,                          /* 步长 */
                            blockSize);                   /* 处理的数据个数 */


    /* 实现LMS自适应滤波，这里每次处理1个点 */
    for(i=0; i < numBlocks; i++)
    {
        
        arm_lms_norm_f32(&lmsS, /* LMS结构体 */
                        inputF32 + (i * blockSize),   /* 输入数据 */
                        inputREF + (i * blockSize),   /* 输出数据 */
                        outputF32 + (i * blockSize),  /* 参考数据 */
                        outputERR + (i * blockSize),  /* 误差数据 */
                        blockSize);                      /* 处理的数据个数 */

    }
    
    /* 打印滤波后结果 */
    for(i=0; i<TEST_LENGTH_SAMPLES; i++)
    {
        printf("%f, %f, %f\r\n", MixData1[i], outputF32[i], test_f32_ERR[i]);
    }
    
}

下面是滤波因数步长调节为0.1时的滤波器效果，浅蓝色是原始波形，黄色黄色是滤波后波形，绿色是误差值：

49.6 实验例程说明（MDK）

配套例子：

V7-234_自适应滤波器实现，无需Matlab生成系数（支持实时滤波）

实验目的：

学习LMS最小均方滤波器。

实验内容：

启动一个自动重装软件定时器，每100ms翻转一次LED2。
按下按键K1，打印测试波形1和滤波后的波形数据。
按下按键K2，打印测试波形2和滤波后的波形数据。
按下按键K3，打印测试波形3和滤波后的波形数据。

使用AC6注意事项

特别注意附件章节C的问题

上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1。

RTT方式打印信息：

程序设计：

系统栈大小分配：

RAM空间用的DTCM：

硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：

/*
*********************************************************************************************************
*    函 数 名: bsp_Init
*    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
*    形    参：无
*    返 回 值: 无
*********************************************************************************************************
*/
void bsp_Init(void)
{
    /* 配置MPU */
    MPU_Config();
    
    /* 使能L1 Cache */
    CPU_CACHE_Enable();

    /* 
       STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
       - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
       - 设置NVIC优先级分组为4。
     */
    HAL_Init();

    /* 
       配置系统时钟到400MHz
       - 切换使用HSE。
       - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    */
    SystemClock_Config();

    /* 
       Event Recorder：
       - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
       - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第8章
    */    
#if Enable_EventRecorder == 1  
    /* 初始化EventRecorder并开启 */
    EventRecorderInitialize(EventRecordAll, 1U);
    EventRecorderStart();
#endif
    
    bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    bsp_InitTimer();      /* 初始化滴答定时器 */
    bsp_InitUart();    /* 初始化串口 */
    bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */    
    bsp_InitLed();        /* 初始化LED */    
}

MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM），FMC的扩展IO区。

/*
*********************************************************************************************************
*    函 数 名: MPU_Config
*    功能说明: 配置MPU
*    形    参: 无
*    返 回 值: 无
*********************************************************************************************************
*/
static void MPU_Config( void )
{
    MPU_Region_InitTypeDef MPU_InitStruct;

    /* 禁止 MPU */
    HAL_MPU_Disable();

    /* 配置AXI SRAM的MPU属性为关闭读Cache和写Cache */
    MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    MPU_InitStruct.BaseAddress      = 0x24000000;
    MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT _BUFFERABLE;
    MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT _CACHEABLE;
    MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    MPU_InitStruct.SubRegionDisable = 0x00;
    MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;

    HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
    
    /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    MPU_InitStruct.BaseAddress      = 0x60000000;
    MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;    
    MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;    
    MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    MPU_InitStruct.SubRegionDisable = 0x00;
    MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
    HAL_MPU_ConfigRegion(&MPU_InitStruct);

    /*使能 MPU */
    HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
}

/*
*********************************************************************************************************
*    函 数 名: CPU_CACHE_Enable
*    功能说明: 使能L1 Cache
*    形    参: 无
*    返 回 值: 无
*********************************************************************************************************
*/
static void CPU_CACHE_Enable(void)
{
    /* 使能 I-Cache */
    SCB_EnableICache();

    /* 使能 D-Cache */
    SCB_EnableDCache();
}

主功能：

主程序实现如下操作：

启动一个自动重装软件定时器，每100ms翻转一次LED2。
按下按键K1，打印测试波形1和滤波后的波形数据。
按下按键K2，打印测试波形2和滤波后的波形数据。
按下按键K3，打印测试波形3和滤波后的波形数据。

/*
*********************************************************************************************************
*    函 数 名: main
*    功能说明: c程序入口
*    形    参: 无
*    返 回 值: 错误代码(无需处理)
*********************************************************************************************************
*/
int main(void)
{
    uint8_t ucKeyCode;        /* 按键代码 */
    uint16_t i;

    bsp_Init();        /* 硬件初始化 */
    PrintfLogo();    /* 打印例程信息到串口1 */

    PrintfHelp();    /* 打印操作提示信息 */
        

    bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */

    /* 进入主程序循环体 */
    while (1)
    {
        bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
        

        if (bsp_CheckTimer(0))    /* 判断定时器超时时间 */
        {
            /* 每隔100ms 进来一次 */
            bsp_LedToggle(2);    /* 翻转LED的状态 */
        }
        
        ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
        if (ucKeyCode != KEY_NONE)
        {
            switch (ucKeyCode)
            {
                case KEY_DOWN_K1:            /* K1键按下 */
                    arm_lms_f32_test1();
                    break;
                
                case KEY_DOWN_K2:            /* K2键按下 */
                    arm_lms_f32_test2();
                    break;
                
                case KEY_DOWN_K3:            /* K3键按下 */
                    arm_lms_f32_test3();
                    break;                
    
                default:
                    /* 其它的键值不处理 */
                    break;
            }
        }

    }
}