5 f+ a* ~+ G0 u* S5 ~! F

创客的兄弟姐妹们大家好，我是杰杰。又到了更新的时候了。

听首歌缓解一下心情。

开始今天的内容之前，先补充一下上篇文章【连载】从单片机到操作系统③——走进FreeRTOS的一点点遗漏的知识点。

1BaseType_t xTaskCreate(       TaskFunction_t pvTaskCode,
2                              const char * const pcName,
3                              uint16_t usStackDepth,
4                              void *pvParameters,
0 x8 R5 I- j+ I% _% V; P/ G 5                              UBaseType_t uxPriority,
6                              TaskHandle_t *pvCreatedTask
7                          );
# [5 m+ u9 X( }# z9 _ 8创建任务中的堆栈大小问题，在task.h中有这样子的描述：
- t8 o7 ?! O* F6 P+ o+ ^7 p9 I+ m 9/**
# u# Q8 f: y5 A, }. m: a+ v% j10* @param usStackDepth The size of the task stack specified as the number of variables the stack * can hold - not the number of bytes.  For example, if the stack is 16 bits wide and  
3 O' x+ T, T9 |% a. j11* usStackDepth is defined as 100, 200 byteswill be allocated for stack storage.
& r0 ]; M3 Q  _" g5 [12*/

代码可左右滑动

& a0 Q3 k, Y" e. g

  当任务创建时，内核会分为每个任务分配属于任务自己的唯一堆栈。usStackDepth 值用于告诉内核为它应该分配多大的栈空间。

这个值指定的是栈空间可以保存多少个字(word) ，而不是多少个字节(byte)。

文档也有说明，如果是16位宽度的话，假如usStackDepth = 100；那么就是200个字节（byte）。

当然，我用的是stm32，32位宽度的， usStackDepth=100；那么就是400个字节（byte）。

  好啦，补充完毕。下面正式开始我们今天的主题。

---

# c' m+ k9 j8 }! t

  我自己学的是应用层的东西，很多底层的东西我也不懂，水平有限，出错了还请多多包涵。

  其实我自己写文章的时候也去跟着火哥的书看着底层的东西啦，但是本身自己也是不懂，不敢乱写。所以，这个《从单片机到操作系统》系列的文章，我会讲一点底层，更多的是应用层，主要是用的方面。

按照一般的写代码的习惯，在main函数里面各类初始化完毕了，并且创建任务成功了，那么，可以开启任务调度了。

