21ic电子技术开发论坛 › 单片机与嵌入式系统 › GigaDevice GD32 MCU › 开源GD32F103数字信号处理和机器学习算法 ...
12下一页
返回列表 发新帖我要提问

开源GD32F103数字信号处理和机器学习算法

[复制链接]
3913|40
 楼主| zeshoufx 发表于 2023-1-3 19:24 | 显示全部楼层 |阅读模式
gd32F103, gd32f1, 信号, 信号处理, 开源
GD32F103单片机开源测试基于ARM CMSIS-DSP和CMSIS-NN，其中ARM CMSIS-DSP包含了：电机变换（克拉克变换、帕克变换）、卷积、离散余弦变换、傅里叶变换、滤波、高斯朴素贝叶斯估计、插值、矩阵运算、PID、支持向量机及排序算法（双调排序（Bitonic sort）、冒泡排序（Bubble sort）、堆排序（Heap sort）、插入排序（Insertion sort）、快速排序（Quick sort）、选择排序（Selection sort）六种排序算法）。
其中CMSIS-NN及自己编写的机器学习和神经网络包含了：卡尔曼滤波、自适应滤波，蚁群优化、卷积神经网络、遗传算法、强化学习、线性回归 归纳学习、循环神经网络。

开源地址：        1、神经网络机器学习：https://gitee.com/zhang_en/expand.git
2、数字信号处理：https://gitee.com/zhang_en/arm-cmsis-dsp-test.git

测试板子：GD32F103VKT6
file:///C:/Users/zes/AppData/Local/Temp/ksohtml9352/wps1.png
1231163b4106f945a8.png
回复

收藏1 举报

相关帖子
 楼主| zeshoufx 发表于 2023-1-3 19:25 | 显示全部楼层
# ARM CMSIS-DSP测试
#### 介绍
ARM DSP基本就完了，包含了：
        电机变换（克拉克变换、帕克变换）、卷积、
离散余弦变换、傅里叶变换、滤波、高斯朴素贝叶斯估计、
插值、矩阵运算、PID、支持向量机
1.  克拉克变换：在三相电系统里，经常使用坐标变换，实现三相变两相、两相变三相，测试采用正弦函数模拟三相电，
幅值为1，频率为50Hz，相位差互差120度，采样频率为6.4kHz，调用函数arm_sin_f32即可，由于三相电瞬时电流代数和为0，
只用给出A、B两相即可，克拉克变换函数arm_clarke_f32。
复制
  1. float32_t ia[128]={0.};                //输入A相电流
    

  2. float32_t ib[128]={0.};                //输入B相电流
    


  3. 

  4. float32_t ia1[128]={0.};        //输出阿法轴电流
    

  5. float32_t ib1[128]={0.};        //输出贝塔轴电流
    


  6. 

  7. void dsp_test(void)
    

  8. {
    

  9.         u8 i=0;
    

  10.         
    

  11.         for(i=0;i<128;i++)
    

  12.         {
    

  13.                 ia[i]=arm_sin_f32(100*PI*i/6400);
    

  14.                 ib[i]=arm_sin_f32(100*PI*i/6400+PI*2/3);
    

  15.         }
    

  16.         
    

  17.         for(i=0;i<128;i++)
    

  18.         {
    

  19.                 arm_clarke_f32(ia[i],ib[i],&ia1[i],&ib1[i]);
    

  20.         }
    

  21.         
    

  22.         for(i=0;i<128;i++)
    

  23.         {
    

  24.                 printf("%f        %f        %f        %f\r\n",ia[i],ib[i],ia1[i],ib1[i]);
    

  25.         }
    

  26. }
1232363b410ba75995.png

回复

收藏1 举报

 楼主| zeshoufx 发表于 2023-1-3 19:26 | 显示全部楼层
zeshoufx 发表于 2023-1-3 19:25
# ARM CMSIS-DSP测试 #### 介绍ARM DSP基本就完了，包含了：        电机变换（克拉克变换、帕克变换）、卷积、离 ...

2.  卷积：卷积在数字信号处理算是一个重点内容，在各个变换里基本都讨论到卷积。卷积函数arm_conv_f32。测试采用
一个频率为50Hz的正弦波与一个长度为64的矩形窗函数进行卷积。
复制
  1. float32_t data[64]={0.};                //输入序列1
    

  2. float32_t data1[32]={0.};                //输入序列2
    

  3. float32_t data2[95]={0.};        //输出序列
    


  4. 

  5. void dsp_test(void)
    

  6. {
    

  7.         u8 i=0;
    

  8.         
    

  9.         printf("***************\r\n");
    

  10.         for(i=0;i<64;i++)
    

  11.         {
    

  12.                 data[i]=arm_sin_f32(100*PI*i/6400);
    

  13.                 
    

  14.         }
    

  15.         
    

  16.         for(i=0;i<64;i++)
    

  17.         {
    

  18.                 printf("%f\r\n",data[i]);
    

  19.         }
    

  20.         
    

  21.         printf("***************\r\n");
    

  22.         for(i=0;i<32;i++)
    

  23.         {
    

  24.                 data1[i]=1;
    

  25.         }
    

  26.         
    

  27.         for(i=0;i<32;i++)
    

  28.         {
    

  29.                 printf("%f\r\n",data1[i]);
    

  30.         }
    

  31.         
    

  32.         arm_conv_f32(data,64,data1,32,data2);
    

  33.         printf("***************\r\n");
    

  34.         for(i=0;i<95;i++)
    

  35.         {
    

  36.                 printf("%f\r\n",data2[i]);
    

  37.         }
    

  38. }
6640863b410eb75b43.png

回复

收藏1 举报

 楼主| zeshoufx 发表于 2023-1-3 19:27 | 显示全部楼层
zeshoufx 发表于 2023-1-3 19:26
2.  卷积：卷积在数字信号处理算是一个重点内容，在各个变换里基本都讨论到卷积。卷积函数arm_conv_f32。 ...

3.  离散余弦变换：离散余弦变换在图像处理中比较常用，主要是图像压缩邻域，例如JPG格式，图像清晰度与原图差不多，
但占用的存储空间却比原图少了很多。离散余弦变换初始化函数arm_dct4_init_f32，离散余弦变换函数arm_dct4_f32。测试
采用对输入序列为1.5+arm_sin_f32(100*PI*i/6400)进行离散余弦变换。
复制
  1. arm_dct4_instance_f32 S;                                //DCT 实例化结构体
    

  2. arm_rfft_instance_f32  S_RFFT;                        //实序列傅里叶变换实例化结构体
    

  3. arm_cfft_radix4_instance_f32 S_CFFT;        //复数序列傅里叶变换实例化结构体
    

  4. float32_t normalize=0.125;                                //归一化因子
    


  5. 

  6. float32_t pInlineBuffer[128];                        //输入输出
    

  7. float32_t pState[128];                                        //state缓存
    

  8. float32_t data[128]={0.f};
    


  9. 


  10. 


  11. 


  12. 


  13. 

  14. void dsp_test(void)
    

  15. {
    

  16.         u16 i=0;
    

  17.         
    

  18.         
    

  19.         for(i=0;i<128;i++)
    

  20.         {
    

  21.                 data[i]=1.5f+arm_sin_f32(100*PI*i/6400);
    

  22.                 printf("%f\r\n",data[i]);
    

  23.                 pInlineBuffer[i]=data[i];
    

  24.         }
    

  25.         
    

  26.         
    

  27.         arm_dct4_init_f32(&S,&S_RFFT,&S_CFFT,128,64,normalize);
    

  28.         
    

  29.         arm_dct4_f32(&S,pState,pInlineBuffer);
    

  30.         
    

  31.         for(i=0;i<128;i++)
    

  32.         {
    

  33.                 printf("%f\r\n",pInlineBuffer[i]);
    

  34.         }
    

  35. }


回复

收藏1 举报

 楼主| zeshoufx 发表于 2023-1-3 19:28 | 显示全部楼层
zeshoufx 发表于 2023-1-3 19:27
3.  离散余弦变换：离散余弦变换在图像处理中比较常用，主要是图像压缩邻域，例如JPG格式，图像清晰度与 ...

4.傅里叶变换：傅里叶变换在各个领域都有运用，尤其是在频谱分析和谐波检测行业中，傅里叶变换实序列
初始化函数为arm_rfft_init_f32，实序列傅里叶变换函数为arm_rfft_f32。测试采用直流分量为1.5，基波频率
为50Hz，幅值为1，采样率为6.4KHZ，叠加幅值为0.3的3次谐波和幅值为0.5的7次谐波，通过傅里叶变换准确获得各次谐波的幅值。
复制
  1. arm_rfft_instance_f32 S;                                //实序列傅里叶变换结构体
    

  2. arm_cfft_radix4_instance_f32 S_CFFT;        //傅里叶变换结果复序列结构体
    


  3. 

  4. static float32_t pSrc[128]={0.0};           //输入
    

  5. static float32_t pDst[256]={0.0};                //输出
    

  6. static float32_t out[128]={0};                        //结果
    

  7. void dsp_test(void)
    

  8. {
    

  9.         u8 i=0,j=0;
    

  10.         for(i=0;i<128;i++)
    

  11.         {
    

  12.                 pSrc[i]=1.6f+arm_sin_f32(100*PI*i/6400)+0.3f*arm_sin_f32(300*PI*i/6400)+0.5f*arm_sin_f32(700*PI*i/6400);
    

  13.         }
    

  14.         arm_rfft_init_f32(&S,&S_CFFT,128,0,1);        //初始化
    

  15.         arm_rfft_f32(&S,pSrc,pDst);                                //傅里叶变换
    

  16.         for(j=0;j<127;j++)
    

  17.         {
    

  18.                 arm_sqrt_f32(pDst[2*j]*pDst[2*j]+pDst[2*j+1]*pDst[2*j+1],&out[j]);//获得幅值
    

  19.                 if(j==0)
    

  20.                 {
    

  21.                         out[j]=out[j]/128;//直流分量需要特殊处理
    

  22.                 }
    

  23.                 else
    

  24.                 {
    

  25.                         out[j]=out[j]/64;//交流分量
    

  26.                 }
    

  27.         }
    

  28.         for(j=0;j<64;j++)
    

  29.         {
    

  30.                 printf("%f\r\n",out[j]);
    

  31.         }
    

  32. }
