你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

STM32之FreeRTOS

[复制链接]
阿松松 发布时间:2015-1-6 13:45
第一次接触的RTOS就是FreeRTOS,哈哈,资料和大家分享了
2 u  n9 F/ F9 K- t- {9 A
: ]/ D9 Q% D/ W" z+ f" E) [- V
7 ^7 @! d. ]0 d7 A, `6 G( K学习操作系统,我并没有一开始就学习UCOS,而是选择了FreeRTOS。FreeRTOS可以方便地搭建在各个平台上,因为汇编相关,都已经由官方完成,我们要做的仅是添加自己的代码,可省去很多工作量。

      问题1:在使用多任务时,我想利用USART输出信息,但是如果直接放在任务中输出,往往会造成字符收发顺序不一致的情况,这是仿真时遇到的实际问题。为解决这个问题,可以在USART输出信息时挂起其它任务,利用vTaskSuspendAll函数挂起,再利用xTaskResumeAll重启内核调度。这样可以保证USART正确发送信息。但是,我觉得还不如为USART建立一个任务,这样子,USART就不会发生发送字符顺序错乱的问题了!而完成任务间的通信,就可以考虑使用队列!

       在此,队列的功能相当于任务与任务之间进行通信的通道。USART的任务可通过查询队列是否为空来决定是否输出。

队列的使用:

       定义队列:

      xQueueHandle USART_Q;

       建立队列:

       xQueueCreate( uxQueueLength, uxItemSize );

       第一个参数为队列中元素个数;第二个参数为队列中元素大小,单位为字节。

       也可以使用

       xQueueGenericCreate( uxQueueLength, uxItemSize, queueQUEUE_TYPE_BASE )创建队列,接下来的三个函数都有两种使用方法。

6 O6 t5 G3 V9 w( r1 g

       发送消息:

      xQueueSend( xQueue, pvItemToQueue, xTicksToWait );

      第一个参数为队列句柄,第二个参数为队列元素,第三个参数为阻塞超时时间,如果在发送时队列已满,这个时间即是任务处于阻塞态等待队列空间有效的最长等待时间。


9 _* H* x+ ^8 A

      接收消息:

      xQueueReceive( xQueue, pvBuffer, xTicksToWait )

      一般用法如:while( xQueueReceive( xLCDQueue, &xMessage, portMAX_DELAY ) != pdPASS );

以上为队列用法,因为学习粗浅,不能进行深入分析……

注意,经查看代码,发送元素到队列的过程中,是将元素复制进队列中的,而并不是指针引用。


6 `% z6 O3 X+ i& \% q

