ucos 怎样确定任务堆栈大小

1、首先需要知道，μC/OS-II中创建任务的函数有两个: OSTaskCreate()和OSTaskCreateExt()

（1）OSTaskCreate() //创建普通任务 

由于重点在下面的创建扩展任务函数，故本函数就不多说了！确实，要想实现检测目标任务栈实际使用情况的功能，是不能使用这个函数来创建目标任务的，必须使用OSTaskCreateExt() 。

（2）OSTaskCreateExt() //创建扩展任务

函数接口原型为：

#if OS_TASK_CREATE_EXT_EN > 0
INT8U OSTaskCreateExt

(

void (*task)(void *pd), //建立扩展任务(任务代码指针
void *pdata, //传递参数指针
OS_STK *ptos, //分配任务堆栈栈顶指针
INT8U prio, //分配任务优先级
INT16U id, //(未来的)优先级标识(与优先级相同)
OS_STK *pbos, //分配任务堆栈栈底指针
INT32U stk_size, //指定堆栈的容量(检验用)
void *pext, //指向用户附加的数据域的指针
INT16U opt //建立任务设定选项

)
#endif

2、其次需要知道μC/OS-II中有这么个函数：OSTaskStkChk()

不错，检测任务堆栈实际使用情况正是用的这个函数，下面来本函数的接口原型：

INT8U OSTaskStkChk

(

INT8U prio,  //待测任务的优先级

OS_STK_DATA *pdata //指向一个类型为OS_STK_DATA的结构体

)

3、再次需要知道一个结构体：

#if OS_TASK_CREATE_EXT_EN > 0
typedef struct

{
INT32U OSFree; //堆栈中未使用的字节数
INT32U OSUsed; //堆栈中已使用的字节数
} OS_STK_DATA;
#endif

参数: prio 为指定要获取堆栈信息的任务优先级，也可以指定参数OS_PRIO_SELF，获取调用任务本身的
信息。
pdata 指向一个类型为OS_STK_DATA的数据结构，其中包含如下信息：
INT32U OSFree; // 堆栈中未使用的字节数
INT32U OSUsed; // 堆栈中已使用的字节数

4、有了上述三个知识点后就可以啦，具体方法为：

（1）将函数的最后一个参数opt 设置为：OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR

（2）定义一个变量：OS_STK_DATA  StackBytes；

（3）调用函数OSTaskStkChk(TestTaskPRIO, &StackBytes)

（4）StackBytes.OSFree的值即为被测任务堆栈未使用的字节数，

StackBytes.OSUsed的值即为被测任务堆栈已使用的字节数。

5、需要设置宏：OS_TASK_OPT_STK_CLR为1

6、最后一点建议：

（1）将被测任务经历最坏的堆栈使用状态，测出来的使用率才可靠

（2）堆栈使用率最好在%50~%80之间，太小浪费空间，太大不安全

（3）最好在工程中单独建立一个优先级较低延时较长的任务来测试其它任务的堆栈使用情况，不用时可以挂起该任务

有时候决定任务实际所需的堆栈空间大小是很有必要的。因为这样用户就可以避免为任务分配过多的堆栈空间，从而减少自己的应用程序代码所需的RAM(内存)数量。?C/OS-Ⅱ提供的OSTaskStkChk()函数可以为用户提供这种有价值的信息。

在图4.2中，笔者假定堆栈是从上往下递减的(即OS_STK_GROWTH被置为1)，但以下的讨论也同样适用于从下往上长的堆栈[F4.2(1)]。?C/OS-Ⅱ是通过查看堆栈本身的内容来决定堆栈的方向的。只有内核或是任务发出堆栈检验的命令时，堆栈检验才会被执行，它不会自动地去不断检验任务的堆栈使用情况。在堆栈检验时，?C/OS-Ⅱ要求在任务建立的时候堆栈中存储的必须是0值(即堆栈被清零)[F4.2(2)]。另外，?C/OS-Ⅱ还需要知道堆栈栈底(BOS)的位置和分配给任务的堆栈的大小[F4.2(2)]。在任务建立的时候，BOS的位置及堆栈的这两个值储存在任务的OS_TCB中。