7022063b411470c2d4.png
8853763b41151994b9.png
回复

收藏1 举报

 楼主| zeshoufx 发表于 2023-1-3 19:29 | 显示全部楼层
zeshoufx 发表于 2023-1-3 19:28
4.傅里叶变换：傅里叶变换在各个领域都有运用，尤其是在频谱分析和谐波检测行业中，傅里叶变换实序列
初 ...

5.滤波：滤波在信号处理中特别重要，在模拟前端经硬件滤波后，流入ADC，采集到的数据可能还达不到直接使用
的目的，这时需要进行软件滤波。包括有限冲激响应滤波和无限冲激响应滤波，测试采用50Hz基波叠加9次谐波，
通过IIR滤波将9次谐波滤掉。
复制
  1. //arm_biquad_cascade_df1_init_f32  parameter（初始化结构体）
    

  2. static arm_biquad_casd_df1_inst_f32  S;        //structure
    

  3. static uint8_t numStages=2;                           //nums  of 2 order filter （2阶滤波器）
    


  4. 

  5. //5*numStages        xishu
    

  6. static float32_t  pCoeffs[5*2]={1,2,1,1.9184107565980049,-0.92769312589129826,         
    

  7.                                                                 1,2,1,1.8250960051409635,-0.83392686425555462};        
    

  8. static float32_t  pState[4*2];                        //4*numStages
    


  9. 


  10. 

  11. //arm_biquad_cascade_df1_f32  parameter
    

  12. static float32_t  pSrc[512];
    

  13. static float32_t  pDst[512];
    

  14. static uint32_t blockSize=1;
    


  15. 

  16. void dsp_test(void)
    

  17. {
    

  18.         u16 i=0;
    

  19.         for(i=0;i<512;i++)
    

  20.         {
    

  21.                 pSrc[i]=1.5f*arm_sin_f32(100*PI*i/6400)+0.5f*arm_sin_f32(900*PI*i/6400);
    

  22.         }
    

  23.         
    

  24.         arm_biquad_cascade_df1_init_f32(&S,numStages,pCoeffs,pState);
    

  25.         
    

  26.         for(i=0;i<(512/blockSize);i++)
    

  27.         {
    

  28.                 arm_biquad_cascade_df1_f32(&S,pSrc+i*blockSize,pDst+i*blockSize,blockSize);
    

  29.         }
    

  30.         
    

  31.         
    

  32.         printf("************\r\n");
    

  33.         for(i=0;i<512;i++)
    

  34.         {
    

  35.                 //Scale Values:                                                
    

  36.                 //0.0023205923233234451                                        
    

  37.                 //0.0022077147786478436
    

  38.                 printf("%f        %f\r\n",pSrc[i],pDst[i]*0.0023205923233234451f*0.0022077147786478436f);
    

  39.         }
    

  40. }
2439063b4118291219.png
回复

收藏1 举报

 楼主| zeshoufx 发表于 2023-1-3 19:29 | 显示全部楼层
zeshoufx 发表于 2023-1-3 19:29
5.滤波：滤波在信号处理中特别重要，在模拟前端经硬件滤波后，流入ADC，采集到的数据可能还达不到直接使 ...

6.高斯朴素贝叶斯分类器：高斯朴素贝叶斯分类器属于偏机器学习领域，通过给出符合高斯分布的均值和方差及分类，
输入待分类数据，即可将输入数据按先验数据进行分类。
复制
  1. arm_gaussian_naive_bayes_instance_f32 S;
    


  2. 

  3. #define SEMIHOSTING 1                        //使能
    

  4. #define NB_OF_CLASSES 3                        //类目
    

  5. #define VECTOR_DIMENSION 2                //向量维数
    


  6. 

  7. const float32_t theta[NB_OF_CLASSES*VECTOR_DIMENSION] = {
    

  8.   1.4539529436590528f, 0.8722776016801852f, 
    

  9.   -1.5267934452462473f, 0.903204577814203f, 
    

  10.   -0.15338006360932258f, -2.9997913665803964f
    

  11. }; /**< 高斯分布的均值 */
    


  12. 

  13. const float32_t sigma[NB_OF_CLASSES*VECTOR_DIMENSION] = {
    

  14.   1.0063470889514925f, 0.9038018246524426f, 
    

  15.   1.0224479953244736f, 0.7768764290432544f, 
    

  16.   1.1217662403241206f, 1.2303890106020325f
    

  17. }; /**< 高斯分布的方差 */
    


  18. 

  19. const float32_t classPriors[NB_OF_CLASSES] = {
    

  20.   0.3333333333333333f, 0.3333333333333333f, 0.3333333333333333f
    

  21. }; /**< 类先验概率 */
    


  22. 


  23. 

  24. void dsp_test(void)
    

  25. {
    

  26.         /* 输入数组 */
    

  27.   float32_t in[2];
    


  28. 

  29.   /* 分类器结果 */
    

  30.   float32_t result[NB_OF_CLASSES];
    

  31.   float32_t maxProba;
    

  32.   uint32_t index;
    

  33.   
    

  34.   S.vectorDimension = VECTOR_DIMENSION;         //向量空间维数
    

  35.   S.numberOfClasses = NB_OF_CLASSES;                 //不同类数目
    

  36.   S.theta = theta;                                                         //高斯分布均值         
    

  37.   S.sigma = sigma;                                                         //高斯分布方差        
    

  38.   S.classPriors = classPriors;                          //先验概率  
    

  39.   S.epsilon=4.328939296523643e-09f;                 //方差的叠加值
    


  40. 

  41.   in[0] = 1.5f;
    

  42.   in[1] = 1.0f;
    


  43. 

  44.   index = arm_gaussian_naive_bayes_predict_f32(&S, in,result);
    


  45. 

  46.   maxProba = result[index]; 
    

  47. #if defined(SEMIHOSTING)
    

  48.   printf("Class = %d\n", index);
    

  49.   printf("Max proba = %f\n", (double)maxProba);
    

  50. #endif
    


  51. 

  52.   in[0] = -1.5f;
    

  53.   in[1] = 1.0f;
    


  54. 

  55.   index = arm_gaussian_naive_bayes_predict_f32(&S, in,result);
    


  56. 

  57.   maxProba = result[index];
    

  58. #if defined(SEMIHOSTING)
    

  59.   printf("Class = %d\n", index);
    

  60.   printf("Max proba = %f\n", (double)maxProba);
    

  61. #endif
    


  62. 

  63.   in[0] = 0.0f;
    

  64.   in[1] = -3.0f;
    


  65. 

  66.   index = arm_gaussian_naive_bayes_predict_f32(&S, in,result);
    


  67. 

  68.   maxProba = result[index];
    

  69. #if defined(SEMIHOSTING)
    

  70.   printf("Class = %d\n", index);
    

  71.   printf("Max proba = %f\n", (double)maxProba);
    

  72. #endif
    


  73. 


  74. 

  75. }


回复

收藏1 举报

 楼主| zeshoufx 发表于 2023-1-3 19:30 | 显示全部楼层
zeshoufx 发表于 2023-1-3 19:29
6.高斯朴素贝叶斯分类器：高斯朴素贝叶斯分类器属于偏机器学习领域，通过给出符合高斯分布的均值和方差及 ...

7.插值：插值在数据分析和处理中较常用，有时数据量不够，可以通过一些插值手段，将数据进行丰富，方便分析。
常规的插值有线性插值、样条插值。测试主要针对样条插值，给出32点的正弦信号，通过插值方法将数据点拓展到
128点，分别对自然样条插值和抛物样条插值进行测试和对比。
复制
  1. void dsp_test(void)
    

  2. {
    

  3.         u8 i=0;
    

  4.         float32_t data[128]={0.};
    

  5.         for(i=0;i<128;i++)
    

  6.         {
    

  7.                 data[i]=1.6f+arm_sin_f32(100*PI*i/6400)+0.3f*arm_sin_f32(300*PI*i/6400)+0.5f*arm_sin_f32(700*PI*i/6400);
    

  8.                 printf("%f\r\n",data[i]);
    

  9.         }
    

  10. }
    


  11. 


  12. 


  13. 

  14. //arm_spline_init_f32  parameter
    

  15. static arm_spline_instance_f32  S;                                //样条插值结构体
    

  16. static arm_spline_type type=ARM_SPLINE_NATURAL;        //自然样条插值
    

  17. static float32_t  x[32];                                                //原始数据x
    

  18. static float32_t  y[32];                                                //原始数据y
    

  19. static uint32_t n=32;                                                        //原始数据个数
    

  20. static float32_t  coeffs[3*(32-1)];
    

  21. static float32_t  tempBuffer[2*(32-1)];
    

  22.         
    


  23. 

  24. //arm_spline_f32   parameter
    

  25. static float32_t  xq[128];
    

  26. static float32_t  pDst[128];
    

  27. static uint32_t blockSize=128;
    


  28. 

  29. #define num_tab 128/32
    


  30. 

  31. void interp_test(u8 mode)
    

  32. {
    

  33.         if(mode)
    

  34.         {
    

  35.                 type=ARM_SPLINE_NATURAL;//自然样条插值
    

  36.         }
    

  37.         else
    

  38.         {
    

  39.                 type=ARM_SPLINE_PARABOLIC_RUNOUT;//抛物样条插值
    

  40.         }
    

  41.         
    

  42.         u8 i=0;
    

  43.         for(i=0;i<32;i++)
    

  44.         {
    

  45.                 x[i]=i*num_tab;
    

  46.                 y[i]=1.f+arm_sin_f32(100.f*PI*i/256.f+PI/3.f);
    

  47.         }
    

  48.         
    

  49.         for(i=0;i<128;i++)
    

  50.         {
    

  51.                 xq[i]=i;
    

  52.         }
    

  53.         
    

  54.         arm_spline_init_f32(&S,type,x,y,n,coeffs,tempBuffer);
    

  55.         arm_spline_f32(&S,xq,pDst,blockSize);
    

  56.         
    

  57.         printf("*****x********\r\n");
    

  58.         for(i=0;i<32;i++)
    

  59.         {
    

  60.                 printf("%f\r\n",x[i]);
    

  61.         }
    

  62.         printf("*****y********\r\n");
    

  63.         for(i=0;i<32;i++)
    

  64.         {
    

  65.                 printf("%f\r\n",y[i]);
    

  66.         }
    

  67.         
    

  68.         
    

  69.         printf("*****x1********\r\n");
    

  70.         for(i=0;i<128;i++)
    

  71.         {
    

  72.                 printf("%f\r\n",xq[i]);
    

  73.         }
    

  74.         
    

  75.         printf("*****y1********\r\n");
    

  76.         for(i=0;i<128;i++)
    

  77.         {
    

  78.                 printf("%f\r\n",pDst[i]);
    

  79.         }
    

  80. }
