21ic电子技术开发论坛 › 单片机与嵌入式系统 › AutoChips MCU › AC78013FDLA Free RTOS的消息队列实验
返回列表 发新帖我要提问

[学习笔记] AC78013FDLA Free RTOS的消息队列实验

[复制链接]
1586|8
 楼主| kzlzqi 发表于 2023-5-26 11:43 | 显示全部楼层 |阅读模式
AC, RTOS, os
消息队列：异步通信机制

1.当队列中的消息是空时，读取消息的任务将被阻塞
2.可以指定阻塞的任务时间 xTicksToWait（这段时间中，如果队列为空，该任务将保持阻塞状态以等待队列数据有效）
3.等待期间如果队列有消息，会唤醒被阻塞的任务并处理消息
4.等待超时，即使队列没有数据也会让任务进入就绪状态


5.消息先进先出
6.允许不同长度（限定范围之内）
7.一个消息队列可以服务于一个或多个任务
6.队列使用结束后通过删除队列函数删除


消息队列基本要素
头指针 pcHead、尾指针 pcTail、消息大小 uxItemSize 以及队列长度 uxLength  
消息队列与消息空间占用一段连续内存
一经创建不可改变

发送消息（任何任务或者中断函数都可以） 队列未满或者允许覆盖入队（消息安全性如何保证？），也可以是消息阻塞状态（那么发送消息的任务进入阻塞状态？是的）如果等待超时任务会进入就绪状态并会报错（errQUEUE_FULL)
普通消息加入队尾（先进先出），紧急消息加入队头。
发送到消息队列的数据是拷贝数据，不是引用数据

如果消息的长度过长可以将消息的地址作为消息发送（要保证数据不被多次擦写）


消息读取：
某任务试图读取消息时可以指定超时时间等待消息


保护机制：


阻塞机制：

读取阻塞：
任务A对队列L进行读操作的时候如果队列中没有消息：
1.任务直接放弃读取
2.任务A等待（进入阻塞状态）等待时间由软件定义
3.任务A一直等待，A进入阻塞状态直到消息队列有数据才会恢复为就绪状态

写入阻塞
任务B被允许对队列L写入时
1.如果队列已满，任务B可以等待阻塞超时时间，指定时间内如果不能完成写入操作返回错误吗errQUEUEFULL，然后进入就绪状态
2.中断中发送队列消息不允许有阻塞机制
3.如果有多个消息阻塞在队列操作中，这些任务将按照优先级进行排序



回复

收藏 举报

评论

kzlzqi
———————————————— 版权声明：本文为CSDN博主「大唐不夜城」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/DiQiZiYouDu/article/details/117224782  发表于 2023-5-26 11:44

相关帖子
 楼主| kzlzqi 发表于 2023-5-26 11:44 | 显示全部楼层
安全设计思想：
一个队列尽可能只对应一个任务可以写入和读取，生产者和消费者保证唯一性。
一个队列由多任务或中断写入是经常的事，但由多个任务读出倒是用的比较少。



实验：设计两个任务，一个按键检测任务Key，一个LED点亮任务Led
检测到Key（扫描方式）发送消息给到Led任务点亮Led
检测到Key（中断方式）发送消息给到Led任务点亮Led



