devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【嵌入式操作系统】FreeRTOS_C++_创建及LVGL相关问题_c++开发rtos

作者：从前慢现在也慢 | 2024-06-07 05:24:37

赞

踩

c++开发rtos

MCU：STM32F407VET6

开发环境：CLion

说明：

        1，名字太长的... ...，我会打省略号

        2，自带的截屏工具，故图片上的提示信息均为纯手工【涂鸦】

        3，本篇基于CLion开发的，也可供其他开发软件如IAR、Keil等参考

        4，相关问题放在最下面

一、创建基本工程

1，CLion中创建项目

首先在CLion中创建STM32CubeMX项目，此处名称为MyRTOS_Cpp, 创建完后如下

2，配置CubeMX

①基本配置

在CLion中打开CubeMX并更换芯片

配置SYS，选择Serial Wire和TIM7（SysTick被FreeRTOS占用）

配置RCC，选择Crystal/Cera ... ...

配置时钟树，先查看自己板子的原理图，看看外部晶振是多少，此处为12MHz。

填好外部晶振频率后，连接通路，本篇使用的MCU主板最大频率为168MHz，故有

②配置RTOS

下载RTOS软件包，点击图示位置或按下快捷键Alt+O

向下滑，找到后点击旁边的Install（此处已安装过，所以FreeRTOS一栏中未显示Install）

再点击OK

回到主界面后，在左边找到Middlware ... ... ，并点击其下的FREERTOS

开启后，并在下面的Config parameters中使能FPU，再在其上的Advanced settings中，把第一个使能

③生成工程

切换到Project Manger，并选择工具链STM32CubeMX

在左方中选择Code Generator，并勾选生成.c/.h的那个选项

按下快捷键Ctrl+S，会默认给你弹出一个写好名称的窗口，点击保存即可

然后又会弹出一个窗口（删除CLion先前生成的无用文件），点击OK即可

点击右上角的GENERATE CODE

二、整理架构

1，基本整理

回到CLion后，会默认弹出一个窗口（会弹两次），跳过即可

打开CMakeLists，把FPU打开（CubeMX生成时是默认注释的）

取消注释后如下

重新加载CMake，然后再点击个锤子，没有问题后再进行下一步

2，更改结构

【说明】：本篇采用的开发架构是硬件驱动层+功能模块层+应用层，可自行按需构建适合自己的架构，本篇仅做引导

①创建目录

右键左栏项目下的MyRTOS_Cpp，再点击如下选项，打开资源管理器，并进入该工程目录里

创建两个目录Application（应用层）和FunctionModuleLayer（功能模块层），并在其下创建子目录inc和src

在Drivers（硬件驱动层）目录下创建User（不重要，可以不创建），并也在其下添加inc和src

②分配文件

把下面两个头文件及其源文件移至FunctionModuleLayer（功能模块层）对应的子目录

把main.c移至Application（应用层）下的src中，并更改后缀名

把下面文件移至Drivers（硬件驱动层）下User里的src中

三、确立架构

1，修改CMakeLists

把刚刚填的文件包含起来，并重新加载CMake

  1. include_directories(
  2.         Application/inc
  3.         Drivers/USER/inc
  4.         FunctionalModuleLayer/inc
  5.         Core/Inc Drivers/STM32F4xx_HAL_Driver/Inc
  6.         Drivers/STM32F4xx_HAL_Driver/Inc/Legacy
  7.         Middlewares/Third_Party/FreeRTOS/Source/include
  8.         Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2
  9.         Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM4F
  10.         Drivers/CMSIS/Device/ST/STM32F4xx/Include Drivers/CMSIS/Include)
  11.  
  12. file(GLOB_RECURSE SOURCES "Core/*.*" "Middlewares/*.*" "Drivers/*.*" "Application/*.*" "FunctionalModuleLayer/*.*" )

2，Drivers（硬件驱动层）

在Drivers下的User中，分别在对应位置创建user_init.h和user.init.c，用于代替main.h

在把main文件中的代码复制到user_init中（头文件对头文件，源文件对源文件），再删除无用的内容

user_init.h如下

  1. #ifndef RTOS_Cpp_USER_INIT_H
  2. #define RTOS_Cpp_USER_INIT_H
  3.  
  4. #ifdef __cplusplus
  5. extern "C" {
  6. #endif
  7.  
  8. #include "stm32f4xx.h"
  9. #include "stm32f4xx_hal.h"
  10.  
  11. void Error_Handler(void);
  12.  
  13. #ifdef __cplusplus
  14. }
  15. #endif
  16. #endif

user_init.c如下

  1. #include "user_init.h"
  2.  
  3.  
  4. void Error_Handler(void)
  5. {
  6.     __disable_irq();
  7.     while (1)
  8.     {
  9.     }
  10. }