2125463b411ead0032.png

回复

收藏1 举报

 楼主| zeshoufx 发表于 2023-1-3 19:32 | 显示全部楼层
zeshoufx 发表于 2023-1-3 19:30
7.插值：插值在数据分析和处理中较常用，有时数据量不够，可以通过一些插值手段，将数据进行丰富，方便分 ...

8.矩阵运算：矩阵运算包括矩阵加、减、乘、逆运算、转置、数乘等
复制
  1. arm_matrix_instance_f32  S;
    

  2. arm_matrix_instance_f32  S1;
    

  3. arm_matrix_instance_f32  S2;
    

  4. uint16_t nRows=5;
    

  5. uint16_t nColumns=5;
    


  6. 


  7. 

  8. static void dsp_test1(void)
    

  9. {
    

  10.         float32_t  pData[25]={17,24,1,8,15,
    

  11.                                                 23,5,7,14,16,
    

  12.                                                 4,6,13,20,22,
    

  13.                                                 10,12,19,21,3,
    

  14.                                                 11,18,25,2,9};
    


  15. 

  16.         float32_t  pData1[25]={3,3,3,3,3,
    

  17.                                                 3,3,3,3,3,
    

  18.                                                 3,3,3,3,3,
    

  19.                                                 3,3,3,3,3,
    

  20.                                                 3,3,3,3,3};        
    


  21. 

  22.         float32_t  pData2[25]={0,0,0,0,0,
    

  23.                                                 0,0,0,0,0,
    

  24.                                                 0,0,0,0,0,
    

  25.                                                 0,0,0,0,0,
    

  26.                                                 0,0,0,0,0};        
    

  27.         
    

  28.         u8 i=0;
    

  29.         arm_mat_init_f32(&S,nRows,nColumns,pData);
    

  30.         arm_mat_init_f32(&S1,nRows,nColumns,pData1);
    

  31.         arm_mat_init_f32(&S2,nRows,nColumns,pData2);
    

  32.         
    

  33.         
    

  34.         printf("矩阵A=\r\n");
    

  35.         for(i=0;i<25;i++)
    

  36.         {
    

  37.                 printf("%f        ",S.pData[i]);
    

  38.                 if(i%5==4)
    

  39.                 {
    

  40.                         printf("\r\n");
    

  41.                 }
    

  42.         }
    

  43.         
    

  44.         printf("\r\n");
    

  45.         printf("矩阵B=\r\n");
    

  46.         for(i=0;i<25;i++)
    

  47.         {
    

  48.                 printf("%f        ",S1.pData[i]);
    

  49.                 if(i%5==4)
    

  50.                 {
    

  51.                         printf("\r\n");
    

  52.                 }
    

  53.         }
    

  54.         
    

  55.         arm_mat_add_f32(&S,&S1,&S2);
    

  56.         printf("\r\n");
    

  57.         printf("矩阵A+B=\r\n");
    

  58.         for(i=0;i<25;i++)
    

  59.         {
    

  60.                 printf("%f        ",S2.pData[i]);
    

  61.                 if(i%5==4)
    

  62.                 {
    

  63.                         printf("\r\n");
    

  64.                 }
    

  65.         }
    

  66.         
    

  67.         arm_mat_mult_f32(&S,&S1,&S2);
    

  68.         printf("\r\n");
    

  69.         printf("矩阵A*B=\r\n");
    

  70.         for(i=0;i<25;i++)
    

  71.         {
    

  72.                 printf("%f        ",S2.pData[i]);
    

  73.                 if(i%5==4)
    

  74.                 {
    

  75.                         printf("\r\n");
    

  76.                 }
    

  77.         }
    

  78.         
    

  79.         arm_mat_inverse_f32(&S,&S2);
    

  80.         printf("\r\n");
    

  81.         printf("矩阵A的逆矩阵=\r\n");
    

  82.         for(i=0;i<25;i++)
    

  83.         {
    

  84.                 printf("%f        ",S2.pData[i]);
    

  85.                 if(i%5==4)
    

  86.                 {
    

  87.                         printf("\r\n");
    

  88.                 }
    

  89.         }
    

  90.         
    

  91. }
    


  92. 

  93. static void dsp_test2(void)
    

  94. {
    

  95.         u8 i=0;
    

  96.         
    

  97.         float32_t  pData[25]={17,24,1,8,15,
    

  98.                                                 23,5,7,14,16,
    

  99.                                                 4,6,13,20,22,
    

  100.                                                 10,12,19,21,3,
    

  101.                                                 11,18,25,2,9};
    


  102. 

  103.         float32_t  pData1[25]={3,3,3,3,3,
    

  104.                                                 3,3,3,3,3,
    

  105.                                                 3,3,3,3,3,
    

  106.                                                 3,3,3,3,3,
    

  107.                                                 3,3,3,3,3};        
    


  108. 

  109.         float32_t  pData2[25]={0,0,0,0,0,
    

  110.                                                 0,0,0,0,0,
    

  111.                                                 0,0,0,0,0,
    

  112.                                                 0,0,0,0,0,
    

  113.                                                 0,0,0,0,0};        
    

  114.         
    

  115.         arm_mat_init_f32(&S,nRows,nColumns,pData);
    

  116.         arm_mat_init_f32(&S1,nRows,nColumns,pData1);
    

  117.         arm_mat_init_f32(&S2,nRows,nColumns,pData2);
    

  118.         
    

  119.         arm_mat_scale_f32(&S,0.1f,&S2);
    

  120.         printf("\r\n");
    

  121.         printf("矩阵A*0.1=\r\n");
    

  122.         for(i=0;i<25;i++)
    

  123.         {
    

  124.                 printf("%f        ",S2.pData[i]);
    

  125.                 if(i%5==4)
    

  126.                 {
    

  127.                         printf("\r\n");
    

  128.                 }
    

  129.         }
    

  130.         
    

  131.         
    

  132.         arm_mat_sub_f32(&S,&S1,&S2);
    

  133.         printf("\r\n");
    

  134.         printf("矩阵A-B=\r\n");
    

  135.         for(i=0;i<25;i++)
    

  136.         {
    

  137.                 printf("%f        ",S2.pData[i]);
    

  138.                 if(i%5==4)
    

  139.                 {
    

  140.                         printf("\r\n");
    

  141.                 }
    

  142.         }
    

  143.         
    

  144.         
    

  145.         arm_mat_trans_f32(&S,&S2);
    

  146.         printf("\r\n");
    

  147.         printf("矩阵A的转置=\r\n");
    

  148.         for(i=0;i<25;i++)
    

  149.         {
    

  150.                 printf("%f        ",S2.pData[i]);
    

  151.                 if(i%5==4)
    

  152.                 {
    

  153.                         printf("\r\n");
    

  154.                 }
    

  155.         }
    

  156. }
    


  157. 

  158. void dsp_test(void)
    

  159. {
    

  160.         dsp_test1();
    

  161.         dsp_test2();
    

  162. }
490063b412468f589.png

6592663b412559c96d.png

回复

收藏1 举报

 楼主| zeshoufx 发表于 2023-1-3 19:33 | 显示全部楼层
zeshoufx 发表于 2023-1-3 19:32
8.矩阵运算：矩阵运算包括矩阵加、减、乘、逆运算、转置、数乘等

9.PID控制：PID控制在工业领域较为常用，尤其是自动化控制。PID初始化函数arm_pid_init_f32，PID控制函数为
arm_pid_f32，测试采用DAC输出连接到ADC输入，PID控制调节DAC输入参数，让ADC采集结果稳定输出在2678。
复制
  1. arm_pid_instance_f32 S;                //定义PID结构体
    

  2. float ref=2678./4095*3.3;        //ADC参考目标值：2678
    


  3. 

  4. void ad_da_init(void)
    

  5. {
    

  6.         //时钟配置
    

  7.         rcu_periph_clock_enable(RCU_GPIOA);
    

  8.         rcu_periph_clock_enable(RCU_AF);
    

  9.         rcu_periph_clock_enable(RCU_ADC0);
    

  10.         rcu_periph_clock_enable(RCU_DAC);
    

  11.         
    

  12.         rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV12);
    

  13.         
    

  14.         //接口配置
    

  15.         gpio_init(GPIOA,GPIO_MODE_AIN,GPIO_OSPEED_50MHZ,GPIO_PIN_4);
    

  16.         gpio_init(GPIOA,GPIO_MODE_AIN,GPIO_OSPEED_50MHZ,GPIO_PIN_6);
    

  17.         
    

  18.         //ADC输入配置
    

  19.         adc_special_function_config(ADC0,ADC_CONTINUOUS_MODE,ENABLE);
    

  20.         adc_data_alignment_config(ADC0,ADC_DATAALIGN_RIGHT);
    

  21.         adc_channel_length_config(ADC0,ADC_REGULAR_CHANNEL,1);
    

  22.         adc_regular_channel_config(ADC0,0,ADC_CHANNEL_6,ADC_SAMPLETIME_55POINT5);
    

  23.         adc_external_trigger_config(ADC0,ADC_REGULAR_CHANNEL,DISABLE);
    

  24.         
    

  25.         adc_enable(ADC0);
    

  26.         delay_ms(1);
    

  27.         adc_calibration_enable(ADC0);
    

  28.         
    

  29.         //DAC输出配置
    

  30.         dac_trigger_source_config(DAC0,DAC_TRIGGER_SOFTWARE);
    

  31.         dac_trigger_enable(DAC0);
    

  32.         dac_wave_mode_config(DAC0,DAC_WAVE_DISABLE);
    

  33.         dac_output_buffer_enable(DAC0);
    

  34.         
    

  35.         dac_enable(DAC0);
    

  36.         
    

  37.         //PID参数初始化
    

  38.         S.Kd=0;
    

  39.         S.Ki=16;
    

  40.         S.Kp=100;
    


  41. 

  42.         arm_pid_init_f32(&S,1);
    

  43. }
    


  44. 


  45. 


  46. 

  47. volatile float adc_get=0.;
    


  48. 

  49. void dsp_test(void)
    

  50. {
    

  51.          
    

  52.         float32_t pid_num=0.;
    

  53.         
    

  54.         pid_num=arm_pid_f32(&S,ref-adc_get);        //PID处理，输入为误差信号
    


  55. 

  56.         if(pid_num>=4095)
    

  57.         {
    

  58.                 pid_num=4095;
    

  59.         }
    

  60.     dac_data_set(DAC0, DAC_ALIGN_12B_R, (u16)pid_num);
    

  61.        
    

  62.     dac_software_trigger_enable(DAC0);
    

  63.         
    

  64.         adc_software_trigger_enable(ADC0,ADC_REGULAR_CHANNEL);
    

  65.         if(adc_flag_get(ADC0,ADC_FLAG_EOC))
    

  66.         {
    

  67.                 adc_flag_clear(ADC0,ADC_FLAG_EOC);
    

  68.                 adc_get = adc_regular_data_read(ADC0)/4095.*3.3;
    

  69.         }
    

  70.         
    

  71.         printf("%f        %d        %d\r\n",adc_get,(u16)pid_num,adc_regular_data_read(ADC0));
    

  72. }
