devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

STM32CubeIDE开发(三十三)， stm32人工智能开发应用实践（Cube.AI）.篇三_在cube-ai上模拟部署一遍,判断自己准备购买的板子适不适合做ai计算

作者：2023面试高手 | 2024-03-30 03:46:53

赞

踩

在cube-ai上模拟部署一遍,判断自己准备购买的板子适不适合做ai计算

目录

一、cube.AI实际项目应用

二、创建工程

2.1 工程配置

2.2 外设代码设计

2.3 传感器数据采集与输出源码设计

2.4 编辑下载程序，采集数据

 三、模型训练

四、cube.AI配置及c模型生成

五、模型调用及测试

一、cube.AI实际项目应用

        接篇二，前文都是采用FP-AI-SENSING1案例和配套的B-L475E-IOT01A开发板来阐述的，而实际项目中，我们都是基于自身项目硬件平台来训练模型及部署模型的，我们仅仅需要cube.AI软件包（作为可调用库）来支持我们项目，不会强行采用FP-AI-SENSING1案例去收集数据及配套的B-L475E-IOT01A等硬件平台部署。

        回顾篇一，ST公司支持到如下图芯片型号，

         在本文中，将采用STM32L496VGT6-ali开发板来部署cube.AI实现人工智能。STM32L496VGT6开发板已经集成了LSM6DSL传感器（三轴加速度计及三轴陀螺仪传感器），项目设想如下：

        1）通过LSM6DSL采集加速度数值（x/y/z三轴加速度）

        2）本文只采集三种姿态（开发板正面朝上，静止不动、左右移动、上下移动三种姿态）时的加速度数值，用来实现分类神经网络，三种姿态作为神经网络模型输出值（分类）

        3）每次输入读取三组加速度值（每组数据是读取x/y/z三轴的三个加速度值），共9个数值作为神经网络模型输入数据

        4）利用STM32L496VGT6开发板上的三个按钮，KEY0为静止不动姿态采集按键，KEY1为左右移动姿态采集按键，KEY2为上下移动姿态采集按键。

        5）通过串口打印输出采集数据信息，并通过串联助手连接获得采集日志并保存成TXT文件

        6）将记录数据文件转换为csv文件，通过keras框架，编写神经网络训练模型python项目，进行神经网络模型训练，并输出.h5训练模型文件

        7）通过cubeMX和cube.AI将h5神经网络模型转换为c语言神经网络模型

        8）将LSM6DSL实时采集数据推送给c语言神经网络模型API，进行神经网络计算，查看输出结果是否符合预期。

二、创建工程

        在CubeIDE上，基于STM32L496VGT6芯片，创建新工程STM32工程，并实现了串口lpuart1调试日志输出，三个按键KEY0~2和三个LED灯LED0~2的功能实现，并实现LSM6DSL传感器采集数据功能（I2C4），请参考本专栏博文：

        1）cubeIDE快速开发流程_ide 程序的开发过程_py_free的博客-CSDN博客

        2）cubeIDE开发， stm32调试信息串口通信输出显示_py_free的博客-CSDN博客_怎么实查看stm32串口输出

        3）cubeIDE开发，I2C协议采集传感器数据（SHTC1、LTR-553ALS、BMP280、LSM6DSL、MMC3680KJ）_ltr553 driver download_py_free的博客-CSDN博客

        现给出简要的配置及源码信息：

2.1 工程配置

        1）内核功能配置及RCC开启外部时钟支持

         2）开启LPUART1，并开启其中断支持

         3）开启I2C4，并开启其中断功能及DMA功能

        4）配置GPIO引脚（三个按键及三个LED灯）

         5）配置时钟树

         6）引脚视图

         7）工程配置，选择为每个外设生成独立的.h/.c文件

         生成输出代码