3，FunctionModuleLayer（功能模块层）

把gpio.h里的头文件包含（原为main.h）改为user_init.h，到资源管理器中把gpio.c改为gpio.cpp(纯粹为了统一，但stm32f4xx_it.c不能这样做，不然启动文件识别不出来)

创建文件时，把所有勾选去掉

①MyTask

在此目录下创建MyTask，用于代替先前的FreeRTOS.c，同时以后的任务函数开发就可以放在此处

MyTask.h

  1. #ifndef RTOS_Cpp_MYTASK_H
  2. #define RTOS_Cpp_MYTASK_H
  3. #include "cmsis_os.h"
  4. #include "FreeRTOS.h"
  5. #include "task.h"
  6. /*用户头文件*/
  7. #include "user_init.h"
  8.  
  9. /*任务函数句柄*/
  10. extern osThreadId_t defaultTaskHandle;
  11. const osThreadAttr_t defaultTask_attributes = {
  12.         .name = "defaultTask",
  13.         .stack_size = 128 * 4,
  14.         .priority = (osPriority_t) osPriorityNormal,
  15. };
  16.  
  17.  
  18. /*任务函数声明*/
  19. void StartDefaultTask(void *argument);
  20.  
  21.  
  22.  
  23. #endif

MyTask.cpp

  1. #include "MyTask.h"
  2. uint16_t temp = 0x0010;
  3. /*句柄定义*/
  4. osThreadId_t defaultTaskHandle;
  5.  
  6. /*任务函数*/
  7. void StartDefaultTask(void *argument)
  8. {
  9.     for (;;)
  10.     {
  11.         osDelay(1);
  12.     }
  13. }
  14.

②RCC

在目录下创建RCC，用于代替main.cpp里的时钟配置函数

RCC.h

  1. #ifndef RTOS_Cpp_RCC_H
  2. #define RTOS_Cpp_RCC_H
  3. #include "user_init.h"
  4.  
  5. void SystemClock_Config(void);
  6. #endif

RCC.cpp        我们的时钟配置可能不一样，前面的文件也是如此

  1. #include "RCC.h"
  2. void SystemClock_Config(void)
  3. {
  4.     RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  5.     RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  6.  
  7.     /** Configure the main internal regulator output voltage
  8.   */
  9.     __HAL_RCC_PWR_CLK_ENABLE();
  10.     __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
  11.  
  12.     /** Initializes the RCC Oscillators according to the specified parameters
  13.   * in the RCC_OscInitTypeDef structure.
  14.   */
  15.     RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  16.     RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  17.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  18.     RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  19.     RCC_OscInitStruct.PLL.PLLM = 6;
  20.     RCC_OscInitStruct.PLL.PLLN = 168;
  21.     RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  22.     RCC_OscInitStruct.PLL.PLLQ = 4;
  23.     if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  24.     {
  25.         Error_Handler();
  26.     }
  27.  
  28.     /** Initializes the CPU, AHB and APB buses clocks
  29.   */
  30.     RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
  31.     RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  32.     RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  33.     RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
  34.     RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
  35.  
  36.     if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)
  37.     {
  38.         Error_Handler();
  39.     }
  40. }

4，Application（应用层）

①main.cpp

main不再是函数编写的主体了，仅仅用于写中断回调。main.h可以删掉了

  1. #include "MyRTOS.h"
  2. Sys *sys;
  3.  
  4. int main(void)
  5. {
  6.     sys = new Sys;
  7.     sys->Peripheral_Init();//外设初始化
  8.     sys->OS_Init();
  9. }
  10.  
  11. /*中断回调函数*/
  12. extern "C" {
  13. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
  14. {
  15.     if (htim->Instance == TIM7)
  16.     {
  17.         HAL_IncTick();
  18.     }
  19. }
  20. }
  21.  
  22. #ifdef USE_FULL_ASSERT
  23. /**
  24.   * @brief  Reports the name of the source file and the source line number
  25.   *         where the assert_param error has occurred.
  26.   * @param  file: pointer to the source file name
  27.   * @param  line: assert_param error line source number
  28.   * @retval None
  29.   */
  30. void assert_failed(uint8_t *file, uint32_t line)
  31. {
  32.     /* USER CODE BEGIN 6 */
  33.     /* User can add his own implementation to report the file name and line number,
  34.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  35.     /* USER CODE END 6 */
  36. }
  37. #endif /* USE_FULL_ASSERT */

②MyRTOS

添加MyRTOS，用于取代FreeRTOS和原main.c