6103963b41284d73c0.png

回复

收藏1 举报

 楼主| zeshoufx 发表于 2023-1-3 19:34 | 显示全部楼层
zeshoufx 发表于 2023-1-3 19:33
9.PID控制：PID控制在工业领域较为常用，尤其是自动化控制。PID初始化函数arm_pid_init_f32，PID控制函数 ...

10。支持向量机分类器：支持向量机与贝叶斯分类器同属于机器学习领域，支持向量机分类器有线性和非线性，
对类A和类B进行标识，输入数据A和B，通过分类器计算结果，对输入数据进行分类，因为例程提供的是线性的SVM分类器，
截距为-1.6617。
复制
  1. #define SEMIHOSTING 1                                //使能打印
    


  2. 


  3. 

  4. //支持向量机实例化结构体，所有参数可以通过python生成
    

  5. arm_svm_polynomial_instance_f32 params;
    


  6. 


  7. 

  8. //通过使用scikit-learn包和一些随机输入数据对SVM分类器进行训练生成的参数
    

  9. #define NB_SUPPORT_VECTORS 11  //向量个数
    


  10. 


  11. 

  12. //向量空间的维数
    

  13. #define VECTOR_DIMENSION 2
    


  14. 

  15. const float32_t dualCoefficients[NB_SUPPORT_VECTORS]={-0.01628988f, -0.0971605f,
    

  16.   -0.02707579f,  0.0249406f,   0.00223095f,  0.04117345f,
    

  17.   0.0262687f,   0.00800358f,  0.00581823f,  0.02346904f,  0.00862162f}; /* Dual coefficients */
    


  18. 

  19. const float32_t supportVectors[NB_SUPPORT_VECTORS*VECTOR_DIMENSION]={ 1.2510991f,   0.47782799f,
    

  20.  -0.32711859f, -1.49880648f, -0.08905047f,  1.31907242f,
    

  21.   1.14059333f,  2.63443767f, -2.62561524f,  1.02120701f,
    

  22.  -1.2361353f,  -2.53145187f,
    

  23.   2.28308122f, -1.58185875f,  2.73955981f,  0.35759327f,
    

  24.   0.56662986f,  2.79702016f,
    

  25.  -2.51380816f,  1.29295364f, -0.56658669f, -2.81944734f}; /* Support vectors */
    


  26. 


  27. 

  28. //类A标识为“0”，类B标识为“1”
    

  29. const int32_t   classes[2]={0,1};
    


  30. 


  31. 

  32. void dsp_test(void)
    

  33. {
    

  34.                 /* 输入数据 */
    

  35.         float32_t in[VECTOR_DIMENSION];
    

  36.         
    

  37.         /* 分类器结果 */
    

  38.         int32_t result;
    

  39.         
    

  40.         
    

  41.         
    

  42.                 //初始化支持向量机实例化结构体
    

  43.         arm_svm_polynomial_init_f32(¶ms,        //实例化结构体
    

  44.                 NB_SUPPORT_VECTORS,                                        //向量个数
    

  45.                 VECTOR_DIMENSION,                                        //向量维数
    

  46.                 -1.661719f,                                                //截距
    

  47.                 dualCoefficients,                                        //双系数
    

  48.                 supportVectors,                                                //支持向量
    

  49.                 classes,                                                        //类ID标识
    

  50.                 3,                                                         //多项式次数
    

  51.                 1.100000f,                                                 //python scikit-learn包专用系数 
    

  52.                 0.500000f                                                  //python scikit-learn包专用系数
    

  53.         );
    

  54.         
    

  55.         
    

  56.         //输入测试数据，类A
    

  57.         in[0] = 0.4f;
    

  58.         in[1] = 0.1f;
    

  59.         
    

  60.         arm_svm_polynomial_predict_f32(¶ms, in, &result);
    

  61.         
    

  62.         //根据分类标识：如果分类器结果为A，则标识必为“0”
    

  63.         #if defined(SEMIHOSTING)
    

  64.         printf("Result = %d\n", result);
    

  65.         #endif
    

  66.         
    

  67.         //输入测试数据，类B
    

  68.         in[0] = 3.0f;
    

  69.         in[1] = 0.0f;
    

  70.         
    

  71.         arm_svm_polynomial_predict_f32(¶ms, in, &result);
    

  72.         
    

  73.         //根据分类标识：如果分类器结果为A，则标识必为“1”
    

  74.         #if defined(SEMIHOSTING)
    

  75.         printf("Result = %d\n", result);
    

  76.         #endif
    

  77.         
    

  78. }
1.  采用ARM官方提供的DSP库
2.  所有测试经过与MATLAB测试对比
3.  软件采用MDK 5.35，DSP采用1.8.0版本，单片机采用GD32F103VKT6

回复

收藏1 举报

 楼主| zeshoufx 发表于 2023-1-3 19:37 | 显示全部楼层
zeshoufx 发表于 2023-1-3 19:34
10。支持向量机分类器：支持向量机与贝叶斯分类器同属于机器学习领域，支持向量机分类器有线性和非线性， ...

1、自适应滤波：采用基波叠加9次谐波，滤除9次谐波，对比了不同阶数和迭代次数的结果
复制
  1. #include "dsp_test.h"
    

  2. #include "systick.h"
    


  3. 

  4. #define F_COUNT 512
    

  5. #define M 16
    


  6. 

  7. /* xn--------输入的信号序列（列向量）
    

  8.  * itr-------迭代次数，标量，默认为xn的长度，M<itr<sizeof(xn)
    

  9.  * en--------误差序列（itr*1）列向量
    

  10.  * dn--------所期望的响应序列（列向量）
    

  11.  * M---------滤波器的阶数（标量）
    

  12.  * mu--------收敛因子（步长）标量
    

  13.  * W---------滤波器权值矩阵，大小为M*itr
    

  14.  * yn--------实际输出序列（列向量）*/
    


  15. 


  16. 

  17. /*LMS具体算法*/
    

  18. //float * LMS_Filter(int itr, const float *xn, const float *dn, float mu, int length);
    

  19. void LMS_Filter(int itr, const float *xn, const float *dn, float mu, int length,float *yn)
    

  20. {
    

  21.     static int i = 0;
    

  22.     static int k = 0;
    

  23.     static float y = 0.0;
    

  24.     static float en[F_COUNT];
    

  25.     static float W[M][F_COUNT];
    

  26.     static float x[M];
    


  27. 

  28.     /*创建一个en全零矩阵，en(k)表示第k次迭代时预期输出与实际输入的误差*/
    

  29.     for (i=0; i<itr; i++)
    

  30.     {
    

  31.         en[i] = 0;
    

  32.     }
    


  33. 

  34.     /*创建一个W全零矩阵，每一行代表一个加权参量，每一列代表一次迭代*/
    

  35.     for (i=0; i<M; i++)
    

  36.         for (k=0; k<itr; k++)
    

  37.             W[i][k] = 0;
    


  38. 

  39.     /*创建一个x全零矩阵*/
    

  40.     for (i=0; i<M; i++)
    

  41.         x[i] = 0;
    


  42. 

  43.     /*迭代计算*/
    

  44.     for (k=M; k<=itr; k++)
    

  45.     {
    

  46.         /* 滤波器M个抽头的输入：从xn第k-1个值倒序取出M个样点的值放入x
    

  47.          * y为滤波器输出：W的第K-2列与x的积的和*/
    

  48.         for (i=0; i<M; i++)
    

  49.         {
    

  50.             x[i] = xn[k-i-1];
    

  51.             y += W[i][k-2] * x[i];
    

  52.         }        
    


  53. 

  54.         en[k-1] = dn[k-1] - y;  //第k次迭代的误差
    


  55. 

  56.         /*滤波器权值计算的迭代式*/
    

  57.         for (i=0; i<M; i++)
    

  58.         {
    

  59.             W[i][k-1] = W[i][k-2] + 2*mu*en[k-1]*x[i];
    

  60.         }
    


  61. 

  62.         y = 0.0;
    

  63.     }
    


  64. 

  65.     /*创建一个yn全无穷大矩阵，维数与xn一样*/
    

  66.     for (i=0; i<itr; i++)
    

  67.     {
    

  68.         yn[i] = 0.0;
    

  69.     }
    


  70. 

  71.     /*求最优时滤波器的输出序列*/
    

  72.     for (k=M; k<=length; k++)
    

  73.     {
    

  74.         for (i=0; i<M; i++)
    

  75.         {
    

  76.             x[i] = xn[k-i-1];
    

  77.             y += W[i][itr-1]*x[i];
    

  78.         }
    


  79. 

  80.         yn[k-1] = y;
    

  81.         y = 0.0;
    


  82. 

  83.     }
    


  84. 

  85. }
    


  86. 


  87. 

  88. float xn[512]={0.},dn[512]={0.};
    

  89. float yn[512]={0.};
    


  90. 

  91. void dsp_test(void)
    

  92. {
    

  93.         u16 i=0;
    

  94.         for(i=0;i<512;i++)
    

  95.         {
    

  96.                 xn[i]=1.5f*arm_sin_f32(100*PI*i/6400)+0.5f*arm_sin_f32(900*PI*i/6400);
    

  97.         }
    

  98.         
    

  99.         for(i=0;i<512;i++)
    

  100.         {
    

  101.                 dn[i]=1.5f*arm_sin_f32(100*PI*i/6400);
    

  102.         }
    

  103.         
    

  104.         
    

  105.         LMS_Filter(128, xn, dn, 0.0008, 512,yn);
    

  106.         
    

  107.         
    

  108.         for(i=0;i<512;i++)
    

  109.         {
    

  110.                 printf("%f        %f        %f\r\n",xn[i],dn[i],yn[i]);
    

  111.         }
    

  112. }