2.2 外设代码设计

        禁用syscalls.c文件（右键进入文件属性设置页面）

        在工程下，创建源目录ICore，在该目录下，如下图所示，创建子目录及外设驱动源文件

         源码文件内容如下：

        1）key.h

  1. #ifndef KEY_H_
  2. #define KEY_H_
  3.  
  4. #include "main.h"
  5. #include "gpio.h"
  6.  
  7. GPIO_PinState get_key0_val();
  8. GPIO_PinState get_key1_val();
  9. GPIO_PinState get_key2_val();
  10.  
  11. uint8_t KEY_0(void);
  12. uint8_t KEY_1(void);
  13. uint8_t KEY_2(void);
  14.  
  15. #endif /* KEY_H_ */

         key.c

  1. #include "key.h"
  2.  
  3. GPIO_PinState get_key0_val()
  4. {
  5. 	return HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin);
  6. };
  7.  
  8. GPIO_PinState get_key1_val()
  9. {
  10. 	return HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin);
  11. };
  12.  
  13. GPIO_PinState get_key2_val()
  14. {
  15. 	return HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin);
  16. };
  17.  
  18. uint8_t KEY_0(void)
  19. {
  20. 	uint8_t a;
  21. 	a=0;//如果未进入按键处理，则返回0
  22. 	if(HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin)==GPIO_PIN_RESET){//读按键接口的电平
  23. 		HAL_Delay(20);//延时去抖动
  24. 		if(HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
  25. 			a=1;//进入按键处理，返回1
  26. 		}
  27. 	}
  28. 	while(HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin)==GPIO_PIN_RESET); //等待按键松开
  29. 	return a;
  30. }
  31.  
  32. uint8_t KEY_1(void)
  33. {
  34. 	uint8_t a;
  35. 	a=0;//如果未进入按键处理，则返回0
  36. 	if(HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin)==GPIO_PIN_RESET){//读按键接口的电平
  37. 		HAL_Delay(20);//延时去抖动
  38. 		if(HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
  39. 			a=1;//进入按键处理，返回1
  40. 		}
  41. 	}
  42. 	while(HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin)==GPIO_PIN_RESET); //等待按键松开
  43. 	return a;
  44. }
  45.  
  46. uint8_t KEY_2(void)
  47. {
  48. 	uint8_t a;
  49. 	a=0;//如果未进入按键处理，则返回0
  50. 	if(HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin)==GPIO_PIN_RESET){//读按键接口的电平
  51. 		HAL_Delay(20);//延时去抖动
  52. 		if(HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
  53. 			a=1;//进入按键处理，返回1
  54. 		}
  55. 	}
  56. 	while(HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin)==GPIO_PIN_RESET); //等待按键松开
  57. 	return a;
  58. }

         2) led.h

  1. #ifndef LED_H_
  2. #define LED_H_
  3. #include "main.h"
  4. #include "gpio.h"
  5.  
  6. void Toggle_led0();
  7. void Toggle_led1();
  8. void Toggle_led2();
  9.  
  10. void set_led0_val(GPIO_PinState PinState);
  11. void set_led1_val(GPIO_PinState PinState);
  12. void set_led2_val(GPIO_PinState PinState);
  13.  
  14. #endif /* LED_H_ */

         led.c

  1. #include "led.h"
  2.  
  3. void Toggle_led0()
  4. {
  5. 	HAL_GPIO_TogglePin(LED0_GPIO_Port,LED0_Pin);
  6. }
  7.  
  8. void Toggle_led1()
  9. {
  10. 	HAL_GPIO_TogglePin(LED1_GPIO_Port,LED1_Pin);
  11. }
  12.  
  13. void Toggle_led2()
  14. {
  15. 	HAL_GPIO_TogglePin(LED2_GPIO_Port,LED2_Pin);
  16. }
  17.  
  18. void set_led0_val(GPIO_PinState PinState)
  19. {
  20. 	HAL_GPIO_WritePin(LED0_GPIO_Port,LED0_Pin,PinState);
  21. };
  22.  
  23. void set_led1_val(GPIO_PinState PinState)
  24. {
  25. 	HAL_GPIO_WritePin(LED1_GPIO_Port,LED1_Pin,PinState);
  26. };
  27.  
  28. void set_led2_val(GPIO_PinState PinState)
  29. {
  30. 	HAL_GPIO_WritePin(LED2_GPIO_Port,LED2_Pin,PinState);
  31. };

         3）print.h

  1. #ifndef INC_RETARGET_H_
  2. #define INC_RETARGET_H_
  3.  
  4. #include "stm32l4xx_hal.h"
  5. #include "stdio.h"//用于printf函数串口重映射
  6. #include <sys/stat.h>
  7.  
  8. void ResetPrintInit(UART_HandleTypeDef  *huart);
  9.  
  10. int _isatty(int fd);
  11. int _write(int fd, char* ptr, int len);
  12. int _close(int fd);
  13. int _lseek(int fd, int ptr, int dir);
  14. int _read(int fd, char* ptr, int len);
  15. int _fstat(int fd, struct stat* st);
  16.  
  17. #endif /* INC_RETARGET_H_ */

         print.c

  1. #include <_ansi.h>
  2. #include <_syslist.h>
  3. #include <errno.h>
  4. #include <sys/time.h>
  5. #include <sys/times.h>
  6. #include <limits.h>
  7. #include <signal.h>
  8. #include <stdint.h>
  9. #include <stdio.h>
  10.  
  11. #include "print.h"
  12.  
  13. #if !defined(OS_USE_SEMIHOSTING)
  14. #define STDIN_FILENO  0
  15. #define STDOUT_FILENO 1
  16. #define STDERR_FILENO 2
  17.  
  18. UART_HandleTypeDef *gHuart;
  19.  
  20. void ResetPrintInit(UART_HandleTypeDef *huart)  {
  21.   gHuart = huart;
  22.   /* Disable I/O buffering for STDOUT  stream, so that
  23.    * chars are sent out as soon as they are  printed. */
  24.   setvbuf(stdout, NULL, _IONBF, 0);
  25. }
  26. int _isatty(int fd) {
  27.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
  28.     return 1;
  29.   errno = EBADF;
  30.   return 0;
  31. }
  32. int _write(int fd, char* ptr, int len) {
  33.   HAL_StatusTypeDef hstatus;
  34.   if (fd == STDOUT_FILENO || fd ==  STDERR_FILENO) {
  35.     hstatus = HAL_UART_Transmit(gHuart,  (uint8_t *) ptr, len, HAL_MAX_DELAY);
  36.     if (hstatus == HAL_OK)
  37.       return len;
  38.     else
  39.       return EIO;
  40.   }
  41.   errno = EBADF;
  42.   return -1;
  43. }
  44. int _close(int fd) {
  45.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
  46.     return 0;
  47.   errno = EBADF;
  48.   return -1;
  49. }
  50. int _lseek(int fd, int ptr, int dir) {
  51.   (void) fd;
  52.   (void) ptr;
  53.   (void) dir;
  54.   errno = EBADF;
  55.   return -1;
  56. }
  57. int _read(int fd, char* ptr, int len) {
  58.   HAL_StatusTypeDef hstatus;
  59.   if (fd == STDIN_FILENO) {
  60.     hstatus = HAL_UART_Receive(gHuart,  (uint8_t *) ptr, 1, HAL_MAX_DELAY);
  61.     if (hstatus == HAL_OK)
  62.       return 1;
  63.     else
  64.       return EIO;
  65.   }
  66.   errno = EBADF;
  67.   return -1;
  68. }
  69. int _fstat(int fd, struct stat* st) {
  70.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO) {
  71.     st->st_mode = S_IFCHR;
  72.     return 0;
  73.   }
  74.   errno = EBADF;
  75.   return 0;
  76. }
  77.  
  78. #endif //#if !defined(OS_USE_SEMIHOSTING)

        4) usart.h

  1. #ifndef INC_USART_H_
  2. #define INC_USART_H_
  3.  
  4. #include "stm32l4xx_hal.h" //HAL库文件声明
  5. #include <string.h>//用于字符串处理的库
  6. #include "../print/print.h"//用于printf函数串口重映射
  7.  
  8. extern UART_HandleTypeDef hlpuart1;//声明LPUSART的HAL库结构体
  9.  
  10. #define HLPUSART_REC_LEN  256//定义LPUSART最大接收字节数
  11.  
  12. extern uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
  13. extern uint16_t HLPUSART_RX_STA;//接收状态标记
  14. extern uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
  15.  
  16.  
  17. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
  18.  
  19. #endif /* INC_USART_H_ */

        usart.c

  1. #include "usart.h"
  2.  
  3. uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
  4. /*
  5.  * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
  6.  * bit14:接收溢出标志，数据超出缓存长度时，设置HLPUSART_RX_STA|=0x4000;
  7.  * bit13:预留
  8.  * bit12:预留
  9.  * bit11~0：接收到的有效字节数目(0~4095)
  10.  */
  11. uint16_t HLPUSART_RX_STA=0;接收状态标记//bit15：接收完成标志，bit14：接收到回车(0x0d)，bit13~0：接收到的有效字节数目
  12. uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
  13.  
  14. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
  15. {
  16. 	if(huart ==&hlpuart1)//判断中断来源（串口1：USB转串口）
  17.     {
  18. 		if(HLPUSART_NewData==0x0d){//回车标记
  19.      	  HLPUSART_RX_STA|=0x8000;//标记接到回车
  20. 		}else{
  21. 			if((HLPUSART_RX_STA&0X0FFF)<HLPUSART_REC_LEN){
  22. 				HLPUSART_RX_BUF[HLPUSART_RX_STA&0X0FFF]=HLPUSART_NewData; //将收到的数据放入数组
  23. 				HLPUSART_RX_STA++;  //数据长度计数加1
  24. 			}else{
  25. 				HLPUSART_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
  26. 			}
  27.         }
  28.        HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData,1); //再开启接收中断
  29.     }
  30. }

        5) LSM6DSL.h

  1. #ifndef _LSM6DSL_H_
  2. #define _LSM6DSL_H_
  3.  
  4. #include "main.h"
  5.  
  6. void LSM6DSL_init();
  7. //
  8. uint8_t LSM6DSL_acc_st_open(void);
  9. uint8_t LSM6DSL_acc_st_close(void);
  10.  
  11. uint8_t LSM6DSL_gyro_st_open(void);
  12. uint8_t LSM6DSL_gyro_st_close(void);
  13.  
  14. uint8_t LSM6DSL_acc_read(int32_t *x_data,int32_t *y_data,int32_t *z_data);
  15. uint8_t LSM6DSL_gyro_read(int32_t *x_data,int32_t *y_data,int32_t *z_data);
  16.  
  17. #endif /* LSM6DSL_LSM6DSL_H_ */

        LSM6DSL.c，实现传感器的ID检验、软重置、模式设置、数据读取及转换功能。

  1. #include <stdio.h>
  2. #include "LSM6DSL.h"
  3.  
  4. extern I2C_HandleTypeDef hi2c4;
  5.  
  6. #define LSM6DSL_I2C_ADDR1 (0x6A)
  7. #define LSM6DSL_I2C_ADDR2 (0x6B)
  8. #define LSM6DSL_I2C_ADDR_TRANS(n) ((n) << 1)
  9. #define LSM6DSL_I2C_ADDR LSM6DSL_I2C_ADDR_TRANS(LSM6DSL_I2C_ADDR2)
  10.  
  11. #define LSM6DSL_ACC_GYRO_FUNC_CFG_ACCESS 0x01
  12. #define LSM6DSL_ACC_GYRO_SENSOR_SYNC_TIME 0x04
  13. #define LSM6DSL_ACC_GYRO_SENSOR_RES_RATIO 0x05
  14. #define LSM6DSL_ACC_GYRO_FIFO_CTRL1 0x06
  15. #define LSM6DSL_ACC_GYRO_FIFO_CTRL2 0x07
  16. #define LSM6DSL_ACC_GYRO_FIFO_CTRL3 0x08
  17. #define LSM6DSL_ACC_GYRO_FIFO_CTRL4 0x09
  18. #define LSM6DSL_ACC_GYRO_FIFO_CTRL5 0x0A
  19. #define LSM6DSL_ACC_GYRO_DRDY_PULSE_CFG_G 0x0B
  20. #define LSM6DSL_ACC_GYRO_INT1_CTRL 0x0D
  21. #define LSM6DSL_ACC_GYRO_INT2_CTRL 0x0E
  22. #define LSM6DSL_ACC_GYRO_WHO_AM_I_REG 0x0F
  23. #define LSM6DSL_ACC_GYRO_CTRL1_XL 0x10
  24. #define LSM6DSL_ACC_GYRO_CTRL2_G 0x11
  25. #define LSM6DSL_ACC_GYRO_CTRL3_C 0x12
  26. #define LSM6DSL_ACC_GYRO_CTRL4_C 0x13
  27. #define LSM6DSL_ACC_GYRO_CTRL5_C 0x14
  28. #define LSM6DSL_ACC_GYRO_CTRL6_C 0x15
  29. #define LSM6DSL_ACC_GYRO_CTRL7_G 0x16
  30. #define LSM6DSL_ACC_GYRO_CTRL8_XL 0x17
  31. #define LSM6DSL_ACC_GYRO_CTRL9_XL 0x18
  32. #define LSM6DSL_ACC_GYRO_CTRL10_C 0x19
  33.  
  34.  
  35. #define LSM6DSL_ACC_GYRO_MASTER_CONFIG 0x1A
  36. #define LSM6DSL_ACC_GYRO_WAKE_UP_SRC 0x1B
  37. #define LSM6DSL_ACC_GYRO_TAP_SRC 0x1C
  38. #define LSM6DSL_ACC_GYRO_D6D_SRC 0x1D
  39. #define LSM6DSL_ACC_GYRO_STATUS_REG 0x1E
  40.  
  41. #define LSM6DSL_ACC_GYRO_OUT_TEMP_L 0x20
  42. #define LSM6DSL_ACC_GYRO_OUT_TEMP_H 0x21
  43. #define LSM6DSL_ACC_GYRO_OUTX_L_G 0x22
  44. #define LSM6DSL_ACC_GYRO_OUTX_H_G 0x23
  45. #define LSM6DSL_ACC_GYRO_OUTY_L_G 0x24
  46. #define LSM6DSL_ACC_GYRO_OUTY_H_G 0x25
  47. #define LSM6DSL_ACC_GYRO_OUTZ_L_G 0x26
  48. #define LSM6DSL_ACC_GYRO_OUTZ_H_G 0x27
  49. #define LSM6DSL_ACC_GYRO_OUTX_L_XL 0x28
  50. #define LSM6DSL_ACC_GYRO_OUTX_H_XL 0x29
  51. #define LSM6DSL_ACC_GYRO_OUTY_L_XL 0x2A
  52. #define LSM6DSL_ACC_GYRO_OUTY_H_XL 0x2B
  53. #define LSM6DSL_ACC_GYRO_OUTZ_L_XL 0x2C
  54. #define LSM6DSL_ACC_GYRO_OUTZ_H_XL 0x2D
  55. #define LSM6DSL_ACC_GYRO_SENSORHUB1_REG 0x2E
  56. #define LSM6DSL_ACC_GYRO_SENSORHUB2_REG 0x2F
  57. #define LSM6DSL_ACC_GYRO_SENSORHUB3_REG 0x30
  58. #define LSM6DSL_ACC_GYRO_SENSORHUB4_REG 0x31
  59. #define LSM6DSL_ACC_GYRO_SENSORHUB5_REG 0x32
  60. #define LSM6DSL_ACC_GYRO_SENSORHUB6_REG 0x33
  61. #define LSM6DSL_ACC_GYRO_SENSORHUB7_REG 0x34
  62. #define LSM6DSL_ACC_GYRO_SENSORHUB8_REG 0x35
  63. #define LSM6DSL_ACC_GYRO_SENSORHUB9_REG 0x36
  64. #define LSM6DSL_ACC_GYRO_SENSORHUB10_REG 0x37
  65. #define LSM6DSL_ACC_GYRO_SENSORHUB11_REG 0x38
  66. #define LSM6DSL_ACC_GYRO_SENSORHUB12_REG 0x39
  67. #define LSM6DSL_ACC_GYRO_FIFO_STATUS1 0x3A
  68. #define LSM6DSL_ACC_GYRO_FIFO_STATUS2 0x3B
  69. #define LSM6DSL_ACC_GYRO_FIFO_STATUS3 0x3C
  70. #define LSM6DSL_ACC_GYRO_FIFO_STATUS4 0x3D
  71. #define LSM6DSL_ACC_GYRO_FIFO_DATA_OUT_L 0x3E
  72. #define LSM6DSL_ACC_GYRO_FIFO_DATA_OUT_H 0x3F
  73. #define LSM6DSL_ACC_GYRO_TIMESTAMP0_REG 0x40
  74. #define LSM6DSL_ACC_GYRO_TIMESTAMP1_REG 0x41
  75. #define LSM6DSL_ACC_GYRO_TIMESTAMP2_REG 0x42
  76.  
  77. #define LSM6DSL_ACC_GYRO_TIMESTAMP_L 0x49
  78. #define LSM6DSL_ACC_GYRO_TIMESTAMP_H 0x4A
  79.  
  80. #define LSM6DSL_ACC_GYRO_STEP_COUNTER_L 0x4B
  81. #define LSM6DSL_ACC_GYRO_STEP_COUNTER_H 0x4C
  82.  
  83. #define LSM6DSL_ACC_GYRO_SENSORHUB13_REG 0x4D
  84. #define LSM6DSL_ACC_GYRO_SENSORHUB14_REG 0x4E
  85. #define LSM6DSL_ACC_GYRO_SENSORHUB15_REG 0x4F
  86. #define LSM6DSL_ACC_GYRO_SENSORHUB16_REG 0x50
  87. #define LSM6DSL_ACC_GYRO_SENSORHUB17_REG 0x51
  88. #define LSM6DSL_ACC_GYRO_SENSORHUB18_REG 0x52
  89.  
  90. #define LSM6DSL_ACC_GYRO_FUNC_SRC 0x53
  91. #define LSM6DSL_ACC_GYRO_TAP_CFG1 0x58
  92. #define LSM6DSL_ACC_GYRO_TAP_THS_6D 0x59
  93. #define LSM6DSL_ACC_GYRO_INT_DUR2 0x5A
  94. #define LSM6DSL_ACC_GYRO_WAKE_UP_THS 0x5B
  95. #define LSM6DSL_ACC_GYRO_WAKE_UP_DUR 0x5C
  96. #define LSM6DSL_ACC_GYRO_FREE_FALL 0x5D
  97. #define LSM6DSL_ACC_GYRO_MD1_CFG 0x5E
  98. #define LSM6DSL_ACC_GYRO_MD2_CFG 0x5F
  99.  
  100. #define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_X_L 0x66
  101. #define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_X_H 0x67
  102. #define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Y_L 0x68
  103. #define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Y_H 0x69
  104. #define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Z_L 0x6A
  105. #define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Z_H 0x6B
  106.  
  107. #define LSM6DSL_ACC_GYRO_X_OFS_USR 0x73
  108. #define LSM6DSL_ACC_GYRO_Y_OFS_USR 0x74
  109. #define LSM6DSL_ACC_GYRO_Z_OFS_USR 0x75
  110.  
  111. #define LSM6DSL_CHIP_ID_VALUE (0x6A)
  112.  
  113. #define LSM6DSL_RESET_VALUE (0x1)
  114. #define LSM6DSL_RESET_MSK (0X1)
  115. #define LSM6DSL_RESET_POS (0)
  116.  
  117. #define LSM6DSL_ACC_ODR_POWER_DOWN (0X00)
  118. #define LSM6DSL_ACC_ODR_1_6_HZ (0X0B)
  119. #define LSM6DSL_ACC_ODR_12_5_HZ (0x01)
  120. #define LSM6DSL_ACC_ODR_26_HZ (0x02)
  121. #define LSM6DSL_ACC_ODR_52_HZ (0x03)
  122. #define LSM6DSL_ACC_ODR_104_HZ (0x04)
  123. #define LSM6DSL_ACC_ODR_208_HZ (0x05)
  124. #define LSM6DSL_ACC_ODR_416_HZ (0x06)
  125. #define LSM6DSL_ACC_ODR_833_HZ (0x07)
  126. #define LSM6DSL_ACC_ODR_1_66_KHZ (0x08)
  127. #define LSM6DSL_ACC_ODR_3_33_KHZ (0x09)
  128. #define LSM6DSL_ACC_ODR_6_66_KHZ (0x0A)
  129. #define LSM6DSL_ACC_ODR_MSK (0XF0)
  130. #define LSM6DSL_ACC_ODR_POS (4)
  131.  
  132. #define LSM6DSL_GYRO_ODR_POWER_DOWN (0X00)
  133. #define LSM6DSL_GYRO_ODR_12_5_HZ (0x01)
  134. #define LSM6DSL_GYRO_ODR_26_HZ (0x02)
  135. #define LSM6DSL_GYRO_ODR_52_HZ (0x03)
  136. #define LSM6DSL_GYRO_ODR_104_HZ (0x04)
  137. #define LSM6DSL_GYRO_ODR_208_HZ (0x05)
  138. #define LSM6DSL_GYRO_ODR_416_HZ (0x06)
  139. #define LSM6DSL_GYRO_ODR_833_HZ (0x07)
  140. #define LSM6DSL_GYRO_ODR_1_66_KHZ (0x08)
  141. #define LSM6DSL_GYRO_ODR_3_33_KHZ (0x09)
  142. #define LSM6DSL_GYRO_ODR_6_66_KHZ (0x0A)
  143. #define LSM6DSL_GYRO_ODR_MSK (0XF0)
  144. #define LSM6DSL_GYRO_ODR_POS (4)
  145.  
  146. #define LSM6DSL_ACC_RANGE_2G (0x0)
  147. #define LSM6DSL_ACC_RANGE_4G (0x2)
  148. #define LSM6DSL_ACC_RANGE_8G (0x3)
  149. #define LSM6DSL_ACC_RANGE_16G (0x1)
  150. #define LSM6DSL_ACC_RANGE_MSK (0X0C)
  151. #define LSM6DSL_ACC_RANGE_POS (2)
  152.  
  153. #define LSM6DSL_ACC_SENSITIVITY_2G (61)
  154. #define LSM6DSL_ACC_SENSITIVITY_4G (122)
  155. #define LSM6DSL_ACC_SENSITIVITY_8G (244)
  156. #define LSM6DSL_ACC_SENSITIVITY_16G (488)
  157.  
  158. #define LSM6DSL_GYRO_RANGE_245 (0x0)
  159. #define LSM6DSL_GYRO_RANGE_500 (0x1)
  160. #define LSM6DSL_GYRO_RANGE_1000 (0x2)
  161. #define LSM6DSL_GYRO_RANGE_2000 (0x3)
  162. #define LSM6DSL_GYRO_RANGE_MSK (0X0C)
  163. #define LSM6DSL_GYRO_RANGE_POS (2)
  164.  
  165. #define LSM6DSL_GYRO_SENSITIVITY_245DPS (8750)
  166. #define LSM6DSL_GYRO_SENSITIVITY_500DPS (17500)
  167. #define LSM6DSL_GYRO_SENSITIVITY_1000DPS (35000)
  168. #define LSM6DSL_GYRO_SENSITIVITY_2000DPS (70000)
  169.  
  170. #define LSM6DSL_SHIFT_EIGHT_BITS (8)
  171. #define LSM6DSL_16_BIT_SHIFT (0xFF)
  172. #define LSM6DSL_ACC_MUL (1000)
  173. #define LSM6DSL_GYRO_MUL (1)
  174.  
  175. #define LSM6DSL_ACC_DEFAULT_ODR_100HZ (100)
  176. #define LSM6DSL_GYRO_DEFAULT_ODR_100HZ (100)
  177.  
  178. #define LSM6DSL_GET_BITSLICE(regvar, bitname) \
  179.     ((regvar & bitname##_MSK) >> bitname##_POS)
  180.  
  181. #define LSM6DSL_SET_BITSLICE(regvar, bitname, val) \
  182.     ((regvar & ~bitname##_MSK) | ((val << bitname##_POS) & bitname##_MSK))
  183.  
  184. typedef enum {
  185.     ACC_RANGE_2G,
  186.     ACC_RANGE_4G,
  187.     ACC_RANGE_8G,
  188.     ACC_RANGE_16G,
  189.     ACC_RANGE_6G,
  190.     ACC_RANGE_12G,
  191.     ACC_RANGE_24G,
  192.     ACC_RANGE_100G,
  193.     ACC_RANGE_200G,
  194.     ACC_RANGE_400G,
  195.     ACC_RANGE_MAX
  196. } acc_range_e;
  197.  
  198. typedef enum {
  199.     GYRO_RANGE_125DPS,
  200.     GYRO_RANGE_250DPS,
  201.     GYRO_RANGE_500DPS,
  202.     GYRO_RANGE_1000DPS,
  203.     GYRO_RANGE_2000DPS,
  204.     GYRO_RANGE_MAX
  205. } gyro_range_e;
  206.  
  207. static int32_t lsm6dsl_acc_factor[ACC_RANGE_MAX] = {
  208.     LSM6DSL_ACC_SENSITIVITY_2G, LSM6DSL_ACC_SENSITIVITY_4G,
  209.     LSM6DSL_ACC_SENSITIVITY_8G, LSM6DSL_ACC_SENSITIVITY_16G
  210. };
  211. static int32_t lsm6dsl_gyro_factor[GYRO_RANGE_MAX] = {
  212.     0, LSM6DSL_GYRO_SENSITIVITY_245DPS, LSM6DSL_GYRO_SENSITIVITY_500DPS,
  213.     LSM6DSL_GYRO_SENSITIVITY_1000DPS, LSM6DSL_GYRO_SENSITIVITY_2000DPS
  214. };
  215.  
  216. typedef enum {
  217.     DEV_POWER_OFF = 0,
  218.     DEV_POWER_ON,
  219.     DEV_SLEEP,
  220.     DEV_SUSPEND,
  221.     DEV_DEEP_SUSPEND,
  222. } LSM6DSL_power_mode;
  223.  
  224. static int32_t cur_acc_factor  = 0;
  225. static int32_t cur_gyro_factor = 0;
  226.  
  227. uint8_t LSM6DSL_ID_check()
  228. {
  229. 	HAL_StatusTypeDef hi2c2_status = 0x00;
  230. 	uint8_t addr_val[3] = {LSM6DSL_ACC_GYRO_WHO_AM_I_REG,0x00,LSM6DSL_CHIP_ID_VALUE};
  231. 	hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
  232. 	if(HAL_OK!=hi2c2_status){
  233. 		printf("get LSM6DSL ID error\r\n");
  234. 		return 1;
  235. 	}
  236. 	if(addr_val[1]!=addr_val[2]){
  237. 		printf("LSM6DSL validate_id is error\r\n");
  238. 		return 1;
  239. 	}
  240. 	printf("LSM6DSL_id:%02X\r\n",addr_val[1]);
  241. 	return 0;
  242. }
  243.  
  244. uint8_t LSM6DSL_soft_reset()
  245. {
  246. 	HAL_StatusTypeDef hi2c2_status = 0x00;
  247. 	/*first read*/
  248. 	uint8_t addr_val[2] = {LSM6DSL_ACC_GYRO_CTRL3_C,0x00};
  249. 	hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
  250. 	if(HAL_OK!=hi2c2_status){
  251. 		printf("get LSM6DSL ACC_GYRO_CTRL3_C error\r\n");
  252. 		return 1;
  253. 	}
  254. 	printf("LSM6DSL ACC_GYRO_CTRL3_C old:%02X\r\n",addr_val[1]);
  255. 	addr_val[1] |= LSM6DSL_RESET_VALUE;
  256. 	printf("LSM6DSL ACC_GYRO_CTRL3_C new:%02X\r\n",addr_val[1]);
  257. 	hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
  258. 	if(HAL_OK!=hi2c2_status){
  259. 		printf("set LSM6DSL ACC_GYRO_CTRL3_C error\r\n");
  260. 		return 1;
  261. 	}
  262. 	printf("successfully LSM6DSL soft reset\r\n");
  263. 	return 0;
  264. }
  265. /*
  266.  * 以正数为例，最大可到32767，如果是Accelerometer数据，量程为2g的情况下，
  267.  * 32768个刻度，一个刻度代表：2g/32768 = 2000mg/32767 = 0.061035mg
  268.  * 例如：如果读出数据为16384，则加速度：16384x0.061035mg = 1000mg = 1g
  269.  */
  270. uint8_t LSM6DSL_acc_set_range(uint32_t range)
  271. {
  272. 	HAL_StatusTypeDef hi2c2_status = 0x00;
  273. 	/*first read*/
  274. 	uint8_t addr_val[2] = {LSM6DSL_ACC_GYRO_CTRL1_XL,0x00};
  275. 	hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
  276. 	if(HAL_OK!=hi2c2_status){
  277. 		printf("get LSM6DSL acc range error\r\n");
  278. 		return 1;
  279. 	}
  280. 	uint8_t tmp   = 0;
  281.     switch (range) {
  282.     	case ACC_RANGE_2G: {
  283.             tmp = LSM6DSL_ACC_RANGE_2G;
  284.         } break;
  285.  
  286.         case ACC_RANGE_4G: {
  287.             tmp = LSM6DSL_ACC_RANGE_4G;
  288.         } break;
  289.  
  290.         case ACC_RANGE_8G: {
  291.             tmp = LSM6DSL_ACC_RANGE_8G;
  292.         } break;
  293.  
  294.         case ACC_RANGE_16G: {
  295.             tmp = LSM6DSL_ACC_RANGE_16G;
  296.         } break;
  297.  
  298.         default:
  299.             break;
  300.     }
  301.     addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_ACC_RANGE, tmp);
  302.     hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
  303. 	if(HAL_OK!=hi2c2_status){
  304. 		printf("set LSM6DSL acc range error\r\n");
  305. 		return 1;
  306. 	}
  307. 	if (range <= ACC_RANGE_16G) {
  308.         cur_acc_factor = lsm6dsl_acc_factor[range];
  309.     }
  310. 	printf("successfully LSM6DSL set acc range\r\n");
  311. 	return 0;
  312. }
  313.  
  314. static uint8_t acc_st_lsm6dsl_hz2odr(uint32_t hz)
  315. {
  316.     if (hz > 3330)
  317.         return LSM6DSL_ACC_ODR_6_66_KHZ;
  318.     else if (hz > 1660)
  319.         return LSM6DSL_ACC_ODR_3_33_KHZ;
  320.     else if (hz > 833)
  321.         return LSM6DSL_ACC_ODR_1_66_KHZ;
  322.     else if (hz > 416)
  323.         return LSM6DSL_ACC_ODR_833_HZ;
  324.     else if (hz > 208)
  325.         return LSM6DSL_ACC_ODR_416_HZ;
  326.     else if (hz > 104)
  327.         return LSM6DSL_ACC_ODR_208_HZ;
  328.     else if (hz > 52)
  329.         return LSM6DSL_ACC_ODR_104_HZ;
  330.     else if (hz > 26)
  331.         return LSM6DSL_ACC_ODR_52_HZ;
  332.     else if (hz > 13)
  333.         return LSM6DSL_ACC_ODR_26_HZ;
  334.     else if (hz >= 2)
  335.         return LSM6DSL_ACC_ODR_12_5_HZ;
  336.     else
  337.         return LSM6DSL_ACC_ODR_1_6_HZ;
  338. }
  339.  
  340. uint8_t LSM6DSL_acc_set_odr(uint32_t hz)
  341. {
  342. 	HAL_StatusTypeDef hi2c2_status = 0x00;
  343. 	/*first read*/
  344. 	uint8_t addr_val[2] = {LSM6DSL_ACC_GYRO_CTRL1_XL,0x00};
  345. 	hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
  346. 	if(HAL_OK!=hi2c2_status){
  347. 		printf("get LSM6DSL acc odr error\r\n");
  348. 		return 1;
  349. 	}
  350. 	uint8_t odr   = acc_st_lsm6dsl_hz2odr(hz);
  351. 	addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_ACC_ODR, odr);
  352. 	hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
  353. 	if(HAL_OK!=hi2c2_status){
  354. 		printf("set LSM6DSL acc odr error\r\n");
  355. 		return 1;
  356. 	}
  357. 	printf("successfully LSM6DSL set acc odr\r\n");
  358. 	return 0;
  359. }
  360.  
  361. uint8_t LSM6DSL_acc_power_mode(LSM6DSL_power_mode mode)
  362. {
  363. 	HAL_StatusTypeDef hi2c2_status = 0x00;
  364. 	/*first read*/
  365. 	uint8_t addr_val[2] = {LSM6DSL_ACC_GYRO_CTRL1_XL,0x00};
  366. 	hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
  367. 	if(HAL_OK!=hi2c2_status){
  368. 		printf("get LSM6DSL acc power_mode error\r\n");
  369. 		return 1;
  370. 	}
  371. 	switch (mode) {
  372. 		case DEV_POWER_ON: {
  373. 			addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_ACC_ODR,LSM6DSL_ACC_ODR_12_5_HZ);
  374. 		}
  375. 		break;
  376. 		case DEV_POWER_OFF: {
  377. 			addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_ACC_ODR,LSM6DSL_ACC_ODR_POWER_DOWN);
  378. 		}
  379. 		break;
  380. 		case DEV_SLEEP: {
  381. 			addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_ACC_ODR,LSM6DSL_ACC_ODR_12_5_HZ);
  382. 		}
  383. 		break;
  384. 		default:
  385. 			break;
  386. 	}
  387. 	hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
  388. 	if(HAL_OK!=hi2c2_status){
  389. 		printf("set LSM6DSL acc power_mode error\r\n");
  390. 		return 1;
  391. 	}
  392. 	printf("successfully LSM6DSL acc power_mode\r\n");
  393. 	return 0;
  394. }
  395.  
  396. uint8_t LSM6DSL_acc_st_open(void)
  397. {
  398. 	uint8_t ret = 0;
  399.  
  400.     ret = LSM6DSL_acc_power_mode( DEV_POWER_ON);
  401.     if (ret>0) {
  402.         return ret;
  403.     }
  404.  
  405.     ret = LSM6DSL_acc_set_range(ACC_RANGE_8G);
  406.     if (ret>0) {
  407.         return ret;
  408.     }
  409.  
  410.     ret = LSM6DSL_acc_set_odr(LSM6DSL_ACC_DEFAULT_ODR_100HZ);
  411.     if (ret>0) {
  412.         return ret;
  413.     }
  414.     printf("successfully LSM6DSL acc open\r\n");
  415.     return 0;
  416. }
  417.  
  418. uint8_t LSM6DSL_acc_st_close(void)
  419. {
  420. 	uint8_t ret = 0;
  421.     ret = LSM6DSL_acc_power_mode(DEV_POWER_OFF);
  422.     if (ret>0) {
  423.         return ret;
  424.     }
  425.     printf("successfully LSM6DSL acc close\r\n");
  426.     return 0;
  427. }
  428.  
  429. //LSM6DSL的满刻度加速度范围为±2/±4/±8/±16 g，角速度范围为±125/±250/±500/±1000/±2000 dps。
  430. uint8_t LSM6DSL_gyro_set_range(uint32_t range)
  431. {
  432. 	HAL_StatusTypeDef hi2c2_status = 0x00;
  433. 	/*first read*/
  434. 	uint8_t addr_val[2] = {LSM6DSL_ACC_GYRO_CTRL2_G,0x00};
  435. 	hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
  436. 	if(HAL_OK!=hi2c2_status){
  437. 		printf("get LSM6DSL gyro range error\r\n");
  438. 		return 1;
  439. 	}
  440. 	uint8_t tmp   = 0;
  441. 	switch (range) {
  442.     	case GYRO_RANGE_250DPS: {
  443.             tmp = LSM6DSL_GYRO_RANGE_245;
  444.         } break;
  445.  
  446.         case GYRO_RANGE_500DPS: {
  447.             tmp = LSM6DSL_GYRO_RANGE_500;
  448.         } break;
  449.  
  450.         case GYRO_RANGE_1000DPS: {
  451.             tmp = LSM6DSL_GYRO_RANGE_1000;
  452.         } break;
  453.  
  454.         case GYRO_RANGE_2000DPS: {
  455.             tmp = LSM6DSL_GYRO_RANGE_2000;
  456.         } break;
  457.  
  458.         default:
  459.             break;
  460. 	}
  461. 	addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_GYRO_RANGE, tmp);
  462.     hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
  463. 	if(HAL_OK!=hi2c2_status){
  464. 		printf("set LSM6DSL gyro range error\r\n");
  465. 		return 1;
  466. 	}
  467. 	if ((range >= GYRO_RANGE_250DPS) && (range <= GYRO_RANGE_2000DPS)) {
  468.         cur_gyro_factor = lsm6dsl_gyro_factor[range];
  469.     }
  470. 	printf("successfully LSM6DSL set gyro range\r\n");
  471. 	return 0;
  472. }
  473.  
  474. static uint8_t gyro_st_lsm6dsl_hz2odr(uint32_t hz)
  475. {
  476.     if (hz > 3330)
  477.         return LSM6DSL_GYRO_ODR_6_66_KHZ;
  478.     else if (hz > 1660)
  479.         return LSM6DSL_GYRO_ODR_3_33_KHZ;
  480.     else if (hz > 833)
  481.         return LSM6DSL_GYRO_ODR_1_66_KHZ;
  482.     else if (hz > 416)
  483.         return LSM6DSL_GYRO_ODR_833_HZ;
  484.     else if (hz > 208)
  485.         return LSM6DSL_GYRO_ODR_416_HZ;
  486.     else if (hz > 104)
  487.         return LSM6DSL_GYRO_ODR_208_HZ;
  488.     else if (hz > 52)
  489.         return LSM6DSL_GYRO_ODR_104_HZ;
  490.     else if (hz > 26)
  491.         return LSM6DSL_GYRO_ODR_52_HZ;
  492.     else if (hz > 13)
  493.         return LSM6DSL_GYRO_ODR_26_HZ;
  494.     else
  495.         return LSM6DSL_GYRO_ODR_12_5_HZ;
  496. }
  497.  
  498. uint8_t LSM6DSL_gyro_set_odr(uint32_t hz)
  499. {
  500. 	HAL_StatusTypeDef hi2c2_status = 0x00;
  501. 	/*first read*/
  502. 	uint8_t addr_val[2] = {LSM6DSL_ACC_GYRO_CTRL2_G,0x00};
  503. 	hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
  504. 	if(HAL_OK!=hi2c2_status){
  505. 		printf("get LSM6DSL gyro odr error\r\n");
  506. 		return 1;
  507. 	}
  508. 	uint8_t odr = gyro_st_lsm6dsl_hz2odr(hz);
  509. 	addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_GYRO_ODR, odr);
  510. 	hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
  511. 	if(HAL_OK!=hi2c2_status){
  512. 		printf("set LSM6DSL gyro odr error\r\n");
  513. 		return 1;
  514. 	}
  515. 	printf("successfully LSM6DSL set gyro odr\r\n");
  516. 	return 0;
  517. }
  518.  
  519. uint8_t LSM6DSL_gyro_power_mode(LSM6DSL_power_mode mode)
  520. {
  521. 	HAL_StatusTypeDef hi2c2_status = 0x00;
  522. 	/*first read*/
  523. 	uint8_t addr_val[2] = {LSM6DSL_ACC_GYRO_CTRL2_G,0x00};
  524. 	hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
  525. 	if(HAL_OK!=hi2c2_status){
  526. 		printf("get LSM6DSL gyro power_mode error\r\n");
  527. 		return 1;
  528. 	}
  529. 	switch (mode) {
  530. 		case DEV_POWER_ON: {
  531. 			addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_GYRO_ODR,LSM6DSL_GYRO_ODR_12_5_HZ);
  532. 			break;
  533. 		}
  534. 		case DEV_POWER_OFF: {
  535. 			addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_GYRO_ODR,LSM6DSL_GYRO_ODR_POWER_DOWN);
  536. 			break;
  537. 		}
  538. 		case DEV_SLEEP: {
  539. 			addr_val[1] = LSM6DSL_SET_BITSLICE(addr_val[1], LSM6DSL_GYRO_ODR,LSM6DSL_GYRO_ODR_12_5_HZ);
  540. 			break;
  541. 		}
  542. 		default:
  543. 			break;
  544. 	}
  545. 	hi2c2_status = HAL_I2C_Mem_Write(&hi2c4,LSM6DSL_I2C_ADDR,addr_val[0],1,&addr_val[1],1,1000);
  546. 	if(HAL_OK!=hi2c2_status){
  547. 		printf("set LSM6DSL gyro power_mode error\r\n");
  548. 		return 1;
  549. 	}
  550. 	printf("successfully LSM6DSL gyro power_mode\r\n");
  551. 	return 0;
  552. }
  553.  
  554. uint8_t LSM6DSL_gyro_st_open(void)
  555. {
  556. 	uint8_t ret = 0;
  557.     ret	= LSM6DSL_gyro_power_mode(DEV_POWER_ON);
  558.     if (ret>0) {
  559.         return 1;
  560.     }
  561.  
  562.     ret = LSM6DSL_gyro_set_range(GYRO_RANGE_1000DPS);
  563.     if (ret>0) {
  564.         return 1;
  565.     }
  566.  
  567.     ret = LSM6DSL_gyro_set_odr(LSM6DSL_GYRO_DEFAULT_ODR_100HZ);
  568.     if (ret>0) {
  569.         return 1;
  570.     }
  571.     printf("successfully LSM6DSL gyro open\r\n");
  572.     return 0;
  573. }
  574.  
  575. uint8_t LSM6DSL_gyro_st_close(void)
  576. {
  577. 	uint8_t ret = 0;
  578.     ret	= LSM6DSL_gyro_power_mode(DEV_POWER_OFF);
  579.     if (ret>0) {
  580.         return 1;
  581.     }
  582.     printf("successfully LSM6DSL gyro close\r\n");
  583.     return 0;
  584. }
  585.  
  586. void LSM6DSL_init()
  587. {
  588. 	if(LSM6DSL_ID_check()>0)
  589. 		return;
  590. 	if(LSM6DSL_soft_reset()>0)
  591. 		return;
  592. 	if(LSM6DSL_acc_power_mode(DEV_POWER_OFF)>0)
  593. 		return;
  594. 	if(LSM6DSL_gyro_power_mode(DEV_POWER_OFF)>0)
  595. 			return;
  596. 	printf("successfully LSM6DSL init\r\n");
  597. }
  598.  
  599. #define DATA_AXIS_X 0
  600. #define DATA_AXIS_Y 1
  601. #define DATA_AXIS_Z 2
  602.  
  603. uint8_t LSM6DSL_acc_read(int32_t *x_data,int32_t *y_data,int32_t *z_data)
  604. {
  605. 	HAL_StatusTypeDef hi2c2_status = 0x00;
  606. 	/*read 0X28,0X29,0X2A,0X2B,0X2C,0X2D*/
  607. 	uint8_t addr[6] = {LSM6DSL_ACC_GYRO_OUTX_L_XL,LSM6DSL_ACC_GYRO_OUTX_H_XL,
  608. 			LSM6DSL_ACC_GYRO_OUTY_L_XL,LSM6DSL_ACC_GYRO_OUTY_H_XL,
  609. 			LSM6DSL_ACC_GYRO_OUTZ_L_XL,LSM6DSL_ACC_GYRO_OUTZ_H_XL};
  610. 	uint8_t val[6] = {0};
  611. 	for(uint8_t i=0; i<6; i++){
  612. 		hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr[i],1,&val[i],1,1000);
  613. 		if(HAL_OK!=hi2c2_status){
  614. 			printf("get LSM6DSL acc_read[0X%02X] error\r\n",addr[i]);
  615. 			return 1;
  616. 		}
  617. 	}
  618. //	printf("read acc reg_data 1:%02X, 2:%02X, 3:%02X, 4:%02X, 5:%02X ,6:%02X\r\n"
  619. //		    		,val[0],val[1],val[2],val[3],val[4],val[5]);
  620. 	int32_t data[3] = {0};
  621. 	data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)val[1])) << LSM6DSL_SHIFT_EIGHT_BITS) | (val[0]));
  622. 	data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)val[3])) << LSM6DSL_SHIFT_EIGHT_BITS) | (val[2]));
  623. 	data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)val[5])) << LSM6DSL_SHIFT_EIGHT_BITS) | (val[4]));
  624.     if (cur_acc_factor != 0)
  625.     {
  626.         data[DATA_AXIS_X] = (data[DATA_AXIS_X] * cur_acc_factor) / LSM6DSL_ACC_MUL;
  627.         data[DATA_AXIS_Y] = (data[DATA_AXIS_Y] * cur_acc_factor) / LSM6DSL_ACC_MUL;
  628.         data[DATA_AXIS_Z] = (data[DATA_AXIS_Z] * cur_acc_factor) / LSM6DSL_ACC_MUL;
  629.     }
  630. //    printf("read acc cur_acc_factor:%ld, X:%ld,Y:%ld,Z:%ld\r\n"
  631. //    		,cur_acc_factor,data[0],data[1],data[2]);
  632.     *x_data = data[DATA_AXIS_X];
  633.     *y_data = data[DATA_AXIS_Y];
  634.     *z_data = data[DATA_AXIS_Z];
  635. 	return 0;
  636. }
  637.  
  638. uint8_t LSM6DSL_gyro_read(int32_t *x_data,int32_t *y_data,int32_t *z_data)
  639. {
  640. 	HAL_StatusTypeDef hi2c2_status = 0x00;
  641. 	/*read 0X22,0X23,0X24,0X25,0X26,0X27*/
  642. 	uint8_t addr[6] = {LSM6DSL_ACC_GYRO_OUTX_L_G,LSM6DSL_ACC_GYRO_OUTX_H_G,
  643. 			LSM6DSL_ACC_GYRO_OUTY_L_G,LSM6DSL_ACC_GYRO_OUTY_H_G,
  644. 			LSM6DSL_ACC_GYRO_OUTZ_L_G,LSM6DSL_ACC_GYRO_OUTZ_H_G};
  645. 	uint8_t val[6] = {0};
  646. 	for(uint8_t i=0; i<6; i++){
  647. 		hi2c2_status = HAL_I2C_Mem_Read(&hi2c4,LSM6DSL_I2C_ADDR,addr[i],1,&val[i],1,1000);
  648. 		if(HAL_OK!=hi2c2_status){
  649. 			printf("get LSM6DSL gyro_read[0X%02X] error\r\n",addr[i]);
  650. 			return 1;
  651. 		}
  652. 	}
  653. //	printf("read gyro reg_data 1:%02X, 2:%02X, 3:%02X, 4:%02X, 5:%02X ,6:%02X\r\n"
  654. //	    		,val[0],val[1],val[2],val[3],val[4],val[5]);
  655. 	int32_t data[3] = {0};
  656. 	data[DATA_AXIS_X] = (int16_t)((((int32_t)((int8_t)val[1])) << LSM6DSL_SHIFT_EIGHT_BITS) | (val[0]));
  657. 	data[DATA_AXIS_Y] = (int16_t)((((int32_t)((int8_t)val[3])) << LSM6DSL_SHIFT_EIGHT_BITS) | (val[2]));
  658. 	data[DATA_AXIS_Z] = (int16_t)((((int32_t)((int8_t)val[5])) << LSM6DSL_SHIFT_EIGHT_BITS) | (val[4]));
  659.  
  660.     if (cur_gyro_factor != 0) {
  661.         data[DATA_AXIS_X] = (data[DATA_AXIS_X] * cur_gyro_factor) / LSM6DSL_GYRO_MUL;
  662.         data[DATA_AXIS_Y] = (data[DATA_AXIS_Y] * cur_gyro_factor) / LSM6DSL_GYRO_MUL;
  663.         data[DATA_AXIS_Z] = (data[DATA_AXIS_Z] * cur_gyro_factor) / LSM6DSL_GYRO_MUL;
  664.     }
  665. //    printf("read gyro cur_gyro_factor:%ld, X:%ld,Y:%ld,Z:%ld\r\n"
  666. //    		,cur_gyro_factor,data[0],data[1],data[2]);
  667.     *x_data = data[DATA_AXIS_X];
  668.     *y_data = data[DATA_AXIS_Y];
  669.     *z_data = data[DATA_AXIS_Z];
  670. 	return 0;
  671. }