演示代码:

  1. xQueueHandle  USART1_MSGQ;   //To receive the usart characters's queue. x+ H4 i  N* X  w: U8 L

  2. 3 P3 G& v7 y1 k# b
  3. volatile unsigned long mainDELAY_LOOP_COUNT=0xffff;! w" J: Z6 E6 S, @
  4. void vTask1( void *pvParameters )
    5 |2 T% Z% D1 w  }2 M- q+ E
  5. {
    + Q  e) R' j& z2 t& u
  6.     volatile unsigned long ul;/ f6 q3 e3 P9 P3 d
  7.     for( ;; )
    " L3 h5 l* B& @
  8.    {
    ) n" P' c  B0 R& ~% b
  9.         xQueueSend( USART1_MSGQ, "This is task 1 !\n",portMAX_DELAY);
    2 D0 g9 a- {! O6 {! w! D6 S& \: w
  10.         for( ul = 0; ul < mainDELAY_LOOP_COUNT; ul++ );
    " z1 O" J) Y# I" Q
  11.    }4 C+ ^! b. a& x( G7 }
  12. }7 _3 E; x- A5 K/ m
  13. void vTask2( void *pvParameters )
    9 G5 A( R0 @3 W- O" _
  14. {
    % m1 N1 i6 H6 K& a
  15.    volatile unsigned long ul;
    # `( U  V+ @, q& B5 `  s3 u
  16.    for( ;; )* x- Y5 X$ T  i9 _, v
  17.    {7 C' W7 C. ^2 T& Q: A  ~
  18.        xQueueSend( USART1_MSGQ, "This is task 2 !\n",portMAX_DELAY);4 N- k9 p7 {6 O9 c
  19.        for( ul = 0; ul < mainDELAY_LOOP_COUNT; ul++ );9 Z8 z6 j6 v, m4 ~( }" V( X. S+ K
  20.     }
    , Z6 L: k8 m- ~) v9 ~+ Y5 j8 l
  21. }
    . q. S1 r- h9 e; M$ J; R2 Z  t
  22. void vTask3( void *pvParameters )4 Z/ v; x3 f/ `+ x7 q' b
  23. {
    : P) T, A* J. |% J
  24.     char str[100];
    $ ]. G! P9 y0 j$ W+ X/ F' N
  25.     volatile unsigned long ul;
    $ W$ y% b3 n6 e. T3 }
  26.     for( ;; )5 d0 C! e+ B& B3 T
  27.    {
    + R; \) }6 ?  n9 |
  28.        while( xQueueReceive( USART1_MSGQ, str, portMAX_DELAY ) != pdPASS );
    ' i! R& y$ u2 F; ?, ]1 E- ~7 \# y
  29.        printf(str);
    ) v! L/ O) ^) S% r# M& D9 _/ m5 S" L
  30.     }" O) u7 V$ e4 R' K" W. S
  31. }
复制代码

2 J0 e# u! |" N5 t: B6 ^

在main函数中添加:

  1. USART1_MSGQ = xQueueCreate(10,(sizeof(char))*100);( Z0 s% [: F! j" r0 M2 z
  2. xTaskCreate( vTask1, "Task 1", 1000, NULL, 1, NULL );
    & U* E: k0 h, P8 {7 _. d1 p% o# f
  3. xTaskCreate( vTask2, "Task 2", 1000, NULL, 1, NULL );1 }4 W% p2 A, q5 D, y
  4. xTaskCreate( vTask3, "Task 3", 1000, NULL, 2, NULL );
    3 ]$ }. T7 f8 H1 k
  5. vTaskStartScheduler();
    8 F8 O6 T$ Y! T$ R2 Z
  6. while(1);
复制代码
6 j2 o9 G' [: H; b, |

注意,printf函数已定位到USART1串口上,使用Keil调试的时候,可以通过串口窗口看到输出内容。


$ }' _2 o# x/ Y1 r2 l+ l* N, b

二进制信号量定义与使用:

      定义信号量:

      xSemaphoreHandle xBinarySemaphore;

      vSemaphoreCreateBinary( xBinarySemaphore );

      设置信号量:(在中断处理里面设置的时候,一定要使用以FromISR结尾的函数或宏)

      xSemaphoreGiveFromISR( xBinarySemaphore, &xHigherPriorityTaskWoken );

xSemaphoreGiveFromISR的第二个参数,。如果调用xSemaphoreGiveFromISR()使得一个任务解除阻塞,并且这个任务的优先级高于当前任务(也就是被中断的任务),那么xSemaphoreGiveFromISR()会在函数内部将*pxHigherPriorityTaskWoken 设为pdTRUE。

       如果xSemaphoreGiveFromISR() 将pxHigherPriorityTaskWoken设为pdTRUE,则在中断退出前应当进行一次上下文切换。这样才能保证中断直接返回到就绪态任务中优先级最高的任务中。

        上下文切换,使用宏portEND_SWITCHING_ISR()

注意:每种处理器架构都有自己的宏定义,一般在portmacro.h文件里面,声明为portEND_SWITCHING_ISR()

        xHigherPriorityTaskWoken参数为portBASE_TYPE类型。取值为pdFALSE或者pdTRUE.

例如:

) I9 q: W  m' d3 \6 w; }
  1. static void __interrupt __far vExampleInterruptHandler( void )) I0 R; v9 E# h  \
  2. {$ C4 O1 }+ B8 Z- S# {' m
  3.    static portBASE_TYPE xHigherPriorityTaskWoken;
    4 }6 z" Y3 Y( a" j8 t
  4.    xHigherPriorityTaskWoken = pdFALSE;
    ! K5 @* k0 y# c
  5.    xSemaphoreGiveFromISR( xBinarySemaphore, &xHigherPriorityTaskWoken );
    ' M$ R% \$ [" H: y3 M' H" U
  6.    portEND_SWITCHING_ISR(xHigherPriorityTaskWoken );' w, k/ W/ e5 Y% S% {1 I
  7. }
复制代码
' w  `: o! k& p0 \! c

      获取信号量(获取不到,则进入阻塞态):

      xSemaphoreTake( xBinarySemaphore, portMAX_DELAY );

      注意,xSemaphoreTake函数的第二个参数设置为portMAX_DELAY,且在FreeRTOSConig.h 中设定INCLUDE_vTaskSuspend 为1,那么阻塞等待将没有超时限制。

, X+ f2 k% D9 C
6 m3 A! m) x1 J- g