20阶迭代22次结果：
6291763b4131bbf5f5.png

20阶迭代100次结果：
152263b4133290dc2.png

20阶迭代300次结果：
4343463b41346530f5.png

10阶100次迭代结果：
8568063b41358b6e42.png

32阶100次迭代结果：
7235463b4136c255d0.png

16阶128次迭代结果：
6826063b4137fbbc30.png



回复

收藏1 举报

 楼主| zeshoufx 发表于 2023-1-3 19:38 | 显示全部楼层
zeshoufx 发表于 2023-1-3 19:37
1、自适应滤波：采用基波叠加9次谐波，滤除9次谐波，对比了不同阶数和迭代次数的结果20阶迭代22次结果：
...

蚁群算法：蚁群算法作为群体智能优化的代表，与全局搜索算法比较具有速度快的特点
复制
  1. #include "dsp_test.h"
    


  2. 


  3. 


  4. 

  5. /*Include头文件*/
    

  6. #include <stdio.h>
    

  7. #include <stdlib.h>
    


  8. 

  9. /*   符号常数的定义                 */
    

  10. #define NOA 10 /*蚂蚁的个体数*/
    

  11. #define ILIMIT 50 /*循环次数*/
    

  12. #define Q 3 /*信息素更新的常数*/
    

  13. #define RHO 0.8 /*挥发常数*/
    

  14. #define STEPS 10 /*路程的步数*/
    

  15. #define EPSILON 0.15 /*确定行动选择的随机性*/
    

  16. #define SEED 32768 /*随机数的Seed*/
    


  17. 


  18. 

  19. /*   函数原型声明      */
    

  20. void printp(double pheromone[2][STEPS]) ;/*显示*/
    

  21. void printmSTEPS(int mSTEPS[NOA][STEPS]) ;
    

  22.                              /*显示蚂蚁的行动*/
    

  23. void walk(int cost[2][STEPS]
    

  24.           ,double pheromone[2][STEPS]
    

  25.           ,int mSTEPS[NOA][STEPS] ) ;/*使蚂蚁步行*/
    

  26. void update(int cost[2][STEPS]
    

  27.          ,double pheromone[2][STEPS]
    

  28.         ,int mSTEPS[NOA][STEPS] ) ;/*更新信息素*/
    

  29. double rand1(void) ;/*返回0～1实数的随机函数*/
    

  30. int rand01(void) ;/*返回0、1的随机函数*/
    


  31. 


  32. 


  33. 


  34. 

  35. /**************************/
    

  36. /*    update()函数        */
    

  37. /*    更新信息素          */
    

  38. /**************************/
    

  39. void update(int cost[2][STEPS]
    

  40.         ,double pheromone[2][STEPS]
    

  41.         ,int mSTEPS[NOA][STEPS] )
    

  42. {
    

  43.         int m ;/*蚂蚁个体的号码*/
    

  44.         int lm ;/*蚂蚁步行的距离*/
    

  45.         int i,j ;
    

  46.         double sum_lm=0 ;/*蚂蚁步行的总体距离*/
    

  47.         
    

  48.         /*信息素的挥发*/
    

  49.         for(i=0;i<2;++i)
    

  50.                 for(j=0;j<STEPS;++j)
    

  51.                         pheromone[i][j]*=RHO ;
    

  52.         
    

  53.         /*蚂蚁的覆盖*/
    

  54.         for(m=0;m<NOA;++m)
    

  55.         {
    

  56.         /*个体m的移动距离lm的计算*/
    

  57.         lm=0 ;
    

  58.         for(i=0;i<STEPS;++i)
    

  59.                 lm+=cost[mSTEPS[m][i]][i] ;
    

  60.         
    

  61.         /*信息素的覆盖*/
    

  62.         for(i=0;i<STEPS;++i)
    

  63.                 pheromone[mSTEPS[m][i]][i]+=Q*(1.0/lm) ;
    

  64.         sum_lm+=lm ;
    

  65.         }
    

  66.         /*蚂蚁步行的平均距离的输出*/
    

  67.         printf("%lf\n",sum_lm/NOA) ;
    

  68. }
    


  69. 

  70. /**************************/
    

  71. /*    walk()函数          */
    

  72. /*    使蚂蚁步行          */
    

  73. /**************************/
    

  74. void walk(int cost[2][STEPS]
    

  75. ,double pheromone[2][STEPS],int mSTEPS[NOA][STEPS])
    

  76. {
    

  77.         int m ;/*蚂蚁个体的号码*/
    

  78.         int s ;/*蚂蚁现在所处的位置*/
    

  79.         
    

  80.         for(m=0;m<NOA;++m)
    

  81.         {
    

  82.                 for(s=0;s<STEPS;++s)
    

  83.                 {
    

  84.                         /*基于ε-greedy的行动选择*/
    

  85.                         if((rand1()<EPSILON)||(abs(pheromone[0][s]-pheromone[1][s])<1e-9))
    

  86.                         {
    

  87.                                 /*随机行动*/
    

  88.                                 mSTEPS[m][s]=rand01() ;
    

  89.                         }
    

  90.                         else
    

  91.                         {/*基于信息素的选择*/
    

  92.                                 if(pheromone[0][s]>pheromone[1][s]) 
    

  93.                                         mSTEPS[m][s]=0 ;
    

  94.                                 else
    

  95.                                         mSTEPS[m][s]=1 ;
    

  96.                         }
    

  97.                 }
    

  98.         }
    

  99.  /*输出蚂蚁的行动*/
    

  100.  printmSTEPS(mSTEPS) ;
    

  101. }
    


  102. 

  103. /**************************/
    

  104. /*  printmSTEPS()函数      */
    

  105. /*   显示蚂蚁的行动       */
    

  106. /**************************/
    

  107. void printmSTEPS(int mSTEPS[NOA][STEPS])
    

  108. {
    

  109.         int i,j ;
    

  110.         
    

  111.         printf("*mSTEPS\n") ;
    

  112.         for(i=0;i<NOA;++i)
    

  113.         {
    

  114.                 for(j=0;j<STEPS;++j)
    

  115.                 printf("%d ",mSTEPS[i][j]) ;
    

  116.                 printf("\n") ;
    

  117.         }
    

  118. }
    


  119. 


  120. 

  121. /**************************/
    

  122. /*    printp()函数        */
    

  123. /*   显示信息素           */
    

  124. /**************************/
    

  125. void printp(double pheromone[2][STEPS]) 
    

  126. {
    

  127.         int i,j ;
    

  128.         
    

  129.         for(i=0;i<2;++i)
    

  130.         {
    

  131.                 for(j=0;j<STEPS;++j)
    

  132.                 printf("%4.2lf ",pheromone[i][j]) ;
    

  133.                 printf("\n") ;
    

  134.         }
    

  135. }
    


  136. 

  137. /**************************/
    

  138. /*    rand1()函数         */
    

  139. /*返回0～1的实数的随机函数*/
    

  140. /**************************/
    

  141. double rand1(void)
    

  142. {
    

  143.         /*随机数的计算*/
    

  144.         return (double)rand()/RAND_MAX ;
    


  145. 

  146. }
    


  147. 

  148. /****************************/
    

  149. /*     rand01()函数         */
    

  150. /*返回0、1的随机函数        */
    

  151. /****************************/
    

  152. int rand01(void)
    

  153. {
    

  154.         int rnd ;
    

  155.         
    

  156.         /*去除随机数的最大值*/
    

  157.         while((rnd=rand())==RAND_MAX) ;
    

  158.         /*计算随机数*/ 
    

  159.         return (int)((double)rnd/RAND_MAX*2) ;
    


  160. 

  161. }
    


  162. 


  163. 

  164. void dsp_test(void)
    

  165. {
    

  166.         int cost[2][STEPS]={/*各步的代价（距离）*/
    

  167.          {1,1,1,1,1,1,1,1,1,1},
    

  168.          {5,5,5,5,5,5,5,5,5,5}};
    

  169.         double pheromone[2][STEPS]={0} ;/*各步的信息素量*/
    

  170.         int mSTEPS[NOA][STEPS] ;/*蚂蚁走过的过程*/
    

  171.         int i;/*循环次数的控制*/
    

  172.         
    

  173.         /*随机数的初始化*/
    

  174.         srand(SEED) ;
    

  175.         
    

  176.         /*最优化的主体*/
    

  177.         for(i=0;i<ILIMIT;++i)
    

  178.         {
    

  179.                 /*信息素的状态的输出*/
    

  180.                 printf("%d:\n",i) ;
    

  181.                 printp(pheromone) ;
    

  182.                 /*使蚂蚁步行*/
    

  183.                 walk(cost,pheromone,mSTEPS) ;
    

  184.                 /*更新信息素*/
    

  185.                 update(cost,pheromone,mSTEPS) ;
    

  186.         }
    

  187.         /*信息素状态的输出*/
    

  188.         printf("%d:\n",i) ;
    

  189.         printp(pheromone) ;
    

  190. }


回复

收藏1 举报

 楼主| zeshoufx 发表于 2023-1-3 19:40 | 显示全部楼层
zeshoufx 发表于 2023-1-3 19:38
蚁群算法：蚁群算法作为群体智能优化的代表，与全局搜索算法比较具有速度快的特点

...