下面贴部分代码，欢迎交流参考
复制
  1. * AutoChips Inc. (C) 2021. All rights reserved.
    

  2.   *
    

  3.   * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
    

  4.   * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("AUTOCHIPS SOFTWARE")
    

  5.   * RECEIVED FROM AUTOCHIPS AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
    

  6.   * ON AN "AS-IS" BASIS ONLY. AUTOCHIPS EXPRESSLY DISCLAIMS ANY AND ALL
    

  7.   * WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
    

  8.   * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
    

  9.   * NONINFRINGEMENT. NEITHER DOES AUTOCHIPS PROVIDE ANY WARRANTY WHATSOEVER WITH
    

  10.   * RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
    

  11.   * INCORPORATED IN, OR SUPPLIED WITH THE AUTOCHIPS SOFTWARE, AND RECEIVER AGREES
    

  12.   * TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
    

  13.   * RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
    

  14.   * OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN AUTOCHIPS
    

  15.   * SOFTWARE. AUTOCHIPS SHALL ALSO NOT BE RESPONSIBLE FOR ANY AUTOCHIPS SOFTWARE
    

  16.   * RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
    

  17.   * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND AUTOCHIPS'S
    

  18.   * ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE AUTOCHIPS SOFTWARE
    

  19.   * RELEASED HEREUNDER WILL BE, AT AUTOCHIPS'S OPTION, TO REVISE OR REPLACE THE
    

  20.   * AUTOCHIPS SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
    

  21.   * CHARGE PAID BY RECEIVER TO AUTOCHIPS FOR SUCH AUTOCHIPS SOFTWARE AT ISSUE.
    

  22.   *
    

  23.   ******************************************************************************  
    

  24.   */
    


  25. 

  26. /* --------------------------------- Includes -------------------------------*/
    

  27. #include "main.h"
    

  28. #include "ac780x_irq_cb.h"
    

  29. #include "ac780x_uart.h"
    

  30. #include "ac780x_uart_reg.h"
    

  31. #include "ac780x_gpio.h"
    

  32. /* USER CODE BEGIN Includes */
    

  33. #include  <stdarg.h>
    

  34. #include  <stdio.h>
    

  35. #include  <stdlib.h>
    

  36. #include  <math.h>
    


  37. 


  38. 

  39. #include "FreeRTOS.h"
    

  40. #include "task.h"
    

  41. #include "queue.h"
    

  42. #include "croutine.h"
    

  43. /* USER CODE END Includes */
    


  44. 

  45. /* --------------------------------- Typedefs -------------------------------*/
    

  46. /* USER CODE BEGIN Typedefs */
    

  47. static TaskHandle_t xHandleTaskLed = NULL;
    

  48. static TaskHandle_t xTaskTaskKey = NULL;
    

  49. QueueHandle_t      Test_GpioQueue =NULL;  //消息队列句柄
    


  50. 

  51. /* USER CODE END Typedefs */
    


  52. 

  53. /* --------------------------------- Defines --------------------------------*/
    

  54. /* USER CODE BEGIN Defines */
    


  55. 

  56. /* USER CODE END Defines */
    


  57. 

  58. /* --------------------------------- Macros ---------------------------------*/
    

  59. /* USER CODE BEGIN Macros */
    


  60. 

  61. /* USER CODE END Macros */
    


  62. 

  63. /* --------------------------------- Variables ------------------------------*/
    


  64. 

  65. /* USER CODE BEGIN Variables */
    


  66. 

  67. /* USER CODE END Variables */
    


  68. 

  69. /* --------------------------------- Function Prototypes --------------------*/
    

  70. void SystemClock_Config(void);
    

  71. static void ATC_GPIO_Init(void);
    

  72. static void ATC_UART2_Init(void);
    

  73. static void ATC_UART1_Init(void);
    

  74. void MSP_Init(void);
    

  75. void MSP_UART_Init(UART_Type* UARTx);
    


  76. 

  77. /* USER CODE BEGIN Function_Prototypes */
    

  78. static void vTaskTaskLed(void* parameter)
    

  79. {
    


  80. 

  81. BaseType_t xReturn = pdPASS;
    

  82. uint8_t    xRekeydata[2]={0x0};
    


  83. 

  84. while (1)
    

  85. {
    

  86.         printf("Scan msg \r\n");
    

  87.        
    

  88.         xReturn = xQueueReceive(Test_GpioQueue, xRekeydata, 500);
    

  89.        
    

  90.         if(xReturn == errQUEUE_EMPTY)
    

  91.                 {
    

  92.                         printf("empty\r\n");
    

  93.                 }
    

  94.                
    

  95.         if(xReturn == pdTRUE)
    

  96.         {
    

  97.                 printf("Get  %d,%d\r\n",xRekeydata[0],xRekeydata[1]);
    

  98.                
    

  99.                 if(xRekeydata[0] == 0x01)
    

  100.                         GPIO_SetPinLevel(LED2_GPIO_Port,LED2_Pin,GPIO_LEVEL_LOW);
    

  101.                 else
    

  102.                         GPIO_SetPinLevel(LED2_GPIO_Port,LED2_Pin,GPIO_LEVEL_HIGH);
    

  103.         }
    

  104.         else
    

  105.         {
    

  106.                
    

  107.         }
    


  108. 


  109. 

  110.          /*
    

  111.         printf("Task Led 0\r\n");
    

  112.        GPIO_SetPinLevel(LED1_GPIO_Port,LED1_Pin,GPIO_LEVEL_LOW);
    

  113.                 vTaskDelay(500);
    

  114.         printf("Task Led 1\r\n");
    

  115.         GPIO_SetPinLevel(LED1_GPIO_Port,LED1_Pin,GPIO_LEVEL_HIGH);
    

  116.                 vTaskDelay(500);
    

  117.      */
    

  118. }
    

  119. }
    

  120. static void vTaskTaskKey(void* parameter)
    

  121. {
    


  122. 

  123. BaseType_t xReturn = pdPASS;
    

  124. uint8_t    xkeydata[2]={0x0};
    

  125. while (1)  
    

  126. {
    

  127.         //L  enable
    

  128. /*        printf("Task Key\r\n");
    

  129.         if(GPIO_GetPinLevel(KEY2_GPIO_Port, KEY2_Pin) == 0)
    

  130.                 {
    

  131.         //        GPIO_SetPinLevel(LED2_GPIO_Port,LED2_Pin,GPIO_LEVEL_LOW);
    

  132.                 xkeydata[0] = 0x00;
    

  133.                 xkeydata[1] = 0x00;
    

  134.                 xReturn =  xQueueSend( Test_GpioQueue, xkeydata,0);
    

  135.                 }
    

  136.         else
    

  137.                 {
    

  138.         //        GPIO_SetPinLevel(LED2_GPIO_Port,LED2_Pin,GPIO_LEVEL_HIGH);
    

  139.                 xkeydata[0] = 0x01;
    

  140.                 xkeydata[1] = 0x01;
    

  141.                 xReturn =  xQueueSend( Test_GpioQueue, xkeydata,0);
    

  142.                 }
    

  143.         vTaskDelay(5000);
    

  144. */
    

  145. }
    

  146. }
    

  147. /* USER CODE END Function_Prototypes */
    


  148. 

  149. /* USER CODE BEGIN 0 */
    


  150. 

  151. static void AppTaskCreate (void)
    

  152. {
    


  153. 

  154. Test_GpioQueue = xQueueCreate(16, 2);
    


  155. 

  156. if(NULL != Test_GpioQueue)
    

  157. {
    

  158. printf("消息队列创建成功\r\n");
    

  159. }
    

  160. else
    

  161. {
    

  162. printf("消息队列创建失败\r\n");
    

  163. }
    


  164. 


  165. 


  166. 


  167. 

  168.     xTaskCreate( vTaskTaskLed,            
    

  169.                  "vTaskLed",              
    

  170.                  512,                        
    

  171.                  NULL,                       
    

  172.                  1,                          
    

  173.                  &xHandleTaskLed );   
    


  174. 

  175.         xTaskCreate( vTaskTaskKey,            
    

  176.                  "vTaskUserTRE",              
    

  177.                  512,                        
    

  178.                  NULL,                       
    

  179.                  1,                          
    

  180.                  &xTaskTaskKey );   
    

  181.        
    

  182. }
    


  183. 


  184. 


  185. 

  186. /*******************************************************************************
    

  187. * Function Name  :void ACC_IRQHandler(void *device, uint32_t wpara, uint32_t lpara)
    

  188. * Description    :ACC  引脚中断处理程序
    

  189. * Output         : None
    

  190. * Return         : None
    

  191. *******************************************************************************/
    

  192. void SocGpioACC_IRQHandler(void *device, uint32_t wpara, uint32_t lpara)
    

  193. {
    

  194. uint8_t    xkeydata[2]={0x0};
    

  195. //if(GPIO_GetPendingExtInterrupt() & KEY2_Pin)
    

  196. {
    

  197.           GPIO_ClearPendingExtInterrupt(KEY2_Pin);
    

  198. xkeydata[0] =GPIO_GetPinLevel(KEY2_GPIO_Port, KEY2_Pin);
    

  199. xQueueSend( Test_GpioQueue, xkeydata,0);
    


  200. 


  201. 

  202. }
    

  203. }
    


  204. 


  205. 

  206. /*******************************************************************************
    

  207. * Function Name  :void  SocGpioEXITAccDet(void)
    

  208. * Description    :使能 ACC   中断
    

  209. * Output         : None
    

  210. * Return         : None
    

  211. *******************************************************************************/
    

  212. void  SocGpioEXITKeyDet(void)
    

  213. {
    


  214. 


  215. 

  216.         GPIO_SetPullup(KEY2_GPIO_Port,KEY2_Pin, ENABLE);
    


  217. 

  218.        
    

  219. GPIO_EnableExtInterrupt(KEY2_GPIO_Port, KEY2_Pin, EXTI_TRIGGER_RISING_FALLING);
    

  220.        
    

  221. GPIO_SetCallback(KEY2_Pin, SocGpioACC_IRQHandler);
    


  222. 


  223. 

  224. }
    


  225. 


  226. 


  227. 


  228. 


  229. 


  230. 


  231. 


  232. 


  233. 


  234. 


  235. 


  236. 


  237. 


  238. 


  239. 


  240. 

  241. /* USER CODE END 0 */
    


  242. 

  243. /**
    

  244.   * [url=home.php?mod=space&uid=247401]@brief[/url]  The application entry point.
    

  245.   *
    

  246.   * @retval int
    

  247.   */
    

  248. int main(void)
    

  249. {
    

  250.     /* USER CODE BEGIN 1 */
    


  251. 

  252.     /* USER CODE END 1 */
    


  253. 

  254.     /* MCU Configuration------------------------------------------------------*/
    


  255. 

  256.     /* USER CODE BEGIN Init */
    


  257. 

  258.     /* USER CODE END Init */
    


  259. 

  260.     /* Configure the system clock */
    

  261.     SystemClock_Config();
    


  262. 

  263.     /* USER CODE BEGIN SysInit */
    


  264. 

  265.     /* USER CODE END SysInit */
    


  266. 

  267.     /* Initialize all configured peripherals */
    

  268.     ATC_GPIO_Init();
    

  269.     ATC_UART2_Init();
    

  270.     ATC_UART1_Init();
    


  271. 

  272.     /* USER CODE BEGIN 2 */
    


  273. 

  274.         SocGpioEXITKeyDet();
    

  275.         InitDebug();
    

  276.         AppTaskCreate();
    

  277.         vTaskStartScheduler();
    

  278.        
    

  279.        
    

  280.        
    

  281.     /* USER CODE END 2 */
    


  282. 

  283.     /* Infinite loop */
    

  284.     while(1)
    

  285.     {
    


  286. 

  287.         /* USER CODE BEGIN WHILE */
    


  288. 

  289.         /* USER CODE END WHILE */
    


  290. 

  291.     }
    


  292. 

  293.     /* USER CODE BEGIN 3 */
    


  294. 

  295.     /* USER CODE END 3 */
    

  296. }
    


  297. 

  298. /**
    

  299.     * @brief System Clock Configuration
    

  300.     * @retval None
    

  301.     */
    

  302. void SystemClock_Config(void)
    

  303. {
    

  304.     SPM_EnableXOSC(ENABLE);
    

  305.     SPM_EnablePLL(ENABLE);
    

  306.     CKGEN_SetPLLReference(PLL_REF_INTERAL_OSC);
    

  307.     CKGEN_SetPllPrevDiv(PLL_PREDIV_1);
    

  308.     CKGEN_SetPllFeedbackDiv(96);
    

  309.     CKGEN_SetPllPostDiv(PLL_POSDIV_16);
    

  310.     CKGEN_SetSysclkDiv(SYSCLK_DIVIDER_1);
    

  311.     CKGEN_SetSysclkSrc(SYSCLK_SRC_PLL_OUTPUT);
    

  312.     CKGEN_SetAPBClockDivider(APBCLK_DIVIDER_2);
    

  313. }
    


  314. 

  315. /* UART1 init function */
    

  316. static void ATC_UART1_Init(void)
    

  317. {
    

  318.     /* USER CODE BEGIN UART1_Init 0 */
    


  319. 

  320.     /* USER CODE END UART1_Init 0 */
    


  321. 

  322.     UART_ConfigType uartConfig;
    

  323.     memset(&uartConfig, 0, sizeof(uartConfig));
    


  324. 

  325.     /* USER CODE BEGIN UART1_Init 1 */
    


  326. 

  327.     /* USER CODE END UART1_Init 1 */
    


  328. 

  329.     MSP_UART_Init(UART1);
    


  330. 

  331.     uartConfig.baudrate = 115200;
    

  332.     uartConfig.dataBits = UART_WORD_LEN_8BIT;
    

  333.     uartConfig.stopBits = UART_STOP_1BIT;
    

  334.     uartConfig.parity = UART_PARI_NO;
    

  335.     uartConfig.fifoByteEn = DISABLE;
    

  336.     uartConfig.dmaEn = UART_DMA_TXRX_NONE;
    

  337.     uartConfig.sampleCnt = UART_SMP_CNT0;
    


  338. 

  339.     UART_Init(UART1, &uartConfig);
    


  340. 

  341.     /* USER CODE BEGIN UART1_Init 2 */
    


  342. 

  343.     /* USER CODE END UART1_Init 2 */
    

  344. }
    


  345. 

  346. /* UART2 init function */
    

  347. static void ATC_UART2_Init(void)
    

  348. {
    

  349.     /* USER CODE BEGIN UART2_Init 0 */
    


  350. 

  351.     /* USER CODE END UART2_Init 0 */
    


  352. 

  353.     UART_ConfigType uartConfig;
    

  354.     memset(&uartConfig, 0, sizeof(uartConfig));
    


  355. 

  356.     /* USER CODE BEGIN UART2_Init 1 */
    


  357. 

  358.     /* USER CODE END UART2_Init 1 */
    


  359. 

  360.     MSP_UART_Init(UART2);
    


  361. 

  362.     uartConfig.baudrate = 115200;
    

  363.     uartConfig.dataBits = UART_WORD_LEN_8BIT;
    

  364.     uartConfig.stopBits = UART_STOP_1BIT;
    

  365.     uartConfig.parity = UART_PARI_NO;
    

  366.     uartConfig.fifoByteEn = DISABLE;
    

  367.     uartConfig.dmaEn = UART_DMA_TXRX_NONE;
    

  368.     uartConfig.sampleCnt = UART_SMP_CNT0;
    


  369. 

  370.     UART_Init(UART2, &uartConfig);
    


  371. 

  372.     /* USER CODE BEGIN UART2_Init 2 */
    


  373. 

  374.     /* USER CODE END UART2_Init 2 */
    

  375. }
    


  376. 

  377. /** Configure pins as
    

  378.               * Analog
    

  379.               * Input
    

  380.               * Output
    

  381.               * EVENT_OUT
    

  382.               * EXTI
    

  383. */
    

  384. static void ATC_GPIO_Init(void)
    

  385. {
    

  386.     GPIO_SetFunc(KEY2_GPIO_Port, KEY2_Pin, GPIO_FUN0);
    

  387.     GPIO_SetFunc(KEY1_GPIO_Port, KEY1_Pin, GPIO_FUN0);
    

  388.     GPIO_SetFunc(LED2_GPIO_Port, LED2_Pin, GPIO_FUN0);
    

  389.     GPIO_SetFunc(LED1_GPIO_Port, LED1_Pin, GPIO_FUN0);
    

  390.     GPIO_SetDir(KEY2_GPIO_Port, KEY2_Pin, GPIO_IN);
    

  391.     GPIO_SetDir(KEY1_GPIO_Port, KEY1_Pin, GPIO_IN);
    

  392.     GPIO_SetDir(LED2_GPIO_Port, LED2_Pin, GPIO_OUT);
    

  393.     GPIO_SetDir(LED1_GPIO_Port, LED1_Pin, GPIO_OUT);
    

  394.     GPIO_SetPinLevel(LED2_GPIO_Port, LED2_Pin, GPIO_LEVEL_LOW);
    

  395.     GPIO_SetPinLevel(LED1_GPIO_Port, LED1_Pin, GPIO_LEVEL_LOW);
    

  396.     GPIO_SetDrivingAbility(LED2_GPIO_Port, LED2_Pin, GPIO_DRIVING_4MA);
    

  397.     GPIO_SetDrivingAbility(LED1_GPIO_Port, LED1_Pin, GPIO_DRIVING_4MA);
    

  398. }
    


  399. 

  400. /* USER CODE BEGIN 4 */
    


  401. 

  402. /* USER CODE END 4 */
    


  403. 

  404. /**
    

  405.   * @brief  This function is executed in case of error occurrence.
    

  406.   * @param  file: The file name as string.
    

  407.   * @param  line: The line in file as a number.
    

  408.   * @retval None
    

  409.   */
    

  410. void Error_Handler(char *file, int line)
    

  411. {
    

  412.     /* USER CODE BEGIN Error_Handler_Debug */
    

  413.     /* User can add his own implementation to handle the driver error */
    

  414.     while(1)
    

  415.     {
    

  416.     }
    

  417.     /* USER CODE END Error_Handler_Debug */
    

  418. }
    


  419. 

  420. /************************ (C) COPYRIGHT AutoChips *****END OF FILE****/