MyRTOS.h

  1. #ifndef RTOS_Cpp_MYRTOS_H
  2. #define RTOS_Cpp_MYRTOS_H
  3. #include "MyTask.h"
  4. #include "RCC.h"
  5. #include "gpio.h"
  6.  
  7.  
  8. /*系统类*/
  9. class Sys
  10. {
  11. public:
  12.     Sys();//默认初始化
  13.     ~Sys();
  14.     void Peripheral_Init();//外设初始化
  15.     void OS_Init();//RTOS初始化
  16.  
  17. public:
  18. };
  19.  
  20. #endif

MyRTOS.cpp

  1. #include "MyRTOS.h"
  2.  
  3. Sys::Sys()
  4. {
  5.     HAL_Init();
  6.     SystemClock_Config();
  7.     GPIO_Init();
  8. }
  9.  
  10. /*外设初始化函数*/
  11. void Sys::Peripheral_Init()
  12. {
  13.     /*
  14.     DAC_Init();
  15.     HAL_DAC_Start(&hdac, DAC_CHANNEL_1);
  16.     */
  17. }
  18. void Sys::OS_Init()
  19. {
  20.     /*用户任务初始化*/
  21.     defaultTaskHandle = osThreadNew(StartDefaultTask, NULL, &defaultTask_attributes);
  22.  
  23.  
  24.     /*操作系统初始化*/
  25.     osKernelInitialize();
  26.     osKernelStart();
  27. }
  28.  
  29. Sys::~Sys()
  30. {
  31. }