为了使用?C/OS-Ⅱ的堆栈检验功能，用户必须要做以下几件事情：

l  在OS_CFG.H文件中设OS_TASK_CREATE_EXT为1。

l  用OSTaskCreateExt()建立任务，并给予任务比实际需要更多的内存空间。

l  在OSTaskCreateExt()中，将参数opt设置为OS_TASK_OPT_STK_CHK+OS_TASK_OPT_STK_

CLR。注意如果用户的程序启动代码清除了所有的RAM，并且从未删除过已建立了的任务，那么用户就不必设置选项OS_TASK_OPT_STK_CLR了。这样就会减少OSTaskCreateExt()的执行时间。

l  将用户想检验的任务的优先级作为OSTaskStkChk()的参数并调用之。

图 4.2          堆栈检验

OSTaskStkChk()顺着堆栈的栈底开始计算空闲的堆栈空间大小，具体实现方法是统计储存值为0的连续堆栈入口的数目，直到发现储存值不为0的堆栈入口[F4.2(5)]。注意堆栈入口的储存值在进行检验时使用的是堆栈的数据类型(参看OS_CPU.H中的OS_STK)。换句话说，如果堆栈的入口有32位宽，对0值的比较也是按32位完成的。所用的堆栈的空间大小是指从用户在OSTaskCreateExt()中定义的堆栈大小中减去了储存值为0的连续堆栈入口以后的大小。OSTaskStkChk()实际上把空闲堆栈的字节数和已用堆栈的字节数放置在0S_STK_DATA数据结构中(参看?COS_Ⅱ.H)。注意在某个给定的时间，被检验的任务的堆栈指针可能会指向最初的堆栈栈顶(TOS)与堆栈最深处之间的任何位置[F4.2(7)]。每次在调用OSTaskStkChk()的时候，用户也可能会因为任务还没触及堆栈的最深处而得到不同的堆栈的空闲空间数。

用户应该使自己的应用程序运行足够长的时间，并且经历最坏的堆栈使用情况，这样才能得到正确的数。一旦OSTaskStkChk()提供给用户最坏情况下堆栈的需求，用户就可以重新设置堆栈的最后容量了。为了适应系统以后的升级和扩展，用户应该多分配10％－100％的堆栈空间。在堆栈检验中，用户所得到的只是一个大致的堆栈使用情况，并不能说明堆栈使用的全部实际情况。

OSTaskStkChk()函数的代码如程序清单 L4.10所示。0S_STK_DATA(参看?COS_Ⅱ.H)数据结构用来保存有关任务堆栈的信息。笔者打算用一个数据结构来达到两个目的。第一，把OSTaskStkChk()当作是查询类型的函数，并且使所有的查询函数用同样的方法返回，即返回查询数据到某个数据结构中。第二，在数据结构中传递数据使得笔者可以在不改变OSTaskStkChk()的API(应用程序编程接口)的条件下为该数据结构增加其它域，从而扩展OSTaskStkChk()的功能。现在，0S_STK_DATA只包含两个域：OSFree和OSUsed。从代码中用户可看到，通过指定执行堆栈检验的任务的优先级可以调用OSTaskStkChk()。如果用户指定0S_PRIO_SELF[L4.10(1)]，那么就表明用户想知道当前任务的堆栈信息。当然，前提是任务已经存在[L4.10(2)]。要执行堆栈检验，用户必须已用OSTaskCreateExt()建立了任务并且已经传递了选项OS_TASK_OPT_CHK[L4.10(3)]。如果所有的条件都满足了，OSTaskStkChk()就会象前面描述的那样从堆栈栈底开始统计堆栈的空闲空间[L4.10(4)]。最后，储存在0S_STK_DATA中的信息就被确定下来了[L4.10(5)]。注意函数所确定的是堆栈的实际空闲字节数和已被占用的字节数，而不是堆栈的总字节数。当然，堆栈的实际大小(用字节表示)就是该两项之和。