回复

收藏 举报

tpgf 发表于 2023-6-8 17:15 | 显示全部楼层
如何学习一个 RTOS？最简单的就是在别人移植好的系统之上，看看 RTOS 里面的 API 使用说明，然后调用这些 API 实现自己想要的功能即可
回复

收藏 举报

木木guainv 发表于 2023-6-9 08:41 | 显示全部楼层
FreeRTOS 于 2018 年被亚马逊收购，改名为 AWS FreeRTOS，版本号升级为 V10，且 开源协议也由原来的 GPLv2+修改为 MIT，与 GPLv2+相比，MIT 更加开放，你完全可以理 解为是为所欲为的免费
回复

收藏 举报

磨砂 发表于 2023-6-9 09:24 | 显示全部楼层
FreeRTOS 是一款 “开源免费”的实时操作系统，遵循的是 GPLv2+的许可协议。
回复

收藏 举报

晓伍 发表于 2023-6-9 09:50 | 显示全部楼层
FreeRTOS 和 OpenRTOS 拥有的代码是一样的，但是可从官方获取到的服务却是不一 样的。FreeRTOS 号称免费，OpenRTOS 号称收费
回复

收藏 举报

八层楼 发表于 2023-6-9 10:33 | 显示全部楼层
当你的产品使用了 FreeRTOS 且没有修改 FreeRTOS 内核源码的时候，你的产品的全部代码都可以闭源，不用开源，但是当 你修改了 FreeRTOS 内核源码的时候，就必须将修改的这部分开源，反馈给社区，其它应用部 分不用开源
回复

收藏 举报

观海 发表于 2023-6-9 10:47 | 显示全部楼层
阅读 RTOS 的源码，深究内核和每个组件的实现方式，这个过程枯燥且痛苦
回复

收藏 举报

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

本版积分规则

kzlzqi

127

主题

996

帖子

2

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