卷积神经网络：卷积神经网络在图像处理等领域中运用广泛，在ARM官方提供的CMSIS-NN库中，就包含了卷积神经网络，
本例就是移植官方的例子，在分类器中的运用。
复制
  1. #include <stdint.h>
    

  2. #include <stdio.h>
    

  3. #include "arm_math.h"
    

  4. #include "arm_nnexamples_cifar10_parameter.h" 
    

  5. #include "arm_nnexamples_cifar10_weights.h"
    


  6. 

  7. #include "arm_nnfunctions.h"
    

  8. #include "arm_nnexamples_cifar10_inputs.h"
    


  9. 

  10. #ifdef _RTE_
    

  11. #include "RTE_Components.h"
    

  12. #ifdef RTE_Compiler_EventRecorder
    

  13. #include "EventRecorder.h"
    

  14. #endif
    

  15. #endif
    


  16. 

  17. // include the input and weights
    


  18. 

  19. static q7_t conv1_wt[CONV1_IM_CH * CONV1_KER_DIM * CONV1_KER_DIM * CONV1_OUT_CH] = CONV1_WT;
    

  20. static q7_t conv1_bias[CONV1_OUT_CH] = CONV1_BIAS;
    


  21. 

  22. static q7_t conv2_wt[CONV2_IM_CH * CONV2_KER_DIM * CONV2_KER_DIM * CONV2_OUT_CH] = CONV2_WT;
    

  23. static q7_t conv2_bias[CONV2_OUT_CH] = CONV2_BIAS;
    


  24. 

  25. static q7_t conv3_wt[CONV3_IM_CH * CONV3_KER_DIM * CONV3_KER_DIM * CONV3_OUT_CH] = CONV3_WT;
    

  26. static q7_t conv3_bias[CONV3_OUT_CH] = CONV3_BIAS;
    


  27. 

  28. static q7_t ip1_wt[IP1_DIM * IP1_OUT] = IP1_WT;
    

  29. static q7_t ip1_bias[IP1_OUT] = IP1_BIAS;
    


  30. 

  31. /* Here the image_data should be the raw uint8 type RGB image in [RGB, RGB, RGB ... RGB] format */
    

  32. uint8_t   image_data[CONV1_IM_CH * CONV1_IM_DIM * CONV1_IM_DIM] = IMG_DATA;
    

  33. q7_t      output_data[IP1_OUT];
    


  34. 

  35. //vector buffer: max(im2col buffer,average pool buffer, fully connected buffer)
    

  36. q7_t      col_buffer[2 * 5 * 5 * 32 * 2];
    


  37. 

  38. q7_t      scratch_buffer[32 * 32 * 10 * 4];
    


  39. 


  40. 


  41. 


  42. 

  43. void dsp_test(void)
    

  44. {
    

  45.         
    

  46.  #ifdef RTE_Compiler_EventRecorder
    

  47.   EventRecorderInitialize (EventRecordAll, 1);  // initialize and start Event Recorder
    

  48.   #endif
    


  49. 

  50.   printf("start execution\n");
    

  51.   /* start the execution */
    


  52. 

  53.   q7_t     *img_buffer1 = scratch_buffer;
    

  54.   q7_t     *img_buffer2 = img_buffer1 + 32 * 32 * 32;
    


  55. 

  56.   /* input pre-processing */
    

  57.   int mean_data[3] = INPUT_MEAN_SHIFT;
    

  58.   unsigned int scale_data[3] = INPUT_RIGHT_SHIFT;
    

  59.   for (int i=0;i<32*32*3; i+=3) {
    

  60.     img_buffer2[i] =   (q7_t)__SSAT( ((((int)image_data[i]   - mean_data[0])<<7) + (0x1<<(scale_data[0]-1)))
    

  61.                              >> scale_data[0], 8);
    

  62.     img_buffer2[i+1] = (q7_t)__SSAT( ((((int)image_data[i+1] - mean_data[1])<<7) + (0x1<<(scale_data[1]-1)))
    

  63.                              >> scale_data[1], 8);
    

  64.     img_buffer2[i+2] = (q7_t)__SSAT( ((((int)image_data[i+2] - mean_data[2])<<7) + (0x1<<(scale_data[2]-1)))
    

  65.                              >> scale_data[2], 8);
    

  66.   }
    

  67.   
    

  68.   // conv1 img_buffer2 -> img_buffer1
    

  69.   arm_convolve_HWC_q7_RGB(img_buffer2, CONV1_IM_DIM, CONV1_IM_CH, conv1_wt, CONV1_OUT_CH, CONV1_KER_DIM, CONV1_PADDING,
    

  70.                           CONV1_STRIDE, conv1_bias, CONV1_BIAS_LSHIFT, CONV1_OUT_RSHIFT, img_buffer1, CONV1_OUT_DIM,
    

  71.                           (q15_t *) col_buffer, NULL);
    


  72. 

  73.   arm_relu_q7(img_buffer1, CONV1_OUT_DIM * CONV1_OUT_DIM * CONV1_OUT_CH);
    


  74. 

  75.   // pool1 img_buffer1 -> img_buffer2
    

  76.   arm_maxpool_q7_HWC(img_buffer1, CONV1_OUT_DIM, CONV1_OUT_CH, POOL1_KER_DIM,
    

  77.                      POOL1_PADDING, POOL1_STRIDE, POOL1_OUT_DIM, NULL, img_buffer2);
    


  78. 

  79.   // conv2 img_buffer2 -> img_buffer1
    

  80.   arm_convolve_HWC_q7_fast(img_buffer2, CONV2_IM_DIM, CONV2_IM_CH, conv2_wt, CONV2_OUT_CH, CONV2_KER_DIM,
    

  81.                            CONV2_PADDING, CONV2_STRIDE, conv2_bias, CONV2_BIAS_LSHIFT, CONV2_OUT_RSHIFT, img_buffer1,
    

  82.                            CONV2_OUT_DIM, (q15_t *) col_buffer, NULL);
    


  83. 

  84.   arm_relu_q7(img_buffer1, CONV2_OUT_DIM * CONV2_OUT_DIM * CONV2_OUT_CH);
    


  85. 

  86.   // pool2 img_buffer1 -> img_buffer2
    

  87.   arm_maxpool_q7_HWC(img_buffer1, CONV2_OUT_DIM, CONV2_OUT_CH, POOL2_KER_DIM,
    

  88.                      POOL2_PADDING, POOL2_STRIDE, POOL2_OUT_DIM, col_buffer, img_buffer2);
    


  89. 

  90. // conv3 img_buffer2 -> img_buffer1
    

  91.   arm_convolve_HWC_q7_fast(img_buffer2, CONV3_IM_DIM, CONV3_IM_CH, conv3_wt, CONV3_OUT_CH, CONV3_KER_DIM,
    

  92.                            CONV3_PADDING, CONV3_STRIDE, conv3_bias, CONV3_BIAS_LSHIFT, CONV3_OUT_RSHIFT, img_buffer1,
    

  93.                            CONV3_OUT_DIM, (q15_t *) col_buffer, NULL);
    


  94. 

  95.   arm_relu_q7(img_buffer1, CONV3_OUT_DIM * CONV3_OUT_DIM * CONV3_OUT_CH);
    


  96. 

  97.   // pool3 img_buffer-> img_buffer2
    

  98.   arm_maxpool_q7_HWC(img_buffer1, CONV3_OUT_DIM, CONV3_OUT_CH, POOL3_KER_DIM,
    

  99.                      POOL3_PADDING, POOL3_STRIDE, POOL3_OUT_DIM, col_buffer, img_buffer2);
    


  100. 

  101.   arm_fully_connected_q7_opt(img_buffer2, ip1_wt, IP1_DIM, IP1_OUT, IP1_BIAS_LSHIFT, IP1_OUT_RSHIFT, ip1_bias,
    

  102.                              output_data, (q15_t *) img_buffer1);
    


  103. 

  104.   arm_softmax_q7(output_data, 10, output_data);
    


  105. 

  106.   for (int i = 0; i < 10; i++)
    

  107.   {
    

  108.       printf("%d: %d\n", i, output_data[i]);
    

  109.   }
    


  110. 


  111. 

  112. }


回复

收藏1 举报

 楼主| zeshoufx 发表于 2023-1-3 19:41 | 显示全部楼层
zeshoufx 发表于 2023-1-3 19:40
卷积神经网络：卷积神经网络在图像处理等领域中运用广泛，在ARM官方提供的CMSIS-NN库中，就包含了卷积神 ...