程序清单 L 4.10   堆栈检验函数

INT8U OSTaskStkChk (INT8U prio, OS_STK_DATA *pdata)

{

OS_TCB  *ptcb;

OS_STK  *pchk;

INT32U   free;

INT32U   size;

pdata->OSFree = 0;

pdata->OSUsed = 0;

if (prio > OS_LOWEST_PRIO && prio != OS_PRIO_SELF) {

return (OS_PRIO_INVALID);

}

OS_ENTER_CRITICAL();

if (prio == OS_PRIO_SELF) {                                              (1)

prio = OSTCBCur->OSTCBPrio;

}

ptcb = OSTCBPrioTbl[prio];

if (ptcb == (OS_TCB *)0) {                                               (2)

OS_EXIT_CRITICAL();

return (OS_TASK_NOT_EXIST);

}

if ((ptcb->OSTCBOpt & OS_TASK_OPT_STK_CHK) == 0) {                   (3)

OS_EXIT_CRITICAL();

return (OS_TASK_OPT_ERR);

}

free = 0;                                                                  (4)

size = ptcb->OSTCBStkSize;

pchk = ptcb->OSTCBStkBottom;

OS_EXIT_CRITICAL();

#if OS_STK_GROWTH == 1

while (*pchk++ == 0) {

free++;

}

#else

while (*pchk-- == 0) {

free++;

}

#endif

pdata->OSFree = free * sizeof(OS_STK);                                 (5)

pdata->OSUsed = (size - free) * sizeof(OS_STK);

return (OS_NO_ERR);

}

uCOS-III任务堆栈溢出检测及统计任务堆栈使用量的方法 

1. 在操作系统任务设计的时候，通常会遇到一个比较麻烦的问题，也就是任务 堆 栈大小设定的问题，为此我们我需要知道一些问题 ：

1.1. 任务堆栈一但溢出，意味着系统的崩溃，在有MMU或者MPU的系统中，对堆栈溢出的检测十分简单，因为这是MMU和MPU必备的功能之一。（uCOS-II/uCOS-III中均有针对没有MMU和MPU的处理器对堆栈溢出检测的策略）

1.2. 堆栈的大小取决于该任务的需求。设定堆栈大小时，你就需要考虑：所有可能被堆栈调用的函数及其函数的嵌套层数，相关局部变量的大小，中断服务程序所需要的空间。另外，堆栈还需存入CPU寄存器，如果处理器有浮点数单元FPU寄存器的话还需存入FPU寄存器。（PS：出于这点，所以在嵌入式系统中有个潜规则，避免写递归函数）

1.3. 虽然任务堆栈大小可以通过人工计算出来，但是要考虑的太多，而且不能十分精确的计算。比如逐级嵌套被调用的函数的参数使用，上下文切换时候的CPU寄存器空间的保存，中断时CPU寄存器空间的保存和中断处理函数的堆栈空间等等，未免太过麻烦。特别的，当任务中使用了printf()之类参数可变的函数，那么统计起来就更困难了。所以这种方式怎么看怎么不现实。囧  。

1.4. 建议在不是很精确的确定任务堆栈使用大小(stk_size)的情况下，还是采取stk_size乘以1.5或者2.0的做法，以保证任务的正常运行。

2. uCOS-III任务堆栈溢出检测原理

每个任务都有自己的TCB(Task Control Block 任务控制块)， TCB结构定义在uCOS-III源码(我使用的是V3.03.00版本)中的os.h中。 TCB中有个 StkLimitPtr成员。