5，说明

        其一，开发重心改变。开发的主体部分不再是main.c或FreeRTOS.c了，而是MyTask和MyRTOS，前者侧重开发任务函数，后者侧重任务的初始化和任务调度以及外设配置

        其二，层次更加分明。本架构源于无际大佬

        其三，面向对象开发。下面是以前裸机开发时创建的System类，希望能提供些许思路。不过，如果请谨慎使用System类（把所有初始化封装在一个类里面），如果你的程序比较大，如使用了LVGL，那么运行时极有可能申请不到空间。

  1. #ifndef _SYSTEM_H
  2. #define _SYSTEM_H
  3. #include "stm32f4xx.h" //必须放在最上面，你也不想它突然报几百个错吧
  4. #include "stm32f4xx_hal_conf.h"
  5. #include "stm32f4xx_it.h"
  6. #include <iostream>
  7. /*DATA*/
  8. #include "logo.h"
  9. #include "FONT.h"
  10. #include "WAVEDAT.h"
  11. /*USER*/
  12. #include "AD-DA.h"
  13. #include "flash.h"
  14. #include "FSMC.h"
  15. #include "LCD.h"
  16. #include "spi.h"
  17. #include "spi_flash.h"
  18. #include "tools.h"
  19. #include "timer.h"
  20. #include "tools.h"
  21. #include "UI.h"
  22. #include "usart.h"
  23. #include "key.h"
  24. #include "FPGA.h"
  25. /*指针类*/
  26. #define KEY_RAM (*((volatile unsigned short *)0x6006000C)) // 键盘接口地址
  27. #define IO_CS (*((volatile unsigned short *)0x60020000))   // MCU-IO扩展模块中并行IO片选地址
  28.  
  29. /*函数类*/
  30. #define CK1_LOW() GPIO_ResetBits(GPIOC, GPIO_Pin_4) // 继电器1置低
  31. #define CK1_HIGH() GPIO_SetBits(GPIOC, GPIO_Pin_4)  // 继电器1置高
  32. #define CK2_LOW() GPIO_ResetBits(GPIOC, GPIO_Pin_5) // 继电器2置低
  33. #define CK2_HIGH() GPIO_SetBits(GPIOC, GPIO_Pin_5)  // 继电器2置高
  34.  
  35. class System
  36. {
  37.  
  38. public:
  39.     System(); // 系统初始化
  40.     ~System();
  41.  
  42.     /*初始化*/
  43.  
  44.     void KEY_EXTI_init(void); // 键盘外部中断配置
  45.     void function_init(void);
  46.     void SystemClock_Config(void);
  47.  
  48.     /*功能模块设计*/
  49.     void keybond(void); // 按键绑定
  50.  
  51.     /*键区*/
  52.     void k0open(); // 擦除
  53.     void k0close();
  54.     void k1open(); // 录音
  55.     void k1close();
  56.     void k2open(); // 放音
  57.     void k2close();
  58.     void k3open(); // 快进
  59.     void k3close();
  60.     void k4open(); // 慢放
  61.     void k4close();
  62.  
  63. public:
  64.     /*基本类成员*/
  65.  
  66.     Key *key;
  67.  
  68.     /*用户类成员*/
  69.  
  70. public:
  71.     /*句柄*/
  72.  
  73. public:
  74.     /*标志类*/
  75.     /*数值类*/
  76.     uint8_t min, csec; // 分钟、秒、百分秒
  77.     uint16_t sec;
  78.     uint8_t recordcsec;
  79.     uint16_t recordsec;
  80.  
  81.     /*计数类*/
  82.  
  83.     /*指针型*/
  84.     uint32_t recordaddr; // 录音地址
  85.     uint32_t playaddr;   // 放音地址
  86.                          // uint32_t startaddr;
  87.     uint16_t offset;
  88.  
  89.     /*debugger*/
  90. };
  91.  
  92. #endif
  1.  
  2. #include "system.h"
  3.  
  4. /*系统功能模块初始化*/
  5. void System::function_init(void) {
  6.   /*用户变量初始化*/
  7.   recordaddr = 0;
  8.   playaddr = 0;
  9.   sec = 0;
  10.   csec = 0; // 注：在这里不是百分秒，而是十分秒
  11.   recordcsec = 0;
  12.   recordsec = 0;
  13.   offset = 0; // 缓存偏移初始化
  14.   // startaddr = 0;
  15.   /*用户类的实例化*/
  16.  
  17.   /*用户功能初始化*/
  18.   MX_SPI3_Init();
  19.   HAL_SPI_MspInit(&hspi3);
  20.   MX_ADC1_Init();
  21.   MX_DAC_Init();
  22.   HAL_ADC_MspInit(&hadc1); // 方便可移植
  23.   HAL_DAC_MspInit(&hdac);
  24.  
  25.   MX_TIM2_Init();
  26.   MX_TIM6_Init(); // 10Hz
  27.   MX_TIM7_Init();
  28.  
  29.   HAL_TIM_Base_MspInit(&htim2);
  30.   HAL_TIM_Base_MspInit(&htim6);
  31.   HAL_TIM_Base_MspInit(&htim7);
  32.  
  33.   HAL_TIM_Base_Start(&htim2);
  34.   HAL_DAC_Start(&hdac, DAC1_CHANNEL_1);
  35.   SPI_FLASH_Init();
  36.   __HAL_TIM_CLEAR_IT(
  37.       &htim6,
  38.       TIM_IT_UPDATE); // 清除定时器初始化过程中的更新中断标志，避免定时器一启动就中断
  39.   __HAL_TIM_CLEAR_IT(
  40.       &htim7,
  41.       TIM_IT_UPDATE); // 清除定时器初始化过程中的更新中断标志，避免定时器一启动就中断
  42. }
  43.  
  44. // 按键绑定
  45. void System::keybond() {
  46.   key->sign = 0;               // 重置键效
  47.   key->reverseflag(key->code); // 键标取反
  48.  
  49.   switch (key->code) {
  50.   case 0x0: // 按键K0
  51.     if (key->operateotherkey(1, keyk1 | keyk2 | keyk3 | keyk4, 0)) {
  52.       k1close();
  53.       k2close();
  54.       HAL_TIM_Base_Stop_IT(&htim6); // 关闭计时器
  55.     }
  56.     /*再打开本键*/
  57.     k0open();
  58.     break;
  59.  
  60.   case 0x1: // 按键K1
  61.     if (key->flag & keyk1) {
  62.       /*先启闭其他键，如果需要的话*/
  63.       if (key->operateotherkey(1, keyk2 | keyk3 | keyk4, 0)) {
  64.         k2close();
  65.         k3close();
  66.         k4close();
  67.       }
  68.  
  69.       k1open();
  70.     } else {
  71.       k1close();
  72.     }
  73.     break;
  74.  
  75.   case 0x2: // 按键K2
  76.     if (key->flag & keyk2) {
  77.       if (key->operateotherkey(1, keyk1, 0)) {
  78.         k1close(); // 只需关闭录音
  79.         playaddr = 0;
  80.         sec = 0, csec = 0;
  81.       }
  82.       k2open();
  83.     } else {
  84.       k2close();
  85.     }
  86.     break;
  87.  
  88.   case 0x3:                     // 按键K3
  89.     if (!key->iskeyopen(keyk1)) // 如果录音开启，那么就不执行慢放
  90.     {
  91.       if (key->flag & keyk3) {
  92.  
  93.         if (key->operateotherkey(1, keyk4, 0)) {
  94.           LCD_ShowChineseStringBig(307, 180, 76, 2, YELLOW); // 关闭快进
  95.         }
  96.         k3open();
  97.  
  98.       } else {
  99.         k3close();
  100.       }
  101.     }
  102.     break;
  103.  
  104.   case 0x4:                     // 按键K4
  105.     if (!key->iskeyopen(keyk1)) // 如果录音开启，那么就不执行快进
  106.     {
  107.       if (key->flag & keyk4) {
  108.  
  109.         if (key->operateotherkey(1, keyk3, 0)) {
  110.           LCD_ShowChineseStringBig(307, 220, 78, 2, YELLOW); // 关闭慢放
  111.         }
  112.         k4open();
  113.  
  114.       } else {
  115.         k4close();
  116.       }
  117.     }
  118.     break;
  119.  
  120.   case 0x5: // 按键K5
  121.     break;
  122.   case 0x6: // 按键K6
  123.     break;
  124.   case 0x7: // 按键K7
  125.     break;
  126.   case 0x8: // 按键K8
  127.     break;
  128.   case 0x9: // 按键K9
  129.     break;
  130.   case 0xA: // 按键KA
  131.     break;
  132.   case 0xB: // 按键KB
  133.     break;
  134.   case 0xC: // 按键KC
  135.     break;
  136.   case 0xD: // 按键KD
  137.     break;
  138.   case 0xE: // 按键KE
  139.     break;
  140.   case 0xF: // 按键KF
  141.     break;
  142.   default: // 异常状态
  143.     break;
  144.   }
  145. }
  146.  
  147. /*系统初始化*/
  148. System::System() {
  149.   /*基本全局初始化*/
  150.   FSMC_init();          // 灵活静态存储初始化——必不可少
  151.   GPIO_Configuration(); // GPIO初始化
  152.   SystemClock_Config(); // 系统时钟初始化
  153.   LCD_Init9488();       // 液晶初始化
  154.   KEY_EXTI_init();      //  全局中断初始化
  155.  
  156.   /*基本初始化*/
  157.   TFTLED = 0x01; // 背光寄存器初始化
  158.   key = new Key;
  159.   /*用户基本初始化*/
  160.   UI_init();            // 显示Logo
  161.   tools.delay_ms(2500); // 延时一坤秒左右
  162.   LCD_Clear1(0x0000);   // 清屏
  163.   userUI();             // 显示用户界面
  164. }
  165.  
  166. System::~System() {
  167.   delete key;
  168.   key = nullptr;
  169. }
  170.  
  171. // 全局中断配置
  172. // 全局中断配置
  173. void System::KEY_EXTI_init(void) {
  174.   GPIO_InitTypeDef GPIO_InitStructure;
  175.   __HAL_RCC_GPIOB_CLK_ENABLE();
  176.  
  177.   GPIO_InitStructure.Mode = MODE_INPUT;
  178.   GPIO_InitStructure.Pull = GPIO_NOPULL;
  179.   GPIO_InitStructure.Mode = GPIO_MODE_IT_FALLING;
  180.   GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_LOW;
  181.   GPIO_InitStructure.Pin = GPIO_PIN_0;
  182.   HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
  183.   // 外部中断1初始化
  184.   GPIO_InitStructure.Pin = GPIO_PIN_1;
  185.   HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
  186.  
  187.   HAL_NVIC_SetPriority(EXTI0_IRQn, 0x01, 0x02);
  188.   HAL_NVIC_EnableIRQ(EXTI0_IRQn);
  189.  
  190.   HAL_NVIC_SetPriority(EXTI1_IRQn, 0x01, 0x02);
  191.   HAL_NVIC_EnableIRQ(EXTI1_IRQn);
  192. }
  193.  
  194. /*系统时钟配置*/
  195. void System::SystemClock_Config(void) {
  196.   /*系统时钟168MHz*/
  197.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  198.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  199.  
  200.   __HAL_RCC_PWR_CLK_ENABLE();
  201.   __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
  202.  
  203.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  204.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  205.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  206.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  207.   RCC_OscInitStruct.PLL.PLLM = 12;
  208.   RCC_OscInitStruct.PLL.PLLN = 336;
  209.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  210.   RCC_OscInitStruct.PLL.PLLQ = 4;
  211.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  212.     while (1)
  213.       ;
  214.  
  215.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK |
  216.                                 RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
  217.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  218.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  219.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
  220.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
  221.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)
  222.     while (1)
  223.       ;
  224. }
  225.  
  226. /************************************************************/
  227. /*                      按键功能设计                         */
  228. /************************************************************/
  229.  
  230. /*开启键0*/
  231. void System::k0open() {
  232.   uint16_t oldflag = key->flag; // 存储旧键值，为了防止在擦除死循环中乱按
  233.   sec = 0, csec = 0; // 计时器清零
  234.   recordaddr = 0;    // 录音地址
  235.   recordcsec = 0, recordsec = 0;
  236.   playaddr = 0;
  237.   tools.dispsec(0);
  238.   HAL_TIM_Base_Start_IT(&htim6);                        // 开启定时器
  239.   LCD_ShowChineseStringBig(161, 220, 70, 2, LIGHTBLUE); // 显示擦除画面
  240.   SPI_FLASH_ChipErase();
  241.   LCD_ShowChineseStringBig(161, 220, 70, 2, YELLOW); // 关闭擦除画面
  242.   HAL_TIM_Base_Stop_IT(&htim6);
  243.   key->flag = oldflag; // 把按键清零
  244.   key->sign = 0;       // 把置键有效也清零
  245. }
  246.  
  247. /*关闭键0*/
  248. void System::k0close() {
  249.   // 擦除不能取消，所以没有重复开关的功能
  250. }
  251.  
  252. void System::k1open() {
  253.   if (recordaddr == 0) /*判断有没有擦除的必要*/
  254.   {
  255.     uint8_t i = 0;
  256.     uint8_t arr[16];
  257.  
  258.     SPI_FLASH_BufferRead(arr, 0, 16);
  259.     for (; i < 16; i++) /*只要有数据就清空*/
  260.       if (arr[i] != Dummy_Byte) {
  261.         k0open();
  262.         break;
  263.       }
  264.   }
  265.   LCD_ShowChineseStringBig(161, 180, 72, 2, LIGHTBLUE); // 显示录音
  266.   sec = recordsec, csec = recordcsec;
  267.   tools.dispsec(sec);
  268.   HAL_TIM_Base_Start_IT(&htim6);
  269.   HAL_ADC_Start_IT(&hadc1); // 开启ADC
  270. }
  271.  
  272. void System::k1close() {
  273.  
  274.   HAL_ADC_Stop_IT(&hadc1);      // 关闭ADC
  275.   HAL_TIM_Base_Stop_IT(&htim6); // 关闭计时器
  276.   recordcsec = csec;
  277.   recordsec = sec;
  278.   csec = 0; // 为了把放音清除
  279.   sec = 0;
  280.   playaddr = 0;
  281.   LCD_ShowChineseStringBig(161, 180, 72, 2, YELLOW); // 显示录音
  282. }
  283.  
  284. void System::k2open() {
  285.   if (recordaddr == playaddr)
  286.     playaddr = 0, sec = 0, csec = 0; // 置零
  287.   tools.dispsec(sec);
  288.   LCD_ShowChineseStringBig(161, 140, 74, 2, LIGHTBLUE); // 蓝为开启
  289.   HAL_TIM_Base_Start_IT(&htim6);                        // 打开计时器
  290.   HAL_TIM_Base_Start_IT(&htim7); // 打开放音用的中断
  291. }
  292.  
  293. void System::k2close() {
  294.   HAL_TIM_Base_Stop_IT(&htim6); // 关闭计时器
  295.   HAL_TIM_Base_Stop_IT(&htim7);
  296.   LCD_ShowChineseStringBig(161, 140, 74, 2, YELLOW); // 黄为关闭
  297. }
  298.  
  299. void System::k3open() {
  300.   __HAL_TIM_SetAutoreload(&htim6, 12599); // 慢放2/3
  301.   __HAL_TIM_SetAutoreload(&htim7, 125);
  302.   LCD_ShowChineseStringBig(307, 220, 78, 2, LIGHTBLUE); // 慢放
  303. }
  304.  
  305. void System::k3close() {
  306.   __HAL_TIM_SetAutoreload(&htim6, 8399); // 恢复
  307.   __HAL_TIM_SetAutoreload(&htim7, 83);
  308.   LCD_ShowChineseStringBig(307, 220, 78, 2, YELLOW); // 慢放
  309. }
  310.  
  311. void System::k4open() {
  312.   __HAL_TIM_SetAutoreload(&htim6,
  313.                           4799); // 快进 1.75,两倍速会卡住，因为HAL库太占资源
  314.   __HAL_TIM_SetAutoreload(&htim7, 47);
  315.   LCD_ShowChineseStringBig(307, 180, 76, 2, LIGHTBLUE); // 快进
  316. }
  317.  
  318. void System::k4close() {
  319.   __HAL_TIM_SetAutoreload(&htim6, 8399); // 恢复
  320.   __HAL_TIM_SetAutoreload(&htim7, 83);
  321.   LCD_ShowChineseStringBig(307, 180, 76, 2, YELLOW); // 快进
  322. }