2.3 传感器数据采集与输出源码设计

        在main.c文件中，添加各个外设驱动头文件支持

  1. /* Private includes ----------------------------------------------------------*/
  2. /* USER CODE BEGIN Includes */
  3. #include "../../ICore/key/key.h"
  4. #include "../../ICore/led/led.h"
  5. #include "../../ICore/print/print.h"
  6. #include "../../ICore/usart/usart.h"
  7. #include "../../ICore/LSM6DSL/LSM6DSL.h"
  8. /* USER CODE END Includes */

        打印实时采集的三轴加速度信息

  1. /* Private user code ---------------------------------------------------------*/
  2. /* USER CODE BEGIN 0 */
  3. void out_print(int32_t acc_x, int32_t acc_y, int32_t acc_z)
  4. {
  5. 	if(acc_x>0)
  6. 		printf("%d.%d, ",(acc_x*98)/10000,((acc_x*98)%10000)/100);
  7. 	else
  8. 		printf("%d.%d, ",(acc_x*98)/10000,((-acc_x*98)%10000)/100);
  9. 	if(acc_y>0)
  10. 		printf("%d.%d, ",(acc_y*98)/10000,((acc_y*98)%10000)/100);
  11. 	else
  12. 		printf("%d.%d, ",(acc_y*98)/10000,((-acc_y*98)%10000)/100);
  13. 	if(acc_z>0)
  14. 		printf("%d.%d, ",(acc_z*98)/10000,((acc_z*98)%10000)/100);
  15. 	else
  16. 		printf("%d.%d, ",(acc_z*98)/10000,((-acc_z*98)%10000)/100);
  17. }
  18. /* USER CODE END 0 */

        在main函数中，初始化各个外设

  1. int main(void)
  2. {
  3.   /* USER CODE BEGIN 1 */
  4.     int32_t acc_x,acc_y,acc_z;
  5.   /* USER CODE END 1 */
  6.  
  7.   /* MCU Configuration--------------------------------------------------------*/
  8.  
  9.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  10.   HAL_Init();
  11.  
  12.   /* USER CODE BEGIN Init */
  13.  
  14.   /* USER CODE END Init */
  15.  
  16.   /* Configure the system clock */
  17.   SystemClock_Config();
  18.  
  19.   /* USER CODE BEGIN SysInit */
  20.  
  21.   /* USER CODE END SysInit */
  22.  
  23.   /* Initialize all configured peripherals */
  24.   MX_GPIO_Init();
  25.   MX_DMA_Init();
  26.   MX_I2C4_Init();
  27.   MX_LPUART1_UART_Init();
  28.   /* USER CODE BEGIN 2 */
  29.   ResetPrintInit(&hlpuart1);
  30.   HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData, 1); //再开启接收中断
  31.   HLPUSART_RX_STA = 0;
  32.   //LSM6DSL
  33.   LSM6DSL_init();
  34.   LSM6DSL_acc_st_open();
  35.   acc_x = acc_y = acc_z = 0;
  36.   uint8_t menu = 0;
  37.   uint8_t step_size = 3;
  38.   /* USER CODE END 2 */

        在main函数循环体内，实现根据按键采集传感器数据（开发板正面朝上）：

        1）保持开发板在桌面不动，按键KEY0按下时，采集静止不动姿态时的三轴加速度，并每采集三次，输出一次姿态结果[1,0,0]，再次按下KEY0时停止采集

        2）保持开发板在桌面左右移动，按键KEY1按下时，采集左右移动姿态时的三轴加速度，并每采集三次，输出一次姿态结果[0,1,0]，再次按下KEY1时停止采集

        3）保持开发板在桌面上上下移动（垂直方向），按键KEY2按下时，采集左右移动姿态时的三轴加速度，并每采集三次，输出一次姿态结果[0,0,1]，再次按下KEY2时停止采集

  1.  /* USER CODE BEGIN WHILE */
  2.   while (1)
  3.   {
  4. 	  if(HLPUSART_RX_STA&0xC000){//溢出或换行，重新开始
  5.   		  printf("%.*s\r\n",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
  6.   		  HLPUSART_RX_STA=0;//接收错误,重新开始
  7.   		  HAL_Delay(100);//等待
  8.   	  }
  9. 	  if(KEY_0())
  10. 	  {
  11. 		  if(menu&0x01)
  12. 			  menu &= 0XFE;	//取消静止不动数据刷新
  13. 		  else{
  14. 			  menu |= 0X01; //开启静止不动数据刷新
  15. 		  }
  16. 		  menu &= 0XF9; //取消其他数据刷新
  17. 	  }
  18. 	  if(KEY_1())
  19. 	  {
  20. 		  if(menu&0x02)
  21. 			  menu &= 0XFD;	//取消左右移动数据刷新
  22. 		  else{
  23. 			  menu |= 0X02; //开启左右移动数据刷新
  24. 		  }
  25. 		  menu &= 0XFA; //取消其他数据刷新
  26.  
  27. 	  }
  28. 	  if(KEY_2())
  29. 	  {
  30. 		  if(menu&0x04)
  31. 			  menu &= 0XFB; //取消上下移动数据刷新
  32. 		  else{
  33. 			  menu |= 0X04; //开启上下移动数据刷新
  34. 		  }
  35. 		  menu &= 0XFC;	//取消其他数据刷新
  36.  
  37. 	  }
  38. 	  if(menu&0x01)//静止不动
  39.   	  {
  40. 		  for(uint8_t i =0; i<step_size;i++){
  41. 	  		LSM6DSL_acc_read(&acc_x,&acc_y,&acc_z);
  42. 	  		out_print(acc_x,acc_y,acc_z);
  43. 	  		HAL_Delay(100);//等待
  44. 		  }
  45. 	  		printf("1, 0, 0\r\n");
  46. 	  		Toggle_led0();
  47.   	  }
  48.   	  if(menu&0x02)//左右移动
  49.   	  {
  50. 		  for(uint8_t i =0; i<step_size;i++){
  51. 	  		LSM6DSL_acc_read(&acc_x,&acc_y,&acc_z);
  52. 	  		out_print(acc_x,acc_y,acc_z);
  53. 	  		HAL_Delay(100);//等待
  54. 		  }
  55.     		printf("0, 1, 0\r\n");
  56.     		Toggle_led1();
  57.   	  }
  58.   	  if(menu&0x04)//上下移动
  59.   	  {
  60. 		  for(uint8_t i =0; i<step_size;i++){
  61. 	  		LSM6DSL_acc_read(&acc_x,&acc_y,&acc_z);
  62. 	  		out_print(acc_x,acc_y,acc_z);
  63. 	  		HAL_Delay(100);//等待
  64. 		  }
  65.     		printf("0, 0, 1\r\n");
  66.     		Toggle_led2();
  67.   	  }
  68.     /* USER CODE END WHILE */

2.4 编辑下载程序，采集数据

        编译程序及加载到开发板

         打开串口助手，连接开发板，先清空屏幕，然后按上述功能操作进行数据采集，每种姿态采集大概一分钟的数据，完成后保存数据。

         创建目录My_HAR_Study，将保存的txt文件拷贝到该目录，并将该文件修改为.csv后缀

 三、模型训练

        在该目录下，创建myrun.py文件，内容如下：

  1. #模型训练文件 myrun.py 训练 epochs 1000次
  2. # myrun.py
  3. '''
  4. 开发板（正面朝上）姿态检测
  5. 静止不动、左右移动、上下移动
  6.  
  7. 输入层 -> 隐藏层 -> 输出层
  8. '''
  9.  
  10. # 导入工具包
  11. import pandas as pd
  12. import numpy as np
  13. from keras.models import Sequential
  14. from keras.layers import Dense, Dropout
  15. from keras.optimizers import SGD
  16.  
  17. # %% 读取数据
  18. data = pd.read_csv('SaveWindows2023_1_28_16-31-14.csv', sep=',', header=None)
  19. data_x = data.loc[:, 0:8]  # 取1~9列所有数据
  20. data_y = data.loc[:, 9:11]
  21. data_y.astype(int)
  22. #
  23. print("-x-")
  24. print(data_x[0:2])
  25. print("-y-")
  26. print(data_y[0:2])
  27.  
  28. # %% 建立模型
  29. model = Sequential()
  30. # Dense(64) 是一个具有 64 个隐藏神经元的全连接层。
  31. # 在第一层必须指定所期望的输入数据尺寸：
  32. # 在这里，是一个 9 维的向量。
  33. model.add(Dense(64, activation='relu', input_dim=9))
  34. model.add(Dense(32, activation='relu'))
  35. model.add(Dense(3, activation='softmax'))
  36.  
  37. sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
  38. model.compile(loss='categorical_crossentropy',
  39.               optimizer=sgd,
  40.               metrics=['accuracy'])
  41.  
  42. model.fit(data_x, data_y,
  43.           epochs=1000,
  44.           batch_size=72)
  45. score = model.evaluate(data_x, data_y, batch_size=72)
  46.  
  47. # 保存模型
  48. model.save('myhar.h5')

         当前目录启动命令行工具，运行python3 .\myrun.py命令，

四、cube.AI配置及c模型生成

        回到数据采集工程（stm32L496VGT6_AI），双击.ioc打开cubeMX配置页面。

         添加my_har模型，选择刚刚生成的keras模型文件(.h5)，注意值生成模型，不需要应用程序。

         分析结果显示，模型精度很差，意料之中，毕竟神经网络层只进行了简单设计，实现不了那么复杂姿态识别，但验证模型没有错误，支持转换，可以用来演示完开发流程就OK。

         根据分析稍微调整一下heap和stack大小

         生成输出代码如下图所示。

五、模型调用及测试

        在项目属性设置页面，开启float支持

          在main.c源文件中，添加AI模型库的头文件

  1. /* Private includes ----------------------------------------------------------*/
  2. /* USER CODE BEGIN Includes */
  3. #include <stdlib.h>
  4. #include "../../ICore/key/key.h"
  5. #include "../../ICore/led/led.h"
  6. #include "../../ICore/print/print.h"
  7. #include "../../ICore/usart/usart.h"
  8. #include "../../ICore/LSM6DSL/LSM6DSL.h"
  9. #include "../../X-CUBE-AI/app/my_har.h"
  10. #include "../../X-CUBE-AI/app/my_har_data.h"
  11. /* USER CODE END Includes */

        在main.c源文件中，添加AI模型库支持函数

  1. /* Private user code ---------------------------------------------------------*/
  2. /* USER CODE BEGIN 0 */
  3. void out_print(int32_t acc_x, int32_t acc_y, int32_t acc_z)
  4. {
  5. 	if(acc_x>0)
  6. 		printf("%d.%d, ",(acc_x*98)/10000,((acc_x*98)%10000)/100);
  7. 	else
  8. 		printf("%d.%d, ",(acc_x*98)/10000,((-acc_x*98)%10000)/100);
  9. 	if(acc_y>0)
  10. 		printf("%d.%d, ",(acc_y*98)/10000,((acc_y*98)%10000)/100);
  11. 	else
  12. 		printf("%d.%d, ",(acc_y*98)/10000,((-acc_y*98)%10000)/100);
  13. 	if(acc_z>0)
  14. 		printf("%d.%d, ",(acc_z*98)/10000,((acc_z*98)%10000)/100);
  15. 	else
  16. 		printf("%d.%d, ",(acc_z*98)/10000,((-acc_z*98)%10000)/100);
  17. }
  18.  
  19. /* Global handle to reference the instantiated C-model */
  20. static ai_handle network = AI_HANDLE_NULL;
  21.  
  22. /* Global c-array to handle the activations buffer */
  23. AI_ALIGNED(32)
  24. static ai_u8 activations[AI_MY_HAR_DATA_ACTIVATIONS_SIZE];
  25.  
  26. AI_ALIGNED(32)
  27. static ai_float in_data[AI_MY_HAR_IN_1_SIZE];
  28.  
  29. AI_ALIGNED(32)
  30. static ai_float out_data[AI_MY_HAR_OUT_1_SIZE];
  31.  
  32. /* Array of pointer to manage the model's input/output tensors */
  33. static ai_buffer *ai_input;
  34. static ai_buffer *ai_output;
  35. static ai_buffer_format fmt_input;
  36. static ai_buffer_format fmt_output;
  37.  
  38. #define NSIZE 3
  39.  
  40. void buf_print(void)
  41. {
  42. 	printf("in_data:");
  43. 	for (int i=0; i<AI_MY_HAR_IN_1_SIZE; i++)
  44. 	{
  45. 		printf("%.2f ",((ai_float*)in_data)[i]);
  46. 	}
  47. 	printf("\n");
  48. 	printf("out_data:");
  49. 	for (int i=0; i<AI_MY_HAR_OUT_1_SIZE; i++)
  50. 	{
  51. 		printf("%.2f ",((ai_float*)out_data)[i]);
  52. 	}
  53. 	printf("\n");
  54. }
  55.  
  56. void aiPrintBufInfo(const ai_buffer *buffer)
  57. {
  58. 	printf("(%lu, %lu, %lu, %lu)", AI_BUFFER_SHAPE_ELEM(buffer, AI_SHAPE_BATCH),
  59. 			  	  	  	  	  	  	 AI_BUFFER_SHAPE_ELEM(buffer, AI_SHAPE_HEIGHT),
  60. 	                                 AI_BUFFER_SHAPE_ELEM(buffer, AI_SHAPE_WIDTH),
  61. 	                                 AI_BUFFER_SHAPE_ELEM(buffer, AI_SHAPE_CHANNEL));
  62. 	printf(" buffer_size:%d ", (int)AI_BUFFER_SIZE(buffer));
  63. }
  64.  
  65. void aiPrintDataType(const ai_buffer_format fmt)
  66. {
  67.     if (AI_BUFFER_FMT_GET_TYPE(fmt) == AI_BUFFER_FMT_TYPE_FLOAT)
  68.     	printf("float%d ", (int)AI_BUFFER_FMT_GET_BITS(fmt));
  69.     else if (AI_BUFFER_FMT_GET_TYPE(fmt) == AI_BUFFER_FMT_TYPE_BOOL) {
  70.     	printf("bool%d ", (int)AI_BUFFER_FMT_GET_BITS(fmt));
  71.     } else { /* integer type */
  72.     	printf("%s%d ", AI_BUFFER_FMT_GET_SIGN(fmt)?"i":"u",
  73.             (int)AI_BUFFER_FMT_GET_BITS(fmt));
  74.     }
  75. }
  76.  
  77. void aiPrintDataInfo(const ai_buffer *buffer,const ai_buffer_format fmt)
  78. {
  79. 	  if (buffer->data)
  80. 		  printf(" @0x%X/%d \n",
  81. 	        (int)buffer->data,
  82. 	        (int)AI_BUFFER_BYTE_SIZE(AI_BUFFER_SIZE(buffer), fmt)
  83. 	    );
  84. 	  else
  85. 		  printf(" (User Domain)/%d \n",
  86. 	        (int)AI_BUFFER_BYTE_SIZE(AI_BUFFER_SIZE(buffer), fmt)
  87. 	    );
  88. }
  89.  
  90. void aiPrintNetworkInfo(const ai_network_report report)
  91. {
  92. 	printf("Model name      : %s\n", report.model_name);
  93. 	printf(" model signature : %s\n", report.model_signature);
  94. 	printf(" model datetime     : %s\r\n", report.model_datetime);
  95. 	printf(" compile datetime   : %s\r\n", report.compile_datetime);
  96. 	printf(" runtime version    : %d.%d.%d\r\n",
  97. 	      report.runtime_version.major,
  98. 	      report.runtime_version.minor,
  99. 	      report.runtime_version.micro);
  100. 	if (report.tool_revision[0])
  101. 		printf(" Tool revision      : %s\r\n", (report.tool_revision[0])?report.tool_revision:"");
  102. 	printf(" tools version      : %d.%d.%d\r\n",
  103. 	      report.tool_version.major,
  104. 	      report.tool_version.minor,
  105. 	      report.tool_version.micro);
  106. 	printf(" complexity         : %lu MACC\r\n", (unsigned long)report.n_macc);
  107. 	printf(" c-nodes            : %d\r\n", (int)report.n_nodes);
  108.  
  109. 	printf(" map_activations    : %d\r\n", report.map_activations.size);
  110. 	  for (int idx=0; idx<report.map_activations.size;idx++) {
  111. 	      const ai_buffer *buffer = &report.map_activations.buffer[idx];
  112. 	      printf("  [%d] ", idx);
  113. 	      aiPrintBufInfo(buffer);
  114. 	      printf("\r\n");
  115. 	  }
  116.  
  117. 	printf(" map_weights        : %d\r\n", report.map_weights.size);
  118. 	  for (int idx=0; idx<report.map_weights.size;idx++) {
  119. 	      const ai_buffer *buffer = &report.map_weights.buffer[idx];
  120. 	      printf("  [%d] ", idx);
  121. 	      aiPrintBufInfo(buffer);
  122. 	      printf("\r\n");
  123. 	  }
  124. }
  125.  
  126. /*
  127.  * Bootstrap
  128.  */
  129. int aiInit(void) {
  130.   ai_error err;
  131.  
  132.   /* Create and initialize the c-model */
  133.   const ai_handle acts[] = { activations };
  134.   err = ai_my_har_create_and_init(&network, acts, NULL);
  135.   if (err.type != AI_ERROR_NONE) {
  136. 	  printf("ai_error_type:%d,ai_error_code:%d\r\n",err.type,err.code);
  137.   };
  138.  
  139.   ai_network_report report;
  140.   if (ai_my_har_get_report(network, &report) != true) {
  141.       printf("ai get report error\n");
  142.       return -1;
  143.   }
  144.  
  145.   aiPrintNetworkInfo(report);
  146.  
  147.   /* Reteive pointers to the model's input/output tensors */
  148.   ai_input = ai_my_har_inputs_get(network, NULL);
  149.   ai_output = ai_my_har_outputs_get(network, NULL);
  150.   //
  151.   fmt_input = AI_BUFFER_FORMAT(ai_input);
  152.   fmt_output = AI_BUFFER_FORMAT(ai_output);
  153.  
  154.   printf(" n_inputs/n_outputs : %u/%u\r\n", report.n_inputs,
  155.             report.n_outputs);
  156.   printf("input :");
  157.   aiPrintBufInfo(ai_input);
  158.   aiPrintDataType(fmt_input);
  159.   aiPrintDataInfo(ai_input, fmt_input);
  160.   //
  161.   printf("output :");
  162.   aiPrintBufInfo(ai_output);
  163.   aiPrintDataType(fmt_output);
  164.   aiPrintDataInfo(ai_output, fmt_output);
  165.   return 0;
  166. }
  167.  
  168. int acquire_and_process_data(void *in_data,uint8_t index, int32_t acc_x, int32_t acc_y, int32_t acc_z)
  169. {
  170. 	char buf_srt[64]={0};
  171. 	if(acc_x>0){
  172. 		sprintf(buf_srt,"%d.%d, ",(acc_x*98)/10000,((acc_x*98)%10000)/100);
  173. 		((ai_float*)in_data)[NSIZE*index] =(float)atof(buf_srt);
  174. 	}else{
  175. 		sprintf(buf_srt,"%d.%d, ",(acc_x*98)/10000,((-acc_x*98)%10000)/100);
  176. 		((ai_float*)in_data)[NSIZE*index] =(float)atof(buf_srt);
  177. 	}
  178. 	if(acc_y>0){
  179. 		sprintf(buf_srt,"%d.%d, ",(acc_y*98)/10000,((acc_y*98)%10000)/100);
  180. 		((ai_float*)in_data)[NSIZE*index+1] =(float)atof(buf_srt);
  181. 	}else{
  182. 		sprintf(buf_srt,"%d.%d, ",(acc_y*98)/10000,((-acc_y*98)%10000)/100);
  183. 		((ai_float*)in_data)[NSIZE*index+1] =(float)atof(buf_srt);
  184. 	}
  185. 	if(acc_z>0){
  186. 		sprintf(buf_srt,"%d.%d, ",(acc_z*98)/10000,((acc_z*98)%10000)/100);
  187. 		((ai_float*)in_data)[NSIZE*index+2] =(float)atof(buf_srt);
  188. 	}else{
  189. 		sprintf(buf_srt,"%d.%d, ",(acc_z*98)/10000,((-acc_z*98)%10000)/100);
  190. 		((ai_float*)in_data)[NSIZE*index+2] =(float)atof(buf_srt);
  191. 	}
  192. 	return 0;
  193. }
  194. /*
  195.  * Run inference
  196.  */
  197. int aiRun(const void *in_data, void *out_data) {
  198.   ai_i32 n_batch;
  199.   ai_error err;
  200.  
  201.   /* 1 - Update IO handlers with the data payload */
  202.   ai_input[0].data = AI_HANDLE_PTR(in_data);
  203.   ai_output[0].data = AI_HANDLE_PTR(out_data);
  204.  
  205.   /* 2 - Perform the inference */
  206.   n_batch = ai_my_har_run(network, &ai_input[0], &ai_output[0]);
  207.   if (n_batch != 1) {
  208. 	  err = ai_my_har_get_error(network);
  209. 	  printf("ai_error_type:%d,ai_error_code:%d\r\n",err.type,err.code);
  210.   };
  211.  
  212.   return 0;
  213. }
  214.  
  215. /* USER CODE END 0 */

        在main函数中初始化ai模型

  1.   /* USER CODE BEGIN 2 */
  2.   ResetPrintInit(&hlpuart1);
  3.   HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData, 1); //再开启接收中断
  4.   HLPUSART_RX_STA = 0;
  5.   //LSM6DSL
  6.   LSM6DSL_init();
  7.   LSM6DSL_acc_st_open();
  8.   acc_x = acc_y = acc_z = 0;
  9.   uint8_t menu = 0;
  10.   uint8_t step_size = NSIZE;
  11.   //
  12.   aiInit();
  13.   buf_print();
  14.   /* USER CODE END 2 */

        在main函数循环体中，通过串口lpuart1调试发送test，开启将实时数据推送给ai模型

  1.   /* Infinite loop */
  2.   /* USER CODE BEGIN WHILE */
  3.   while (1)
  4.   {
  5. 	  if(HLPUSART_RX_STA&0xC000){//溢出或换行，重新开始
  6.   		  printf("%.*s\r\n",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
  7.   		if(strstr((const char*)HLPUSART_RX_BUF,(const char*)"test"))
  8. 		  {
  9.   		      menu = 0x08;
  10. 		  }
  11.   		  HLPUSART_RX_STA=0;//接收错误,重新开始
  12.   		  HAL_Delay(100);//等待
  13.   	  }
  14. 	  if(KEY_0())
  15. 	  {
  16. 		  if(menu&0x01)
  17. 			  menu &= 0XFE;	//取消静止不动数据刷新
  18. 		  else{
  19. 			  menu |= 0X01; //开启静止不动数据刷新
  20. 		  }
  21. 		  menu &= 0XF9; //取消其他数据刷新
  22. 	  }
  23. 	  if(KEY_1())
  24. 	  {
  25. 		  if(menu&0x02)
  26. 			  menu &= 0XFD;	//取消左右移动数据刷新
  27. 		  else{
  28. 			  menu |= 0X02; //开启左右移动数据刷新
  29. 		  }
  30. 		  menu &= 0XFA; //取消其他数据刷新
  31.  
  32. 	  }
  33. 	  if(KEY_2())
  34. 	  {
  35. 		  if(menu&0x04)
  36. 			  menu &= 0XFB; //取消上下移动数据刷新
  37. 		  else{
  38. 			  menu |= 0X04; //开启上下移动数据刷新
  39. 		  }
  40. 		  menu &= 0XFC;	//取消其他数据刷新
  41.  
  42. 	  }
  43. 	  if(menu&0x01)//静止不动
  44.   	  {
  45. 		  for(uint8_t i =0; i<step_size;i++){
  46. 	  		LSM6DSL_acc_read(&acc_x,&acc_y,&acc_z);
  47. 	  		out_print(acc_x,acc_y,acc_z);
  48. 	  		HAL_Delay(100);//等待
  49. 		  }
  50. 	  		printf("1, 0, 0\r\n");
  51. 	  		Toggle_led0();
  52.   	  }
  53.   	  if(menu&0x02)//左右移动
  54.   	  {
  55. 		  for(uint8_t i =0; i<step_size;i++){
  56. 	  		LSM6DSL_acc_read(&acc_x,&acc_y,&acc_z);
  57. 	  		out_print(acc_x,acc_y,acc_z);
  58. 	  		HAL_Delay(100);//等待
  59. 		  }
  60.     		printf("0, 1, 0\r\n");
  61.     		Toggle_led1();
  62.   	  }
  63.   	  if(menu&0x04)//上下移动
  64.   	  {
  65. 		  for(uint8_t i =0; i<step_size;i++){
  66. 	  		LSM6DSL_acc_read(&acc_x,&acc_y,&acc_z);
  67. 	  		out_print(acc_x,acc_y,acc_z);
  68. 	  		HAL_Delay(100);//等待
  69. 		  }
  70.     		printf("0, 0, 1\r\n");
  71.     		Toggle_led2();
  72.   	  }
  73.   	  if(menu&0x08)//测试
  74.   	  {
  75.   		for(uint8_t i =0; i<step_size;i++){
  76.   			LSM6DSL_acc_read(&acc_x,&acc_y,&acc_z);
  77.   			acquire_and_process_data(in_data,i,acc_x,acc_y,acc_z);
  78.   			HAL_Delay(100);//等待
  79.   		}
  80.   		aiRun(in_data, out_data);
  81.   		buf_print();
  82.   	  }
  83.     /* USER CODE END WHILE */

        编译及下载程序

         串口助手通过lpuart1连接开发板，发送“test”,开启AI计算，静止不动开发板情况如下：

         左右移动开发板测试输出：

         上下移动（垂直方向）开发板测试输出：

        通过测试可以看出，基本能识别开发板的行为，若需要更准确的识别，更好数据采集方法，也可以更多姿态行为模式计算（开发板不同朝向、倾斜度等）

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/338918
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号