假设在切换到任务S前，代码会检测将要被载入CPU堆栈指针的值是否超出该任务S的TCB中StkLimitPtr限制。因为软件不能在溢出时就迅速地做出反应，所以应该设置StkLimitPtr的值尽可能远离&MyTaskStk[0]，保证有足够的溢出缓冲。如下图。软件检测不会像硬件检测那样有效，但也可以防止堆栈溢出。 当uC/OS-III从一个任务切换到另一个任务的时候，它会调用一个 hook函数OSTaskSwHook()，它允许用户扩展上下文切换时的功能。 所以，如果处理器没有硬件支持溢出检测功能，就可以在该hook函 数中添加代码软件模拟该能。

不过我个人的做法是，通常设置StkLimitPtr指向任务栈大小的90%处，然后获取任务堆栈使用量，如果栈使用率大于90%时就必须做出警告了！下面就来介绍任务栈使用量的获取。

图1

3. uCOS-III任务堆栈使用量统计的原理和方法

3.1 原理

原理其实很简单，就是统计连续为0的区域的大小就可以知道空闲栈free的大小，而任务在创建时任务栈总量TaskStkSize是确定的，那么使用了的栈大小used =  TaskStkSize  - free。见图2。

图2 

首先，当任务创建时其堆栈被清零。然后，通过一个低优先级任务，计算该任务整个堆栈中值为0的内存大小。如果发现都不为0，那么就需要扩展堆栈的大小。然后，调整堆栈为的相应大小。这是一种非常有效的方法。注意的是，程序需用运行很长的时间以让堆栈达到其需要的最大值。 

3.2 方法 

uC/OS-III提供了一个函数OSTaskStkChk()用于实现这个计算功能。那么就来看看具体怎么做吧。 

3.2.1 首先创建一个任务来运行任务堆栈统计工作，值得注意的是，这个任务的优先级建议设置为系统所有任务中最低的一个！

#define  SystemDatasBroadcast_PRIO            12 // 统计任务优先级最低，我这里是12，已经低于其他任务的优先级了#define  SystemDatasBroadcast_STK_SIZE       100 // 任务的堆栈大小，做统计一般够了，统计结果出来后不够再加..OS_TCB  SystemDatasBroadcast_TCB; // 定义统计任务的TCBCPU_STK SystemDatasBroadcast_STK [SystemDatasBroadcast_STK_SIZE];// 开辟数组作为任务栈给任务使用static  void  AppTaskCreate(void){  // .....
// 这是系统创建任务的函数，还有其他任务创建的代码，这里就不贴出了
// .....

OSTaskCreate( (OS_TCB     *)&SystemDatasBroadcast_TCB,
(CPU_CHAR   *)"SystemDatasBroadcast",
(OS_TASK_PTR ) SystemDatasBroadcast,
(void       *) 0,
(OS_PRIO     ) SystemDatasBroadcast_PRIO,
(CPU_STK    *)&SystemDatasBroadcast_STK[0],
(CPU_STK_SIZE) SystemDatasBroadcast_STK_SIZE/10,/*栈溢出临界值我设置在栈大小的90%处*/
(CPU_STK_SIZE) SystemDatasBroadcast_STK_SIZE,
(OS_MSG_QTY  ) 0,
(OS_TICK     ) 0,
(void       *) 0,
(OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
(OS_ERR     *) &err);
}

3.2.2 然后在任务函数SystemDatasBroadcast()中开始统计各个任务 (其他任务的代码就不贴了， 跟

SystemDatasBroadcast 创建代码的方法是一模一样的，大家根据自己的需求照葫芦画瓢即可 )的栈使用,代码如下：