四、验证

1，创建OpenCD

可以参考CLion + STM32CubeMX【嵌入式开发 _环境搭建_C++】，目录【四-3】

2，构建

        接下来不会有什么太大问题，需要注意的是C++调用C和C调用C++

3，分析

        官方其实集成了RTOS分析工具

五、BUG

1，使用信号量传递，但永远阻塞

可能是被编译器优化掉了。试了一下，跟是否有临界区无关

  1. void StartDefaultTask(void *argument)
  2. {
  3. /****创建信号量的过程不要放在这！！！应该放在MX_FREERTOS_Init()里****/
  4.     //myBinarySem01Handle = xSemaphoreCreateBinary();
  5.     for (;;)
  6.     {
  7.         xSemaphoreGive(myBinarySem01Handle);
  8.         osDelay(500);
  9.     }
  10. }

2，使用 xSemaphoreTake报错

这是因为C++有更为严格的类型检查，使用static_cast就可以解决问题

  1. void FreqTask(void *argument)
  2. {
  3.     for (;;)
  4.     {
  5.         xSemaphoreTake(static_cast<QueueHandle_t>(myBinarySem01Handle), portMAX_DELAY);
  6.         osDelay(100);
  7.     }
  8. }

3，无法使用信号量，卡在configASSERT( pxQueue );

        ①lvgl

        本来一直找不到原因，直至重新建一个工程后才发现，不使用lvgl可以正常使用信号量，但是一使用就会卡住，所以推断是lvgl出现了问题。后来受这篇博客启发STM32 FreeRTOS处理LVGL+串口双任务相关问题总结，最初推断是堆栈不够了。

  1.     /*LVGL初始化*/
  2.     lv_init();
  3.     lv_port_disp_init();

        在后续实测中发现，堆栈分配都是足够的，可仍会卡死。但只要把lv_port_disp_init();注释掉信号量就不会卡死。

        由此对  lv_port_disp_init();进行了深入测试，最终发现，无论是LCD_Init();还是lv_disp_drv_register(&disp_drv)，只要调用其中一个就会出现信号量卡死的情况

        这种结果是相当匪夷所思的，因为理论上LCD初始化驱动怎么也不可能影响到FreeRTOS。能出现这种莫名其妙的错误，必然有着莫名其妙的原因。

        于是我开始猜想会不会是LCD初始化需要进入临界区，尽管这种想法挺莫名其妙的，因为我的 lv_port_disp_init();是在FreeRTOS初始化之前调用的

  1. int main()
  2. {
  3.     HAL_Init();
  4.     SystemClock_Config();
  5.  
  6.     Base_GPIO_Init();
  7.     PeripheralInit();
  8.  
  9.     /*LVGL初始化*/
  10.     lv_init();
  11.     lv_port_disp_init();
  12.  
  13.     /*FreeRTOS初始化*/
  14.     osKernelInitialize();
  15.     My_FreeRTOS_Init();
  16.     osKernelStart();
  17. }

        结果居然可以正常工作了！？