遗传算法：遗传算法也是一种优化算法，模拟背包问题，寻求最优解
复制
  1. /* Include头文件*/
    

  2. #include <stdio.h>
    

  3. #include <stdlib.h>
    

  4. #include <limits.h>
    


  5. 

  6. /*符号常数的定义*/
    

  7. #define MAXVALUE 100 /*重量和价值的最大值*/
    

  8. #define N 30 /*行李个数*/
    

  9. #define WEIGHTLIMIT (N*MAXVALUE/4) /*重量限制*/
    

  10. #define POOLSIZE 30 /*染色体个数*/
    

  11. #define LASTG 50    /*终止后代*/
    

  12. #define MRATE 0.01  /*突变的概率*/
    

  13. #define SEED 32767    /*随机数的seed*/
    

  14. #define YES 1   /*yes对应的整数值*/
    

  15. #define NO 0    /*no对应的整数值*/
    


  16. 

  17. /*函数原型声明*/
    

  18. void initparcel();/*行李的初始化*/
    

  19. int evalfit(int gene[]) ; /*计算适应度*/
    

  20. void mating(int pool[POOLSIZE][N]
    

  21.         ,int ngpool[POOLSIZE*2][N]) ; /*交叉*/
    

  22. void mutation(int ngpool[POOLSIZE*2][N]) ; /*突变*/
    

  23. void printp(int pool[POOLSIZE][N]) ; /*输出结果*/
    

  24. void initpool(int pool[POOLSIZE][N]) ;
    

  25. /*生成初始染色体集合*/
    

  26. int rndn() ; /*生成n之下的随机数   */
    

  27. int notval(int v) ;/*真值的反转*/
    

  28. int selectp(int roulette[POOLSIZE],int totalfitness) ;
    

  29. /*选择父代*/
    

  30. void crossing(int m[],int p[],int c1[],int c2[]) ;
    

  31. /* 两个特定染色体的交叉 */
    

  32. void selectng(int ngpool[POOLSIZE*2][N]
    

  33.         ,int pool[POOLSIZE][N]) ;/*选择下一代*/
    


  34. 

  35. /*全局变量（行李数据）*/
    

  36. int parcel[N][2] =
    

  37. {
    

  38.         {65,27},
    

  39.         {39,82},
    

  40.         {9,85},
    

  41.         {72,71},
    

  42.         {87,91},
    

  43.         {91,28},
    

  44.         {34,92},
    

  45.         {58,79},
    

  46.         {3,27},
    

  47.         {12,82},
    

  48.         {92,15},
    

  49.         {39,49},
    

  50.         {83,54},
    

  51.         {76,43},
    

  52.         {6,26},
    

  53.         {77,2},
    

  54.         {68,6},
    

  55.         {24,60},
    

  56.         {60,47},
    

  57.         {6,40},
    

  58.         {91,58},
    

  59.         {44,68},
    

  60.         {50,33},
    

  61.         {91,92},
    

  62.         {57,62},
    

  63.         {97,49},
    

  64.         {96,68},
    

  65.         {39,77},
    

  66.         {89,6},
    

  67.         {24,97}
    

  68. };/*行李*/
    


  69. 


  70. 


  71. 

  72. /****************************/
    

  73. /*      initparcel()函数    */
    

  74. /*      行李的初始化        */
    

  75. /****************************/
    

  76. void initparcel()
    

  77. {
    

  78. //        int i=0 ;
    

  79. //        while((i<N) && 
    

  80. //                (scanf("%d %d",&parcel[i][0],&parcel[i][1])
    

  81. //                        !=EOF)){
    

  82. //                ++i ;
    

  83. //        }
    


  84. 

  85.         
    

  86. }
    


  87. 

  88. /************************/
    

  89. /*   selectng()函数     */
    

  90. /*   选择下一代         */
    

  91. /************************/
    

  92. void selectng(int ngpool[POOLSIZE*2][N]
    

  93.         ,int pool[POOLSIZE][N]) 
    

  94. {
    

  95.         int i,j,c ;/* 循环控制参数 */
    

  96.         int totalfitness=0 ;/*适应度的总计值*/
    

  97.         int roulette[POOLSIZE*2] ;/*存放适应度*/
    

  98.         int ball ;/* 球（选择位置的数值）*/
    

  99.         int acc=0 ;/*适应度的累积值*/
    

  100.         
    

  101.         /*循环进行选择*/
    

  102.         for(i=0;i<POOLSIZE;++i){
    

  103.                 /* 生成轮盘 */
    

  104.                 totalfitness=0 ;
    

  105.                 for(c=0;c<POOLSIZE*2;++c){
    

  106.                         roulette[c]=evalfit(ngpool[c]) ;
    

  107.                         /*计算适应度的总计值*/
    

  108.                         totalfitness+=roulette[c] ;
    

  109.                 }
    

  110.                 /*选择一个染色体*/
    

  111.                 ball=rndn(totalfitness) ;
    

  112.                 acc=0 ;
    

  113.                 for(c=0;c<POOLSIZE*2;++c){
    

  114.                         acc+=roulette[c] ;/*累积评价值*/
    

  115.                         if(acc>ball) break ;/*对应的基因*/
    

  116.                 }
    

  117.                 
    

  118.                 /*染色体的复制*/
    

  119.                 for(j=0;j<N;++j){
    

  120.                         pool[i][j]=ngpool[c][j] ;
    

  121.                 }
    

  122.         }
    

  123. }
    


  124. 

  125. /************************/
    

  126. /*   selectp()函数      */
    

  127. /*    父代的选择        */
    

  128. /************************/
    

  129. int selectp(int roulette[POOLSIZE],int totalfitness)
    

  130. {
    

  131.         int i ;/* 循环的控制变量 */
    

  132.         int ball ;/* 球（选择位置的数值）*/
    

  133.         int acc=0 ;/*评价值的累积值*/
    

  134.         
    

  135.         ball=rndn(totalfitness) ;
    

  136.         for(i=0;i<POOLSIZE;++i){
    

  137.                 acc+=roulette[i] ;/*评价值的累积*/
    

  138.                 if(acc>ball) break ;/*对应的基因*/
    

  139.         }
    

  140.         return i ;
    

  141. }
    


  142. 


  143. 

  144. /************************/
    

  145. /*   mating()函数       */
    

  146. /*        交叉          */
    

  147. /************************/
    

  148. void mating(int pool[POOLSIZE][N]
    

  149.         ,int ngpool[POOLSIZE*2][N])
    

  150. {
    

  151.         int i ;/* 循环的控制变量 */
    

  152.         int totalfitness=0 ;/*评价值的总计值*/
    

  153.         int roulette[POOLSIZE] ;/*存放评价值*/
    

  154.         int mama,papa ;/*父代的基因的号码*/
    

  155.         
    

  156.         /* 生成轮盘 */
    

  157.         for(i=0;i<POOLSIZE;++i){
    

  158.                 roulette[i]=evalfit(pool[i]) ;
    

  159.                 /* 计算评价值的总计值*/
    

  160.                 totalfitness+=roulette[i] ;
    

  161.         }
    

  162.         
    

  163.         /*选择和交叉的循环*/
    

  164.         for(i=0;i<POOLSIZE;++i){
    

  165.                 do{/*父代的选择*/
    

  166.                         mama=selectp(roulette,totalfitness) ;
    

  167.                         papa=selectp(roulette,totalfitness) ;
    

  168.                 }while(mama==papa) ;/*删除重复的*/
    

  169.                 
    

  170.                 /*特定2染色体的交叉*/
    

  171.                 crossing(pool[mama],pool[papa]
    

  172.                         ,ngpool[i*2],ngpool[i*2+1])  ;  
    

  173.         }
    

  174. }
    


  175. 


  176. 

  177. /************************/
    

  178. /*  crossing()函数      */
    

  179. /* 特定2染色体的交叉    */
    

  180. /************************/
    

  181. void crossing(int m[],int p[],int c1[],int c2[])
    

  182. {
    

  183.         int j ;/* 循环控制变量 */
    

  184.         int cp ;/*交叉的点*/
    

  185.         
    

  186.         /*确定交叉点*/
    

  187.         cp =rndn(N) ;
    

  188.         
    

  189.         /*复制前半部分*/
    

  190.         for(j=0;j<cp;++j){
    

  191.                 c1[j]=m[j] ;
    

  192.                 c2[j]=p[j] ;
    

  193.         }
    

  194.         /*复制后半部分*/
    

  195.         for(;j<N;++j){
    

  196.                 c2[j]=m[j] ;
    

  197.                 c1[j]=p[j] ;
    

  198.         }
    

  199. }
    


  200. 

  201. /************************/
    

  202. /*   evalfit()函数      */
    

  203. /*   计算评价值         */
    

  204. /************************/
    

  205. int evalfit(int g[])
    

  206. {
    

  207.         int pos ;/*指定基因位点*/
    

  208.         int value=0 ;/*评价值*/
    

  209.         int weight=0 ;/*重量*/
    

  210.         
    

  211.         /*调查各个基因位点计算重量和评价值*/
    

  212.         for(pos=0;pos<N;++pos){
    

  213.                 weight+=parcel[pos][0]*g[pos] ;
    

  214.                 value+=parcel[pos][1]*g[pos] ;
    

  215.         }
    

  216.         /*致死基因的处理*/
    

  217.         if(weight>=WEIGHTLIMIT) value=0 ;
    

  218.         return value;
    

  219.         
    

  220. }
    


  221. 

  222. /***********************/
    

  223. /*   printp()函数      */
    

  224. /*   输出结果          */
    

  225. /***********************/
    

  226. void printp(int pool[POOLSIZE][N])
    

  227. {
    

  228.         int i,j ;/* 循环的控制变量 */
    

  229.         int fitness ;/* 评价值 */
    

  230.         double totalfitness=0 ;/* 评价值的总计值 */
    

  231.         int elite,bestfit=0 ;/*精英基因的处理用变量*/
    

  232.         
    

  233.         for(i=0;i<POOLSIZE;++i){
    

  234.                 for(j=0;j<N;++j)
    

  235.                         printf("%1d",pool[i][j]) ;
    

  236.                 fitness=evalfit(pool[i]) ;
    

  237.                 printf("\t%d\n",fitness) ;
    

  238.                 if(fitness>bestfit){/*精英解*/
    

  239.                         bestfit=fitness ;
    

  240.                         elite=i ;
    

  241.                 }
    

  242.                 totalfitness+=fitness ;
    

  243.         }
    

  244.         /*输出精英解的评价值*/
    

  245.         printf("%d\t%d \t",elite,bestfit) ;
    

  246.         /*输出平均评价值*/
    

  247.         printf("%lf\n",totalfitness/POOLSIZE) ;
    

  248. }
    


  249. 


  250. 

  251. /***********************/
    

  252. /*   initpool()函数    */
    

  253. /*   生成初始染色体集合*/
    

  254. /***********************/
    

  255. void initpool(int pool[POOLSIZE][N])
    

  256. {
    

  257.         int i,j ;/* 循环控制变量 */
    

  258.         
    

  259.         for(i=0;i<POOLSIZE;++i)
    

  260.                 for(j=0;j<N;++j)
    

  261.                         pool[i][j]=rndn(2) ;
    

  262. }
    


  263. 


  264. 

  265. /************************/
    

  266. /*     rndn()函数       */
    

  267. /*    n以下随机数的生成 */
    

  268. /************************/
    

  269. int rndn(int l)
    

  270. {
    

  271.         int rndno ;/*生成的随机数*/
    

  272.         
    

  273.         while((rndno=((double)rand()/RAND_MAX)*l)==l) ;
    

  274.         
    

  275.         return rndno;
    

  276. }
    


  277. 

  278. /***********************/
    

  279. /*   mutation()函数    */
    

  280. /*   突变              */
    

  281. /***********************/
    

  282. void mutation(int ngpool[POOLSIZE*2][N])
    

  283. {
    

  284.         int i,j ;/* 循环的控制变量 */
    

  285.         
    

  286.         for(i=0;i<POOLSIZE*2;++i)
    

  287.                 for(j=0;j<N;++j)
    

  288.                         if((double)rndn(100)/100.0<=MRATE)
    

  289.                                 /*反转的突变*/
    

  290.                                 ngpool[i][j]=notval(ngpool[i][j]) ;
    

  291.         
    

  292. }
    


  293. 

  294. /************************/
    

  295. /*   notval()函数       */
    

  296. /*   真值的反转         */
    

  297. /************************/
    

  298. int notval(int v)
    

  299. {
    

  300.         if(v==YES) return NO ;
    

  301.         else return YES ;
    

  302. }
    


  303. 

  304. int pool[POOLSIZE][N] ; /*染色体集合*/
    

  305. int ngpool[POOLSIZE*2][N] ; /*下一代染色体集合*/
    

  306. int generation;/* 现在的代数 */
    


  307. 

  308. void dsp_test(void)
    

  309. {
    

  310.         
    

  311.         
    

  312.         /*随机数的初始化*/
    

  313.         srand(SEED) ;
    

  314.         
    

  315. //        /*行李的初始化*/
    

  316. //        initparcel() ;
    

  317.         
    

  318.         /*生成初始染色体集合*/
    

  319.         initpool(pool) ;
    

  320.         
    

  321.         /*循环直至终止子代*/
    

  322.         for(generation=0;generation<LASTG;++generation){
    

  323.                 printf("%d代数\n",generation) ;
    

  324.                 mating(pool,ngpool) ;/*交叉*/
    

  325.                 mutation(ngpool) ;/*突变*/
    

  326.                 selectng(ngpool,pool) ;/*选择下一子代*/
    

  327.                 printp(pool) ;/*输出结果*/
    

  328.         }
    

  329. }