1int main(void)
) ]$ `- s7 A; E1 b% f9 O1 F 2{
3 W! A9 [( Y: q3 \% h1 [ 3    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4   
4    Delay_Init();                       //延时函数初始化     
5    Uart_Init(115200);                  //初始化串口
5 L, R4 u3 W. f 6    LED_Init();                     //初始化LED
" R% t* s! F! D" M5 A 7    KEY_Init();
8    //创建开始任务
9    xTaskCreate((TaskFunction_t )start_task,            //任务函数
& q! f: [3 d0 l6 k10                (const char*    )"start_task",          //任务名称
11                (uint16_t       )START_STK_SIZE,        //任务堆栈大小
* d$ {" i' k# f" B8 U12                (void*          )NULL,                  //传递给任务函数的参数
8 A4 S& w6 O" N6 H/ ^0 I13                (UBaseType_t    )START_TASK_PRIO,       //任务优先级
14                (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
15    vTaskStartScheduler();          //开启任务调度
. a% K  ~" u# w7 [& d/ p16}
5 f& V9 M1 j$ c# ?

  来大概看看分析一下创建任务的过程，虽然说会用就行，但是也是要知道了解一下的。

注意：下面说的创建任务均为xTaskCreate（动态创建）而非静态创建。

1pxStack = ( StackType_t * ) pvPortMalloc( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) );
# v$ e0 O, }9 c+ F& }4 ] 2/*lint !e961 MISRA exception as the casts are only redundant for some ports. */
3            if( pxStack != NULL )
9 Z' Q4 w8 q  l  w% a 4            {
5                /* Allocate space for the TCB. */
+ O% B' e6 }9 j4 v 6                pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) );
9 Z% p5 x1 Q/ C" o 7                /*lint !e961 MISRA exception as the casts are only redundant for some paths. */
5 O3 ^0 f5 Q  r9 _/ E1 `/ u0 ? 8                if( pxNewTCB != NULL )
9                {
6 k5 M" z4 I+ }3 c: T* X  p10                    /* Store the stack location in the TCB. */
11                    pxNewTCB->pxStack = pxStack;
5 _% k/ d5 L; O: J, _1 Y6 m5 I* b12                }
13                else
5 n" v- M! o9 i3 J) A1 e14                {
15                    /* The stack cannot be used as the TCB was not created.  Free
7 ^3 s3 l; K2 y+ ^16                    it again. */
5 E0 y2 Z* p7 D2 s2 p: H17                    vPortFree( pxStack );
18                }
5 ~% T' v  n( ]. e2 y19            }
20            else
& N, j/ `8 v6 T0 \+ A8 s21            {
22                pxNewTCB = NULL;
% Y0 y+ _2 }9 {: y7 g23            }
) M3 p, }; i- z3 n- i) x24        }

  首先是利用pvPortMalloc给任务的堆栈分配空间，if( pxStack != NULL )如果内存申请成功，就接着给任务控制块申请内存。pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) );同样是使用pvPortMalloc();如果任务控制块内存申请失败则释放 之前已经申请成功的任务堆栈的内存vPortFree( pxStack );

  然后就初始化任务相关的东西，并且将新初始化的任务控制块添加到列表中prvAddNewTaskToReadyList( pxNewTCB );

  最后返回任务的状态，如果是成功了就是pdPASS，假如失败了就是返回errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;

- \1 ~7 x7 E1 J2 q1 b; W( O  {- C4 Q 1prvInitialiseNewTask(     pxTaskCode,
' R/ u5 B% X* s8 @. L" `2 M/ q 2                          pcName,
$ |  Q; G1 X9 T& ]% @ 3                         ( uint32_t ) usStackDepth,
4                          pvParameters,
+ \3 W9 g) F* D1 o9 x) k( A, A) o 5                          uxPriority,
6                         pxCreatedTask,
1 V& ?! t. m( X" B1 b- p 7                          pxNewTCB,
5 Q6 Y2 O( e: P  o% c 8                         NULL );
; t- X' d$ }! n) W5 i, t+ A 9            prvAddNewTaskToReadyList( pxNewTCB );
9 k6 s6 G" r2 ?6 I/ C( ~( i10            xReturn = pdPASS;
, t7 i( W* o  `0 n: f11        }
12        else
" F6 _, K) {1 M) U$ e8 @- b1 D7 k) x13        {
, M) @5 B8 l# G9 L) g$ h" X1 e14            xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
15        }
16        return xReturn;
+ l' B8 C- G# h6 ~8 K7 F17    }
0 [& k6 `/ ?1 D7 H# D& N18// 相关宏定义
19#define pdPASS            ( pdTRUE )
: l; y  Z8 x4 e) M: G- n* O# u20#define pdTRUE            ( ( BaseType_t ) 1 )
21/* FreeRTOS error definitions. */
  Q8 Y: w: v9 {9 G4 D' @22#define errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY    ( -1 )

  具体的static void prvInitialiseNewTask(()实现请参考FreeRTOS的tasks.c文件的767行代码。具体的static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB )实现请参考FreeRTOS的tasks.c文件的963行代码。

  因为这些是tasks.c中的静态的函数，仅供xTaskCreate创建任务内部调用的，我们无需理会这些函数的实现过程，当然如果需要请自行了解。

1 j- F) z& [' n% w' N

创建完任务就开启任务调度了：

1vTaskStartScheduler();          //开启任务调度

在任务调度里面，会创建一个空闲任务（我们将的都是动态创建任务，静态创建其实一样的）

1xReturn = xTaskCreate(    prvIdleTask,
2                          "IDLE", configMINIMAL_STACK_SIZE,
3                          ( void * ) NULL,
4                          ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ),
5                          &xIdleTaskHandle );
6/*lint !e961 MISRA exception, justified as it is not a redundant explicit cast to all supported compilers. */
' N+ w8 }* R: B! m' n* r- g 7    }
8相关宏定义：
9#define tskIDLE_PRIORITY            ( ( UBaseType_t ) 0U )
10#ifndef portPRIVILEGE_BIT
* J. \: T& r9 y3 S2 t11    #define portPRIVILEGE_BIT ( ( UBaseType_t ) 0x00 )
4 m6 i0 v1 A2 q* K6 |, t6 B6 g12#endif
13#define configUSE_TIMERS                        1                              
& y2 ]; o6 r$ }/ B% Z/ s( D0 m  q14 //为1时启用软件定时器

从上面的代码我们可以看出，空闲任务的优先级是tskIDLE_PRIORITY为0，也就是说空闲任务的优先级最低。当CPU没事干的时候才执行空闲任务，以待随时切换优先级更高的任务。

如果使用了软件定时器的话，我们还需要创建定时器任务，创建的函数是：

1#if ( configUSE_TIMERS == 1 )
* N( a8 K& i$ \6 Q$ p+ Q2    BaseType_t xTimerCreateTimerTask( void )
3
) j/ f2 X* @1 ?  k% q8 g9 n3 q

然后还要把中断关一下

1portDISABLE_INTERRUPTS();
' z& e( d& D7 y

至于为什么关中断，也有说明：

1/* Interrupts are turned off here, toensure a tick does not occur
+ y3 y) \) F: ` 2before or during the call toxPortStartScheduler().  The stacks of
3the created tasks contain a status wordwith interrupts switched on
4so interrupts will automatically getre-enabled when the first task
# z$ K% T1 c$ w, p: z; P' r8 a 5starts to run. */
6/ *中断在这里被关闭，以确保不会发生滴答
, p  E" A; x  \$ F; m 7在调用xPortStartScheduler（）之前或期间。堆栈
* h  o3 W2 q& N7 Q 8创建的任务包含一个打开中断的状态字
9因此中断将在第一个任务时自动重新启用
+ A0 O, V: D, F# J/ t, C& @; i10开始运行。*/
; E2 E( A( _, z4 g# Y1 }6 }

那么如何打开中断呢？？？？这是个很重要的问题

别担心，我们在SVC中断服务函数里面就会打开中断的

看代码：

1__asm void vPortSVCHandler( void )
, L, y7 X0 u5 U/ o; F4 F. \' q 2{
3 u4 }2 T# Q# m9 Q+ ^ 3         PRESERVE8
4         ldr    r3, =pxCurrentTCB  /* Restore the context. */
5         ldrr1, [r3]                            /* UsepxCurrentTCBConst to get the pxCurrentTCB address. */
  ~) s8 w0 p8 R, P1 H+ m9 F8 [ 6         ldrr0, [r1]                            /* Thefirst item in pxCurrentTCB is the task top of stack. */
  h% c' }3 h8 u9 u& y5 L 7         ldmiar0!, {r4-r11}             /* Pop theregisters that are not automatically saved on exception entry and the criticalnesting count. */
7 v, ?3 C; U9 o# q- s 8         msrpsp, r0                                   /*Restore the task stack pointer. */
9         isb
10         movr0, #0
11         msr  basepri, r0
8 |( }# a' L1 C6 G0 s12         orrr14, #0xd
13         bxr14
( M3 r" D3 Z4 N5 [+ D# g14}
  w3 [& I; h' W+ x
1msr  basepri, r0
) x( H' r# s5 E* q' h

  就是它把中断打开的。看不懂没所谓，我也不懂汇编，看得懂知道就好啦。

2 J* V9 u: t( i+ I% b; T2 a5 |( U1xSchedulerRunning = pdTRUE;
3 R% O3 B) O( h! u' i9 z! p

任务调度开始运行

' e% b( p  W5 I1/* If configGENERATE_RUN_TIME_STATS isdefined then the following
2macro must be defined to configure thetimer/counter used to generate
3the run time counter time base. */
/ }( `# M" B! z4 H/ q4portCONFIGURE_TIMER_FOR_RUN_TIME_STATS();

如果configGENERATE_RUN_TIME_STATS使用时间统计功能，这个宏为1，那么用户必须实现一个宏portCONFIGURE_TIMER_FOR_RUN_TIME_STATS();用来配置一个定时器或者计数器。

来到我们的重点了，开启任务调度，那么任务到这了就不会返回了。

1if( xPortStartScheduler() != pdFALSE )
4 t4 w5 Y; }2 s4 b9 M# @2                   {
3                            /*Should not reach here as if the scheduler is running the
0 ]0 R: `# `. C4                            functionwill not return. */
5                   }然后就能开启第一个任务了，感觉好难是吧，我一开始也是觉得的，但是写了这篇文章，觉得还行吧，也不算太难，可能也是在查看代码跟别人的书籍吧，写东西其实还是蛮好的，能加深理解，写过文章的人就知道，懂了不一定能写出来，所以，我还是很希望朋友们能投稿的。杰杰随时欢迎。。。

开始任务就按照套路模板添加自己的代码就好啦，很简单的。

先创建任务：

1 xTaskCreate((TaskFunction_t )led0_task,   
2                (const char*    )"led0_task",  
$ I) ^* [1 p- E; E5 D4 c 3                (uint16_t       )LED0_STK_SIZE,
4                (void*          )NULL,                                    
5                (UBaseType_t    )LED0_TASK_PRIO,   
" ]2 Q) K( i3 l( R) F6 r0 P- x 6                (TaskHandle_t*  )&LED0Task_Handler);  
7   //创建LED1任务
8   xTaskCreate((TaskFunction_t )led1_task,   
+ w; @3 Z# I2 t! C 9                (const char*    )"led1_task",  
" R: C+ w+ v0 w10                (uint16_t       )LED1_STK_SIZE,
& y" }2 V0 o6 v. l" T( y  X11                (void*          )NULL,
( e  n6 e" c! @# ~3 [12                (UBaseType_t    )LED1_TASK_PRIO,
13                (TaskHandle_t*  )&LED1Task_Handler);      

7 h3 q) h, o) \+ B3 h: [3 w3 m

创建完任务就开启任务调度：

1vTaskStartScheduler();          //开启任务调度

然后具体实现任务函数：

1//LED0任务函数
2void led0_task(void *pvParameters)
$ y4 Y; W3 D+ A; D" { 3{
0 |4 h+ E, y7 M% C 4   while(1)
; b& B- z0 @* C 5    {
' R1 T% j& o/ C3 H8 X/ h 6       LED0=~LED0;
. |2 x# m2 X. b$ n/ S$ W% X 7       vTaskDelay(500);
8    }
9}  
10//LED1任务函数
11void led1_task(void *pvParameters)
2 z$ t. u# u1 a12{
# G  @* k, R$ z0 |0 e( q3 `13   while(1)
14    {
15       LED1=0;
16       vTaskDelay(200);
17       LED1=1;
18       vTaskDelay(800);
19    }
20}

1 Y" g0 h, F) O- {' E) ^

好啦，今天的介绍到这了为止，后面还会持续更新，敬请期待哦~

欢迎大家一起来讨论操作系统的知识

我们的群号是：783234154

/ |0 q% x( s1 ^0 T; m* q' U6 e
/ z( w1 Z( y" `) k7 ]9 O# U

【连载】从单片机到操作系统①
4 h* i/ s  K. b( R

【连载】从单片机到操作系统②

【连载】从单片机到操作系统③——走进FreeRTOS
' T" d/ _% `( d7 Y3 n

创客飞梦空间是开源公众号

欢迎大家分享出去

也欢迎大家投稿

" t; H# ?' k+ x
- p* s/ a3 c, Y0 Y2 F' v* \

xiaojie0513 发表于 2018-5-31 18:05
2 }5 i: v# A+ o3 J, y3 v怎么样啊，杰杰水平有限，还要多多指教吖

写的很好。我对于单片机的操作系统不是很了解，底层的倒是知道，还有就是了解些Linux系统。

         
参与/回复主题
关闭
RE: 【连载】从单片机到操作系统④——FreeRTOS创建任务&开启... [修改]

lilei900512 发表于 2018-5-31 12:42
看看怎么样！

怎么样啊，杰杰水平有限，还要多多指教吖

看完留个言啊

竟然看完了  

谢谢打赏~

感谢楼主分享

king_lv 发表于 2018-5-31 11:33
感谢楼主分享

: A. [4 s/ s+ s) y9 T1 _

看看怎么样！

写的好

heyv11 发表于 2018-6-7 21:52
写的好

谢谢支持

支持楼主，好东西

学习一下

billy226-301299 发表于 2018-6-13 11:20
支持楼主，好东西

  v/ N+ _% `! y7 t5 i; b谢谢支持
& C, k$ c+ v, o谢谢支持