连lv_disp_drv_register(&disp_drv)都不需要注释掉了

  1. #include "cmsis_os.h"
  2.  
  3. void lv_port_disp_init(void)
  4. {
  5.     taskENTER_CRITICAL();
  6.      LCD_Init();
  7.     taskEXIT_CRITICAL();
  8.  
  9.     /* Example for 1) */
  10.     static lv_disp_draw_buf_t draw_buf_dsc_1;
  11.     static lv_color_t buf_1[MY_DISP_HOR_RES * BufferRows]; /*A buffer for 10 rows*/
  12.     lv_disp_draw_buf_init(&draw_buf_dsc_1, buf_1, NULL, MY_DISP_HOR_RES * BufferRows);
  13.  
  14.  
  15.     static lv_disp_drv_t disp_drv; /*Descriptor of a display driver*/
  16.     lv_disp_drv_init(&disp_drv);   /*Basic initialization*/
  17.  
  18.     disp_drv.hor_res = MY_DISP_HOR_RES;
  19.     disp_drv.ver_res = MY_DISP_VER_RES;
  20.  
  21.     disp_drv.flush_cb = disp_flush;
  22.  
  23.     disp_drv.draw_buf = &draw_buf_dsc_1;
  24.  
  25.     lv_disp_drv_register(&disp_drv);
  26. }

        当然不能像上面那样直接在lv_port_disp_init里加临界区代码，那样不利于后续移植，最好在你调用这个函数的地方加上临界保护区

  1.     /*LVGL初始化*/
  2.     lv_init();
  3.     taskENTER_CRITICAL();
  4.     lv_port_disp_init();
  5.     taskEXIT_CRITICAL();