回复

收藏1 举报

 楼主| zeshoufx 发表于 2023-1-3 19:42 | 显示全部楼层
zeshoufx 发表于 2023-1-3 19:41
遗传算法：遗传算法也是一种优化算法，模拟背包问题，寻求最优解

1、卡尔曼滤波：卡尔曼滤波在数据采集中运用广泛，在数据波动的情况下获得真实值。
复制
  1. #include "dsp_test.h"
    

  2. #include "systick.h"
    


  3. 

  4. #define Kk_calc(x,y)    (x)/(x+y)
    


  5. 

  6. type_KalmanFilter k;
    


  7. 

  8. float RandomNumGenerator(int base, int range)
    

  9. {
    

  10.         float k = 0.0;
    

  11.         float randomNum = 0.0;
    


  12. 

  13.         k = 2 * range * 10;
    


  14. 

  15.         randomNum = rand() % (int)k;
    


  16. 

  17.         k = base - range + (randomNum / 10);
    

  18.         return k;
    

  19. }
    


  20. 


  21. 

  22. //Kalman初始化
    

  23. void Kalman_Init(type_KalmanFilter* kalmanFilter, float FirstMeaValue, float E_mea, float FirstEstValue, float E_est) 
    

  24. {
    

  25.         kalmanFilter->x_est = FirstEstValue;
    

  26.         kalmanFilter->x_mea = FirstMeaValue;
    

  27.         kalmanFilter->e_est = E_est;
    

  28.         kalmanFilter->e_mea = E_mea;
    

  29.         kalmanFilter->Kk = Kk_calc(kalmanFilter->e_est, kalmanFilter->e_mea);
    

  30. }
    


  31. 

  32. //Kalman更新
    

  33. void Kalman_Update(type_KalmanFilter* kalmanFilter, float newMeaValue) 
    

  34. {
    

  35.         float temp = kalmanFilter->e_est;
    

  36.         kalmanFilter->x_est = kalmanFilter->x_est + kalmanFilter->Kk * (newMeaValue - kalmanFilter->x_est);
    

  37.         kalmanFilter->x_mea = newMeaValue;
    

  38.         kalmanFilter->Kk = Kk_calc(kalmanFilter->e_est, kalmanFilter->e_mea);
    

  39.         kalmanFilter->e_est = (1 - kalmanFilter->Kk) * temp;
    

  40. }
    


  41. 

  42. void ad_da_init(void)
    

  43. {
    

  44.         //时钟配置
    

  45.         rcu_periph_clock_enable(RCU_GPIOA);
    

  46.         rcu_periph_clock_enable(RCU_AF);
    

  47.         rcu_periph_clock_enable(RCU_ADC0);
    

  48.         rcu_periph_clock_enable(RCU_DAC);
    

  49.         
    

  50.         rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV12);
    

  51.         
    

  52.         //接口配置
    

  53.         gpio_init(GPIOA,GPIO_MODE_AIN,GPIO_OSPEED_50MHZ,GPIO_PIN_4);
    

  54.         gpio_init(GPIOA,GPIO_MODE_AIN,GPIO_OSPEED_50MHZ,GPIO_PIN_6);
    

  55.         
    

  56.         //ADC输入配置
    

  57.         adc_special_function_config(ADC0,ADC_CONTINUOUS_MODE,ENABLE);
    

  58.         adc_data_alignment_config(ADC0,ADC_DATAALIGN_RIGHT);
    

  59.         adc_channel_length_config(ADC0,ADC_REGULAR_CHANNEL,1);
    

  60.         adc_regular_channel_config(ADC0,0,ADC_CHANNEL_6,ADC_SAMPLETIME_55POINT5);
    

  61.         adc_external_trigger_config(ADC0,ADC_REGULAR_CHANNEL,DISABLE);
    

  62.         
    

  63.         adc_enable(ADC0);
    

  64.         delay_ms(1);
    

  65.         adc_calibration_enable(ADC0);
    

  66.         
    

  67.         //DAC输出配置
    

  68.         dac_trigger_source_config(DAC0,DAC_TRIGGER_SOFTWARE);
    

  69.         dac_trigger_enable(DAC0);
    

  70.         dac_wave_mode_config(DAC0,DAC_WAVE_DISABLE);
    

  71.         dac_output_buffer_enable(DAC0);
    

  72.         
    

  73.         dac_enable(DAC0);
    

  74.         dac_data_set(DAC0, DAC_ALIGN_12B_R, (u16)1024);
    

  75.     dac_software_trigger_enable(DAC0);
    

  76.         
    

  77.         //Kalman初始化
    

  78.         Kalman_Init(&k, 1024, 2, 1024, 2);
    

  79. }
    


  80. 


  81. 


  82. 

  83. void dsp_test(void)
    

  84. {
    

  85.         u16 adc_get=0;
    

  86.         
    

  87.         adc_software_trigger_enable(ADC0,ADC_REGULAR_CHANNEL);
    

  88.         if(adc_flag_get(ADC0,ADC_FLAG_EOC))
    

  89.         {
    

  90.                 adc_flag_clear(ADC0,ADC_FLAG_EOC);
    

  91.                 adc_get = adc_regular_data_read(ADC0);
    

  92.                 Kalman_Update(&k,adc_get);
    

  93.         }
    

  94.         
    

  95.         printf("%d        %f        %f\r\n",adc_get,k.x_mea,k.x_est);
    

  96. }
2036763b41485c9ff2.png

回复

收藏1 举报

 楼主| zeshoufx 发表于 2023-1-3 19:42 | 显示全部楼层
zeshoufx 发表于 2023-1-3 19:42
1、卡尔曼滤波：卡尔曼滤波在数据采集中运用广泛，在数据波动的情况下获得真实值。
...

1、线性回归：线性回归作为最简单的机器学习
复制
  1. #include "dsp_test.h"
    


  2. 


  3. 

  4. float data_x[12]={187.1,179.5,157.0,197.0,239.4,217.8,227.1,233.4,242.0,251.9,230.0,271.8};
    

  5. float data_y[12]={25.4,22.8,20.6,21.8,32.4,24.4,29.3,27.9,27.8,34.2,29.2,30.0};
    


  6. 


  7. 

  8. //求线性回归方程：Y=ax+b
    

  9. //dada_x数组：X;
    

  10. //data_y数组：Y；
    

  11. //length：数据个数；
    

  12. //a,b：返回回归系数
    

  13. //返回值：无
    

  14. void LinearRegression(        float *data_x,
    

  15.                                                 float *data_y,
    

  16.                                                 u16 length,
    

  17.                                                 float *a,
    

  18.                                                 float *b)
    

  19. {
    

  20.         u16 i=0;
    

  21.         float sum_x=0.,sum_y=0.;
    

  22.         float mean_x=0.,mean_y=0.;
    

  23.         float Lxy=0.,Lxx=0.;
    

  24.         
    

  25.         //分别求和
    

  26.         for(i=0;i<length;i++)
    

  27.         {
    

  28.                 sum_x+=data_x[i];
    

  29.                 sum_y+=data_y[i];
    

  30.         }
    

  31.         
    

  32.         //取平均
    

  33.         mean_x=sum_x/length;
    

  34.         mean_y=sum_y/length;
    

  35.         
    

  36.         //计算分母和分子
    

  37.         for ( i=0; i!=length; i++)
    

  38.         {
    

  39.                 Lxy += (data_x[i] - mean_x) * (data_y[i] - mean_y);
    

  40.                 Lxx += (data_x[i] - mean_x) * (data_x[i] - mean_x);
    

  41.         }
    

  42.         
    

  43.         //计算回归系数
    

  44.         *a=Lxy/Lxx;
    

  45.         *b=mean_y-(*a)*mean_x;
    

  46. }
    


  47. 

  48. void dsp_test(void)
    

  49. {
    

  50.         float a=0.,b=0.;
    

  51.         LinearRegression(data_x,data_y,12,&a,&b);
    

  52.         printf("%f        %f\r\n",a,b);
    

  53. }
8334663b414b5f11dc.png

回复

收藏1 举报

caigang13 发表于 2023-1-3 20:47 来自手机 | 显示全部楼层
MCU还能玩神经网络计算？
回复

收藏1 举报

 楼主| zeshoufx 发表于 2023-1-4 08:59 | 显示全部楼层
caigang13 发表于 2023-1-3 20:47
MCU还能玩神经网络计算？

可以的，，ARM官方提供的CMSIS-NN库，就是针对cortex-M 和cortex-A CPU的，，
回复

收藏1 举报

cauhorse 发表于 2023-1-5 13:33 | 显示全部楼层
楼主玩得很全面，佩服
回复

收藏1 举报

下一页 »
12下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

zeshoufx

67

主题

1991

帖子

15

粉丝
快速回复 在线客服 返回列表 返回顶部