void  SystemDatasBroadcast (void *p_arg){
OS_ERR err;
CPU_STK_SIZE free,used;
(void)p_arg;  while(DEF_TRUE)
{
OSTaskStkChk (&SystemDatasBroadcast_TCB,&free,&used,&err); printf("SystemDatasBroadcast  used/free:%d/%d  usage:%%%d\r\n",used,free,(used*100)/(used+free));

OSTaskStkChk (&Core_Page_TCB,&free,&used,&err); printf("Core_Page             used/free:%d/%d  usage:%%%d\r\n",used,free,(used*100)/(used+free));

OSTaskStkChk (&GUIActive_TCB,&free,&used,&err); printf("GUIActive             used/free:%d/%d  usage:%%%d\r\n",used,free,(used*100)/(used+free));

OSTaskStkChk (&KeyCheck_Process_TCB,&free,&used,&err); printf("KeyCheck              used/free:%d/%d  usage:%%%d\r\n",used,free,(used*100)/(used+free));

OSTaskStkChk (&Light_Adjust_TCB,&free,&used,&err); printf("Light_Adjust          used/free:%d/%d  usage:%%%d\r\n",used,free,(used*100)/(used+free));

OSTaskStkChk (&Calibrate_Process_TCB,&free,&used,&err); printf("Calibrate             used/free:%d/%d  usage:%%%d\r\n",used,free,(used*100)/(used+free));


OSTaskStkChk (&Data_Process_TCB,&free,&used,&err); printf("Data_Process          used/free:%d/%d  usage:%%%d\r\n",used,free,(used*100)/(used+free));
printf("\r\n\r\n\r\n");
OSTimeDlyHMSM(0,0,5,0,(OS_OPT)OS_OPT_TIME_DLY,(OS_ERR*)&err);
}
}

3.2.3实验结果

上述代码的实验结果如下图所示，可以清楚的看到每个任务的堆栈的使用状况。

但是请遵循一个原则：必须让系统运行足够久，比如尽量让系统处于不同的运行状态下，然后观察任务堆栈使用的变化，找到堆栈的最高使用率，然后根据上文所说的原则按需重新分配新的任务堆栈大小。

每个任务都有自己的堆栈空间。堆栈必须声明为OS_STK类型，并且由连续的内存空间组成。用户可以静态分配堆栈空间(在编译的时候分配)也可以动态地分配堆栈空间(在运行的时候分配)。静态堆栈声明如程序清单 L4.4和4.5所示，这两种声明应放置在函数的外面。

程序清单 L4.4 静态堆栈

static OS_STK MyTaskStack[stack_size];

或 OS_STK MyTaskStack[stack_size];

用户可以用C编译器提供的malloc()函数来动态地分配堆栈空间，如程序清单 L4.6所示。在动态分配中，用户要时刻注意内存碎片问题。特别是当用户反复地建立和删除任务时，内存堆中可能会出现大量的内存碎片，导致没有足够大的一块连续内存区域可用作任务堆栈，这时malloc()便无法成功地为任务分配堆栈空间。

程序清单 L L4.6 用malloc()为任务分配堆栈空间

OS_STK *pstk;

pstk = (OS_STK *)malloc(stack_size);

If (pstk != (OS_STK *)0) { /* 确认malloc()能得到足够地内存空间 */

Create the task;

}

假如有a b c三个任务，任务优先级a>b>c，由于a优先级最高，故而一开始ucOS会挑a来先运行。
a运行期间，b、c任务都不会被运行，除非a任务主动进行等待(可以是等待：延时、信号、消息等)，a任务调用等待函数时，实际上是把a任务的堆栈给切出去，同时换上次一级的任务b的堆栈环境，然后执行b任务。
任务b执行期间，c任务不能被运行，但若a任务可以抢夺其执行权(在a任务等待结束时)。

故而并非是每一任务按优先级顺序轮流执行的，而是高优先级的任务独占运行，除非其主动放弃执行，否则低优先级任务不能抢占，同时高优先级可以把放出去给低优先级任务使用的CPU占用权抢回来。所以ucos的任务间要注意插入等待延时，以便ucos切出去让低优先级任务执行。