②任务栈

为lv_task_handler分配的栈不要太节省，否则也会出现卡死的现象。经测试，最少得分配栈大小为277，当然由于未考虑过多的因素，所以这个数值仅供参考。建议还是分配512

  1. osThreadId_t GUITaskHandle;
  2. const osThreadAttr_t GUITask_attributes = {
  3.         .name = "GUITask",
  4.         .stack_size = 512 * 4,
  5.         .priority = (osPriority_t) osPriorityNormal,
  6. };
  1. void GUITask(void *argument)
  2. {
  3.     while (1)
  4.     {
  5.         lv_task_handler();
  6.         osDelay(5);
  7.     }
  8. }

        后来加载了界面再测试，结果直接进入了硬件中断。去掉lv_scr_load(ui->EPMscreen);就不会进入硬件中断。其根本原因还是刚才分配给lv_task_handler的任务栈太小，改成512就不会出现问题。

        下一次如果出现类似问题，可以考虑将lv_task_handler的任务栈调大一点

  1. void setup_ui(lv_ui *ui)
  2. {
  3. 	init_scr_del_flag(ui);
  4. 	setup_scr_EPMscreen(ui);
  5. 	lv_scr_load(ui->EPMscreen);
  6. }

③信号量创建

        属实没想到创建位置也能引发这个报错，下面这个是错误例子（我还没有排除两种体系的API造成的影响）

  1.     /*基本任务、信号量创建*/
  2.     keyBinarySemHandle = xSemaphoreCreateBinary();//放在任务里的前面会出现问题
  3.  
  4.     GUITaskHandle = osThreadNew(GUITask, nullptr, &GUITask_attributes);
  5.     KeyTaskHandle = osThreadNew(KeyTask, nullptr, &KeyTask_attributes);
  6.  
  7.     /*信号量创建*/
  8.     FPGABinarySemHandle = xSemaphoreCreateBinary();
  9.     /*任务创建*/
  10.     FreqTaskHandle = osThreadNew(FreqTask, nullptr, &FreqTask_attributes);