4 X$ D( e- \! s  w. D

计数信号量定义与使用:

       因为之前没有接触过RTOS,在学习的过程中,我就不明白,为什么要搞个计数信号量,有什么意义?还好资料给我解除了这个疑惑。一个二值信号量最多只可以锁存一个中断事件,如果中断延迟处理任务还没有执行完,而中断又发生了多次,就会导致中断信息丢失。如果采用计数信号量,中断次数就能很好地保存下来。

       定义计数信号量:

xSemaphoreHandle为计数信号量的变量类型
- p( s: _3 F' {. d: [9 d8 C

       创建计数信号量:

xSemaphoreHandle xSemaphoreCreateCounting( unsigned portBASE_TYPE uxMaxCount,unsigned portBASE_TYPE uxInitialCount );

返回值为xSemaphoreHandle变量

uxMaxCount参数为最大计数值,也就是队列深度。7 ~$ P$ m% m4 C- d$ q

uxInitialCount参数为计数始值。
- t3 n' i" M% y* s( s

       设置信号量:(在中断处理里面设置的时候,一定要使用以FromISR结尾的函数或宏)

同样使用函数:xSemaphoreGiveFromISR,也要注意上下文切换。6 o- t1 [$ w" {# }: F+ P* q

       获取信号量:

同样使用函数xSemaphoreTake;


5 B" R/ n; e3 Q' m5 N8 {, X
5 ~6 \) [/ i# p) h; C* K8 `6 l

用于临界值的一组宏:

taskENTER_CRITICAL();进入临界区
2 L5 U) |8 S7 ]9 i! ^4 O. k1 j

taskEXIT_CRITICAL();退出临界区


( M1 @5 z8 k: T/ c
赞 收藏 3 评论5 发布时间:2015-1-6 13:45

举报

5个回答
stm32_beginner 回答时间:2015-1-6 13:46:26
学习了 正好正在使用
阿松松 回答时间:2015-1-6 13:46:27
调度器挂起与运行:
. @  G6 w' Y( [6 D  }/ Z2 `9 Ovoid vTaskSuspendAll( void );
$ d4 S5 Z+ b, q5 [portBASE_TYPE xTaskResumeAll( void );
  c  U( U1 D% @1 k- {6 Z
1 @4 P+ s, K! P+ U5 h4 I互斥量(及二值信号量)
1 y% {% G# j4 Y* `1 L互斥量是一种特殊的二值信号量,用于控制在两个或多个任务间访问共享资源。可以理解为得到互斥量,即可得到资源。但是用完资源,必须归还互斥量。
4 ]& Z0 y9 s6 T# q互斥量的变量类型为:
1 |  r$ `2 i. k) s' S6 BxSemaphoreHandle xMutex;
6 @& x6 G5 b, f( Z2 Q. [9 o互斥量的创建:1 S4 c9 E3 e6 T2 I
xSemaphoreHandle xSemaphoreCreateMutex( void );: m+ ~! W# p0 {. O' w
互斥量的取得:
1 n& f6 h9 I1 X* n  i7 gxSemaphoreTake( xMutex, portMAX_DELAY );
' M& v. ]4 @- R; M互斥量的归还:6 K" v. B* V4 H2 s
xSemaphoreGive( xMutex );
- z( [; w7 R; U7 e9 t" @- E% C3 a运行时的栈侦测等最后会完善。
7 B) N& e0 P3 I' F ) D% ^! O/ r0 h3 A5 l5 x3 h

+ a& w2 `$ l% E1 F! H5 oFreeRTOS的软时钟与任务延时阻塞:% K0 H$ G$ H3 M) P2 d4 ]' W
用硬件定时器有时候并不是很方便,因为得写中断,得分配信号量;而且这类开支会让定时也不能特别精确!如果使用FreeRTOS的软时钟,会比较合适。而且也能省去很多代码。
* O3 ]2 J! R8 ?+ ~: K1、任务延时阻塞vTaskDelay()函数与0 U2 ?4 {! x; l6 \  h+ d
vTaskDelay函数的使用( g7 h$ G( h! {
INCLUDE_vTaskDelay must be defined as 1 for this function to be available. See the configuration section for more information.
+ J* Z( J7 E- x8 T4 Y# h7 hDelay a task for a given number of ticks. The actual time that the task remains blocked depends on the tick rate. The constant portTICK_RATE_MS can be used to calculate real time from the tick rate .
# `$ p' h# `" Q' A: `1 l' R* }6 P/ _INCLUDE_vTaskDelay应该定义为1才能使能该函数。可以通过查看配置部分获取更多信息。函数可通过给定数值延时一个任务。任务的实际阻塞时间依赖于时钟频率。常量portTICK_RATE_MS能用来计算时钟频率的实际时间。  Z5 I! W& y" O4 \
例如:
( F9 S2 J* A9 \* R8 N$ h7 W+ }1 o0 `. B/ b' m, ^# l: c) o/ z9 _
  1. void vTaskFunction( void * pvParameters )+ n9 ^( J$ \" ^# Q  r; X. g
  2. {
    " d- \+ f" R3 ]7 T6 a
  3. /* Block for 500ms. */) b! C' P5 x: X7 g! v5 }
  4. const portTickType xDelay = 500 / portTICK_RATE_MS;' F( H$ p3 ?6 c3 v5 W1 G7 M" _9 c

  5. - H5 f# i8 b! K+ H
  6. for( ;; )
    $ M- x* }1 E9 ~; c
  7. {
    / [, v, i& W5 t1 P
  8. /* Simply toggle the LED every 500ms, blocking between each toggle. */5 W0 s; }3 O% ?2 W+ q
  9. vToggleLED();! @+ y; g# j$ o! Z
  10. vTaskDelay( xDelay );
    7 I" u% e! _4 w) M  g
  11. }
    6 f- F: r& J" [1 y* T! ]
  12. }
复制代码
. }4 o1 `' i' A3 n- l7 _
但是,vTaskDelay并不能给你一个绝对的时延,它是相对于自身的延时!因为任务切换或中断发生等原因会影响vTaskDelay函数的使用。如果要使用绝对的时延,可以使用函数vTaskDelayUntil
0 q( P5 g% H% E; y
% \  `7 b0 e. |' ?' m* a2 G- a; ovTaskDelayUntil函数的使用
8 T  E& I2 w; gINCLUDE_vTaskDelayUntil must be defined as 1 for this function to be available.
0 V; f# m" |0 r# k: F5 u  J使能函数,INCLUDE_vTaskDelayUntil必须设置为1。4 ]* z! ~, a; n$ n
Delay a task until a specified time. This function can be used by cyclical tasks to ensure a constant execution frequency.
1 P) n" E6 D0 u3 p* H9 r延迟一个任务直到指定时间。该函数能用于循环任务保持流畅执行。" m' t3 U0 _! I2 h; R
This function differs from vTaskDelay() in one important aspect: vTaskDelay() specifies a time at which the task wishes to unblock relative to the time at which vTaskDelay() is called, whereas vTaskDelayUntil() specifies an absolute time at which the task wishes to unblock.3 c; F% e. o% }
该函数与vTaskDelay函数最大不同的一方面在于:vTaskDelay指定的时间是相对于vTaskDelay调用时开始的,然而vTaskDelayUntil指定的时间是绝对的时间,到时间一定解除阻塞。
, ?& @( F4 U* Y# J8 u9 @& SvTaskDelayUntil函数的使用:5 k1 O- R( U/ H) Q+ ~
  1. // Perform an action every 10 ticks.
    * Q# [6 k. a: V# D& |
  2. void vTaskFunction( void * pvParameters )# U8 O1 p0 F) {/ U9 J6 p" s- L
  3. {
    * w1 D/ F- P# E2 W. O9 t* _% E9 }
  4. portTickType xLastWakeTime;9 ~1 ^* f( o/ _3 I4 f9 u
  5. const portTickType xFrequency = 10;
    5 c, x$ d6 x& ^

  6. ; o7 M# v5 S- u
  7. // Initialise the xLastWakeTime variable with the current time.5 V, ~* P- M5 t9 j6 x
  8. xLastWakeTime = xTaskGetTickCount();$ s- X$ J7 a; x4 i
  9. for( ;; )
    & U! O! ^. Q, Y: c; J
  10. {
    : u( N6 P+ w$ m$ T6 n1 a
  11. // Wait for the next cycle.% V0 D' o4 i" x# _/ Y: b" {
  12. vTaskDelayUntil( &xLastWakeTime, xFrequency );
    . n4 ]+ p- H; o( X3 L; w! g
  13. // Perform action here.
    . X6 v* i: ^0 n, j1 e. R2 n
  14. }
    3 m) w) z/ D" ]
  15. }
复制代码

' h6 z" e2 v3 N5 b; a
  |* w# f3 z$ E; _* ~- ^听说FreeRTOS任务可以同优先级,但是发现同优先级创建3个以上任务就无法调度?不知道是什么原因?
0 P! e' n/ W" w6 s" W" [原因:一般情况下,刚开始学FreeRTOS都习惯将任务栈空间设置为1000,这意味着将要在系统里面申请4000个字节(栈空间以4字节为单位);创建3个任务,申请的约为12K左右的样子,如果再创建一个任务,也是用的1000; 那么意味着向系统申请16K左右的栈空间。加上空闲任务的栈空间,你FreeRTOSConfig.h文件里面的栈空间默认值为#define configTOTAL_HEAP_SIZE( ( size_t ) ( 17 * 1024 ) );也就是17K。显然运行不了,是因为堆栈空间不足的原因!
# C' n$ v  q& ?3 r解决:两种办法:1、任务栈空间调小点,变成500;2、系统栈空间调大点,变成30K ;一般就足够你跑5到6个任务了。如果再小,跑得更多!
) k( b. c9 V: P. z( e/ y; R- x& l: [) I+ z( Y5 }. h
调度器只能调度一次就崩溃了,移植汇编都没问题?  k  |' q! @$ k4 K$ |
原因:你的任务函数没放在死循环里面!
% J# H; |, l5 j4 V , ~4 l1 q6 @" F' R$ a1 |
( I; d! J+ @7 H/ U% E# f. C
发现一个问题,在使用# `, ~0 v1 Y' f' ?5 d
vSemaphoreCreateBinary(xActiveSemaphore);创建二值信号量后,不能立即使用xSemaphoreGive(xActiveSemaphore)释放二值信号量!官网说明如下:4 s3 D& E! e/ Z
vSemaphoreCreateBinary  is a Macro to release a semaphore. The semaphore must have previously been created with a call to xSemaphoreCreateBinary(), xSemaphoreCreateMutex() or xSemaphoreCreateCounting(), and obtained using sSemaphoreTake().
) Q. }7 h( _' V6 T) Y意思是vSemaphoreCreateBinary  是一个用于释放信号量的宏。其中的信号量必须被xSemaphoreCreateBinary(), xSemaphoreCreateMutex() or xSemaphoreCreateCounting()等函数调用完成后,而且必须被sSemaphoreTake()获取后才能使用!
6 ^, j; A) I8 _: \简单地说是要xSemaphoreGive(xActiveSemaphore),必须创建了信号量后才可以!/ }5 y% R. \  c: ?
can-39743 回答时间:2015-4-9 19:28:08
mark,                                                   
stary666 回答时间:2015-4-10 09:35:49
正在学习使用
wamcncn 回答时间:2015-4-10 15:36:16
标记,学习一下
关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版