正确创建应该为下面这样

  1.     /*信号量创建*/
  2.     keyBinarySemHandle = xSemaphoreCreateBinary();//放在任务里的前面会出现问题
  3.     FPGABinarySemHandle = xSemaphoreCreateBinary();
  4.  
  5.  
  6.     /*任务创建*/
  7.     FreqTaskHandle = osThreadNew(FreqTask, nullptr, &FreqTask_attributes);
  8.     GUITaskHandle = osThreadNew(GUITask, nullptr, &GUITask_attributes);
  9.     KeyTaskHandle = osThreadNew(KeyTask, nullptr, &KeyTask_attributes);

提示：建议使用CMSIS-RTOS或CMSIS-RTOS2的API，而非FreeRTOS自带的API，因为前者是统一的标准，即便后续你换了RTOS，也仍可继续使用。

4，进不去任何任务包括中断

如果你一直卡在

prvCheckTasksWaitingTermination、portTASK_FUNCTION之类的函数

        可能是你把某个任务的栈大小分配得太小了，调大一点就可以了

5，SPI_Flash卡死在等待

在等待函数里加个临界区保护代码就可以了

  1. inline void SPI_FLASH_WaitForWriteEnd()        // 等待写完成
  2. {
  3.     uint8_t FLASH_Status;
  4.     SPI_FLASH_CS_LOW();
  5.     SPI_FLASH_SendByte(ReadStatusReg); /* 发送 读状态寄存器 命令 */
  6.     do
  7.     {
  8.         taskENTER_CRITICAL();
  9.         FLASH_Status = SPI_FLASH_SendByte(Dummy_Byte);
  10.         taskEXIT_CRITICAL();
  11.     } while (FLASH_Status & WIP_Flag);// 检测BUSY位是否为0,0表示已完成不忙
  12.     SPI_FLASH_CS_HIGH();
  13. }

6，初始化卡住

        这是相当神奇的一幕，那就是理论上还没有执行到osKernelInitialize();，可却已经以时间片轮询的方式进行了。所以会发生一些十分诡异的情况，比如在前面的一些基础GPIO的初始化，可能会与后面的App_Init中如IIC的GPIO初始化产生冲突，有时候HAL_Delay也会卡住。

        为了避免这种情况发生，可以在需要提前做的部分加上临界区加以保护

  1. #include "Application_Logic.h"
  2. #include "FreeRTOS.h"
  3. #include "baseInit.h"
  4. #include "cmsis_os2.h"
  5. #include "task.h"
  6. int main() {
  7.     taskENTER_CRITICAL();//临界区
  8.     HAL_Init();
  9.     SystemClock_Config();
  10.     Base_Founction_Init();
  11.     taskEXIT_CRITICAL();//临界区
  12.  
  13.     /*FreeRTOS初始化*/
  14.     osKernelInitialize();
  15.     App_Init();
  16.     osKernelStart();
  17.     while (1)
  18.         ;
  19. }

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

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

  

闽ICP备14008679号