《定时执行专家》软件的一个重要的特点就是能够毫秒级定时执行任务，能够保证误差在50毫秒以内。因为毫秒级的触发要求非常快的时间检测速度，为了能达到这个要求，我们采用了多线程并行处理的方式。

多线程的并行处理主要体现在以下两个功能上：

1、触发器检查线程。检查触发器是否到了触发时间，这里按照触发器类型分成了 11个线程，并发执行；

2、另外是任务执行线程。每个任务的执行都是在新线程里面执行的，各个任务都不存在相互等待。

可以通过“触发器对话框”界面，设置以下四种“秒”级触发条件：

- 倒计时

- 伴随软件启动

- 空闲时间

- 间隔时间

【使用手册】

https://blog.csdn.net/boomworks/article/details/116405931

【下载链接】

TimingExecutor-V5.6-211218.zip

链接：百度网盘 请输入提取码

提取码：boom

// -------------------------------------------------------------------------------------

附：

一、软件简介

《定时执行专家》是一款制作精良、功能全面、使用简单的专业定时执行工具软件。支持 18 种任务类型，11 种任务触发方式（包含 Cron方式），触发精度达到“秒”级。软件无需安装，无使用时间限制，欢迎下载使用。软件使用 Unicode 编码，可以在英文、日文等所有外文 Windows 系统下正常使用，并且软件带有中、日、英多国语言界面版本，可自由切换。

这次版本升级间隔了10多年，在《PC定时执行专家 4.0》的基础上，做了重大升级和更新。重写这个软件，希望这个新版本能在各种应用场景发挥它的作用。

（图1-1，定时执行专家 - 主窗口）

二、适用人群及应用场景

- 每天工作在电脑前面的白领

- IT管理人员

- 系统维护管理人员

- 程序开发人员

- 办公室人员

- 有定时播放需求的学校、机关

- 有定时截屏监控需求的场景

三、软件功能概要

1、支持 18 种任务类型 

1） 日程提醒；2） 打开网址；3） 打开文件夹；4） 打开文件；5） 备份目录；6） 执行DOS命令；7） 执行批处理文件（.bat） ；8） 关闭显示器；9） 清空回收站；10） 锁定此电脑；11） 关机；12） 重启；13） 注销；14） 睡眠；15） 休眠；16） 发送UDP消息；17） 自动截屏（截屏并保存到指定目录）；18） 关闭程序

2、支持 11 种触发方式 

1） 倒计时；2） 随软件启动；3） 空闲时间； 4） 间隔时间；5） 具体时间；6） 每小时；7） 每天；8） 每周；9） 每月；10） 每年；11） Cron方式（Cron界面化设置方式，易于使用，可自行百度Cron表达式了解）

* [注] 前 4 种触发方式，可以指定小时、分钟、秒种，可以精确执行”秒“级的任务。

* [注] 新功能会不断更新，详情请查看作者的博客（软件关于对话框，有博客链接）

【关键字/Keyword】

boomworks PC定时执行专家 定时执行专家 定时执行工具 定时执行 定时关机 自动关机软件 自动关机 关机软件 定时任务管理 定时任务 任务管理 自动截屏 自动屏幕截图 屏幕截图 无察觉截屏 隐身执行 超级网搜 全网搜索 代码统计工具 代码统计分析工具 代码统计 代码分析

// -------------------------------------------------------------------------------------

附：

一、线程池的任务执行机制

任务调度是线程池的主要入口，当用户提交了一个任务，接下来这个任务将如何执行都是由这个阶段决定的。了解这部分就相当于了解了线程池的核心运行机制。

首先，所有任务的调度都是由execute方法完成的，这部分完成的工作是：检查现在线程池的运行状态、运行线程数、运行策略，决定接下来执行的流程，是直接申请线程执行，或是缓冲到队列中执行，亦或是直接拒绝该任务。其执行过程如下：

首先检测线程池运行状态，如果不是RUNNING，则直接拒绝，线程池要保证在RUNNING的状态下执行任务。

如果workerCount < corePoolSize，则创建并启动一个线程来执行新提交的任务。

如果workerCount >= corePoolSize，且线程池内的阻塞队列未满，则将任务添加到该阻塞队列中。

如果workerCount >= corePoolSize && workerCount < maximumPoolSize，且线程池内的阻塞队列已满，则创建并启动一个线程来执行新提交的任务。

如果workerCount >= maximumPoolSize，并且线程池内的阻塞队列已满, 则根据拒绝策略来处理该任务, 默认的处理方式是直接抛异常。

二、软件定时器实现的思路

软件开发中，软件定时器是常用的工具。定时执行特定任务和延时功能，都可以用软件定时器实现。

　　常见的延时函数的实现做法有：

　　1. 使用空指令进行延时，通过控制空指令的执行次数，进行延时。优点：不需要占用系统外设。缺点：系统运行指定个空指令的时间不稳定，中途出现的中断处理会严重影响计时的精确性。

　　2.使用单片机的定时器外设，设定特定的时间产生中断，进行计时。优点：计时准确，不受其他中断影响计时。缺点：浪费单片机外设资源，并且延时处理不能嵌套调用，灵活性不够。

　　这里要介绍的是利用单片机内部的sysTicket 定时器实现的软件定时器。sysTicket timer每毫秒产生一次中断，单片机内有一个无符号类型的32位全局变量msTicket对中断次数进行计数，我们可以认为msTicket

为当前“系统时间”。

　　先介绍相对简单的ms定时器，ms定时器的结构定义如下：

typedef struct
{
    uint16_t start;
    uint32_t value;
}MsSoftTimer;

　　start字段用来表示定时器的开关状态，考虑到字节对齐的问题，用了十六位的类型。如果单片机存储资源紧张，可以不用这个字段。value字段用来保存开始计时时刻系统的时间，也就是msTicket的值。

ms定时器的接口函数如下：

 1 #define        def_ms_tm(tm)    MsSoftTimer tm;
 2 #define        declare_ms_tm(tm)    extern MsSoftTimer tm;
 3 #define        get_ms_tm_val(tm)         _get_ms_tm_val(tm.value)
 4 
 5 #define  start_ms_tm(tm)     do  \
 6 {                         \
 7     tm.start = 1;         \
 8     tm.value = get_msTicks();     \
 9 }while(0)
10 
11 #define  init_ms_tm(tm)     do  \
12 {                         \
13     tm.start = 0;         \
14     tm.value = 0;        \
15 }while(0)
16 
17 #define  is_ms_tm_on(tm)     ( tm.start)
18 #define  stop_ms_tm(tm)     tm.start = 0

定义定时器，本质是就是定义一个定时器类型的变量。可以嵌套调用，如果要在中断处理函数中使用软件定时器，要先将msTicket 中断的优先级设置为最高级别的，并且可以抢占。获取当前的计时时间，就是将当前的“系统时间”，减去定时器开始计时时刻的时间。具体实现如下：

 1 uint32_t _get_ms_tm_val(uint32_t pre_timer_val)
 2 {
 3     uint32_t curr_timer_val = msTicks;
 4     uint32_t ret_timer_val = 0;
 5     
 6     if ( curr_timer_val >= pre_timer_val)
 7     {
 8         ret_timer_val  = curr_timer_val - pre_timer_val;
 9     }
10     else
11     {
12         ret_timer_val = 0xFFFFFFFF - pre_timer_val + curr_timer_val;
13     }
14 
15     return ret_timer_val;
16 }

第12行代码中，对msTicket 变量溢出做了判断和处理。

利于ms软件定时器实现的ms延时函数如下：

void delay_ms(uint32_t ms)
{
    if ( ms == 0) return ;
    def_ms_tm(tm_ms_count);
    start_ms_tm(tm_ms_count);
    while ( get_ms_tm_val(tm_ms_count) < ms)
    ;
    stop_ms_tm(tm_ms_count);
}

us 定时器实现原理跟ms定时器类似，但会稍微复杂一些。us定时利用系统sysTicket 定时器内部的计数值（SysTick Current Value）进行计时。如果系统时钟为20M,每隔1us，SysTick Current Value减少20。

如果系统时钟为48M，每隔1us，SysTick Current Value 减少48。系统sysTicket 定时器结构如下：

1 typedef struct
2 {
3   __IO uint32_t CTRL;                    /*!< Offset: 0x000 (R/W)  SysTick Control and Status Register */
4   __IO uint32_t LOAD;                    /*!< Offset: 0x004 (R/W)  SysTick Reload Value Register       */
5   __IO uint32_t VAL;                     /*!< Offset: 0x008 (R/W)  SysTick Current Value Register      */
6   __I  uint32_t CALIB;                   /*!< Offset: 0x00C (R/ )  SysTick Calibration Register        */
7 } SysTick_Type;

us 定时器的结构体如下：

1 typedef struct 
2 {
3     uint16_t start;
4     uint32_t init_ticket_val;
5     uint32_t init_ms_val;
6 }UsSoftTimer;

init_ticket_val 记录的是开始计时时刻SysTick Current Value的值。init_ms_val 记录的是开始计时时刻msTicket 的值。

us 定时器接口函数实现如下：

 1 void _start_us_sw(USSoftTimer* pTM)
 2 {
 3     pTM->init_ms_val =  msTicks;
 4     pTM->init_ticket_val = SysTick->VAL;
 5     pTM->start = 1;
 6 }
 7 
 8 #pragma O0
 9 uint32_t _get_us_tm_val(USSoftTimer* pTM)
10 {
11     volatile uint32_t curr_ms = msTicks;    
12     volatile uint32_t curr_ticket_val = SysTick->VAL;
13     volatile uint32_t ms_interval = 0;
14     volatile uint32_t sys_clock = SysTick -> LOAD / 1000;
15     volatile uint32_t us_interval = 0;
16     
17     
18     if ( curr_ticket_val > pTM->init_ticket_val)
19     us_interval = ( SysTick->LOAD  - (curr_ticket_val - pTM->init_ticket_val)) / sys_clock;
20     else
21     us_interval = (pTM->init_ticket_val - curr_ticket_val) / sys_clock;
22     
23     if ( curr_ms != pTM->init_ms_val)
24     {
25 
26     if ( curr_ms >= pTM->init_ms_val)
27         ms_interval = curr_ms - pTM->init_ms_val;
28     else
29         ms_interval = 0xFFFFFFFF - pTM->init_ms_val+ curr_ms;
30     
31     if ( curr_ticket_val > pTM->init_ticket_val)
32         ms_interval -= 1;
33 
34     us_interval += ms_interval * 1000;
35 
36     }
37 
38     return us_interval;
39 }
40 
41 #define       def_us_tm(tm)       UsSoftTimer tm 
42 #define       declare_us_tm(tm)   extern    UsSoftTimer tm        
43 #define       get_us_tm_val(tm)    _get_us_tm_val(&tm)
44 #define is_us_tm_on(tm)    (1== tm.start)
45 #define stop_us_tm(tm)    tm.start = 0
46 #define start_us_tm(tm)    _start_us_sw(&tm)

us延时函数的实现如下：

1 void delay_us(uint32_t us)
2 {
3     if ( us <= 1) return ;
4     def_us_tm(tm_us_count);
5     start_us_tm(tm_us_count);
6     while ( get_us_tm_val(tm_us_count) < us)
7     ;
8     stop_us_tm(tm_us_count);
9 }

// END

上一篇文章说的是“软件工程毕设（一）·课题选题表”，今天我们到了要写第二篇文档的时候了，也就是今天的任务书。

接下来就给大家看看任务书的样板，如下所示。
 

任务书样板

可以看出，任务书的样板比之前的课题选题表内容多了很多。不仅是页数上的内容增多，而且需要思考的内容也更多了。比如：参考文献（这个要求非常高，往往到了最后毕设老师扣的就是这个）、项目的设计等。

目前还没到毕业年级的，现在就可以开始慢慢构思自己的项目或是可以积累平时期末自己认为好的项目保存，到了毕业年级继续完善之前的项目，之后这些文档就轻松了。

任务书，样板已经上传，直接下载即可

嵌入式应用软件任务划分的原则

本文主要参考文章“嵌入式应用软件任务划分的原则”，其他见“参考文章部分”。

---

在基于实时操作系统(RTOS，RealTime Operating System)的单片机应用软件设计中，“任务”是一个很重要的概念。对于任务的划分，并没有一个人人都要遵守的规则，不同的人来设计一个同样规格要求的系统，会有不同的方案。本文将在研究划分任务的基础上，从实用的角度给出编写基于RTX51 Tiny实时操作系统的应用软件的指导方针。

任务的概念和应用软件开发过程

• 在嵌入式实时多任务系统开发中，用C语言代码表示的任务是一个无限的循环程序。任务不能有返回，不能有退出出口，但是任务可以被杀死，包括被别的任务杀死或自杀。任务的概念与操作系统中的进程概念相同，一个任务是独立的执行进程，可以与其他的并发任务竞争CPU时间。

• 基于RTOS的单片机应用软件开发过程：首先是根据系统设计方案明确应用软件的功能，然后结合RTOS的并发特性(或准并发特性)，对应用软件要实现的功能进行大小适当的划分，也就是把应用软件的功能按照一定的原则划分为若干个任务模块，并对各个任务间的通信和时延进行仔细的确认。

任务划分的原则

原则1：是将同一个外设的访问放在一个任务中。

对每个独立的硬件(例如串行通信端口)进行操作的驱动程序段放在一个任务中。也就是说，要想对某个设备资源进行操作，只有依靠执行相应的任务来实现。这样无论何时切换任务，都不会对任何独立的“外设”造成影响。

这样做能够避免嵌入式操作系统的特殊问题——资源冲突和重入问题，而且利于系统维护与升级。各个任务之间要实现通信，可以调用os_send_signal函数及全局变量来实现。

所谓“资源冲突”，就是任务A在访问某个资源时，恰好发生了任务切换——由任务A切换到任务B，任务B也访问这个资源且改变了它的状态，这样当再次执行任务A时，就可能发生冲突或带来不确定性。而所谓“重入”，是指假设任务A在运行某个函数，发生任务切换后，任务B也运行这个函数，这样就会破坏任务A执行这个函数时的现场，从而可能导致任务A执行函数时结果不正确。这种问题尤其容易出现在串行接口器件的操作中，例如串口，串行的A/D、D/A器件等。

原则2：是要通过任务分割提高系统的实时性。

在嵌入式多任务实时系统中，任务是指一个程序分段。这个程序分段被操作系统当作一个基本单元来调度。典型地，每个任务都是一个无限的循环。

RTOS本质上就是嵌入的实时内核，它负责管理各个任务，或者说是为每个任务分配CPU时间，并且负责任务之间的通信。实时内核可分为可剥夺型和不可剥夺型两类。因此，按照所使用内核的不同，嵌入式实时系统也可分为两类：使用不可剥夺型内核的嵌入式实时系统和使用可剥夺型内核的嵌入式实时系统。

2.1 长任务的定义

在RTOS中，长任务就是指整个任务的执行时间较长，超出了RTOS中其他某一个或某几个任务的实时要求容限，而对整个RTOS的实时性构成威胁的那些任务。需要注意的是，长任务与复杂任务不能混淆，复杂任务的执行时间不一定长，简单任务也可能会构成长任务。

2.2 长任务对RTOS的影响

当使用可剥夺型实时内核时，长任务由于执行的时间较长，因而更容易被高优先级的任务打断；一旦高优先级的任务进入了就绪状态，当前任务的CPU使用权就被剥夺了，或者说任务被挂起了，那个高优先级的任务立刻得到了CPU的控制权。这样会出现两个问题：一是长任务可能在一次执行的过程中被频繁打断，长时间得不到一次完整的执行；二是长任务被打断时，可能要保存大量的现场信息，其目的是为了保证在高优先级任务执行完返回后，长任务能得以继续执行。然而，这样做要占用一定的系统资源，同时保存现场本身也是要占用CPU时间的，因此，实时性也会下降。

当使用不可剥夺型实时内核时，长任务对RTOS的影响更为明显，因为在这种内核中，任务的响应时间取决于最长的任务执行时间。也就是说，由于长任务的存在，任务的响应时间要变长。其结果是CPU长时间停留在长任务中，其他任务得不到实时的响应，甚至根本得不到执行，系统的实时性势必要下降。

总之，无论是使用可剥夺型内核，还是使用不可剥夺型内核，长任务都会对RTOS构成严重的威胁。

2.3 长任务问题的解决方法

解决长任务问题最有效的途径是进行任务分割。所谓“任务分割”是指将影响系统实时性的长任务分割成若干个小任务。这样单个任务的执行时间变短，系统的任务响应时间变短，实时性得以提高。

（1） 对任务的分析与计算

当然，长任务的分割必须结合系统中所使用的内核，以及各任务对实时性的要求等情况，进行必要的分析与计算，才能保证分割的合理性和有效性，具体的步骤如下。

• ① 分析系统共有多少个任务，这些任务对实时性的要求有多高，求出各个任务所要求的最低执行频率(f1，f2，…，fn)。
• ② 计算目前各任务的实际执行时间(t1，t2，…，tn)。
• ③ 确定系统中的长任务。如果max(t1，t2，…，tn) ≤ min(1/f1，1/f2，…，1/fn)，则此系统中不存在长任务。如果max(t1，t2，…，tn)＞min(1/f1，1/f2，…，1/fn)，则存在长任务，而且执行时间为max(t1，t2，…，tn)的那个任务就是要找的长任务。
• ④ 分析此长任务是否需要分割，分析一下是什么原因导致执行的时间过长，这个时间是否能够通过程序的优化来缩短？如果能，则不需要进行任务分割；否则，要对这个长任务进行分割。

（2） 实施长任务分割

常用的任务分割的方法有以下两种：

• ① 将长任务按功能分为若干个小模块，每一个模块构成一个小任务，每个小任务实现一种相对独立的功能，且要保证执行时间t

• ② 有的长任务比较特殊，例如键盘任务和动态LED数码管显示任务，很难按照上面的方法把它分成若干个功能相对独立的小模块。这时，一般是按照方便保存现场信息的原则，将其强制分割成若干个小任务，每个小任务在min(1/f1，1/f2，…，1/fn) 时间内主动保存现场信息、放弃CPU的控制权，等到再次被内核调度时继续执行。这种分割方法相对而言较复杂，各任务之间界限不是很明显，看似未经分割，但实际上它却是由多次任务中断来完成的。

原则3：是要将软件工程中的“解耦原则”用于任务划分。

可以采用软件工程中的解耦原则对应用程序进行任务的划分。任务之间的耦合是影响软件复杂程度的一个重要因素，应该采取下述设计原则：尽量使用数据耦合，少用控制耦合和特征耦合，限制公共环境耦合的范围，完全不用内容耦合。具体方法可参见软件工程方面的书籍，例如文献[3]。

基于RTX51 Tiny的应用软件设计指导

RTX51是一个德国Keil Software公司开发的用于8051系列单片机的多任务实时操作系统。RTX51有2个不同的版本。

• （1） 完全版RTX51 Full
  完全版RTX51 Full允许4个优先级的任务时间片轮转调度和抢先式的任务切换，可以并行地利用中断功能。信号和信息可以通过邮箱系统在任务之间互相传递，可以从一个存储池中分配和释放内存，可以强迫一个任务等待中断、超时以及从另一个任务或中断发出的信号或信息。
• （2） 小型版RTX51 Tiny
  小型版RTX51 Tiny是RTX51的一个子集，它可以很容易地在没有任何外部存储器的单片8051系统上运行。RTX51 Tiny仅支持时间片轮转任务切换和使用信号进行任务切换，不支持抢先式的任务切换，可以并行地利用中断功能，可以强迫一个任务等待中断、超时以及从另一个任务或中断发出的信号，不能进行信息处理，也不支持存储器分配或释放。RTX51 Tiny是一种不可剥夺型实时操作系统内核。

基于RTX51 Tiny实时操作系统的单片机应用软件设计，首先应该根据RTX51 Tiny操作系统的准并发特性，对应用软件要实现的功能进行大小适当的划分——按照上述3个原则划分为若干个任务模块，并对各个任务间的通信和时延进行仔细的确认。

编写基于RTX51 Tiny的应用软件的指导方针如下：

• ① 包含头文件rtx51tny.h在应用程序中。
• ② 不要写C语言主函数main()。RTX51 Tiny操作系统内核中已经有它自己的主函数main()。
• ③ 应用程序应该至少包括1个任务函数(task function)。
• ④ RTX51 Tiny应用程序必须中断使能(EA=1)，因为RTX51 Tiny操作系统使用了定时器T0中断。
• ⑤ 应用程序至少调用1个RTX51 Tiny系统函数(如os_wait)；否则，链接器将不会把RTX51 Tiny的系统库包含到应用程序中。
• ⑥ 任务task0是应用程序中第一个执行的函数。在任务task 0中，必须调用os_create_task函数来运行其他任务。
• ⑦ 任务task函数不必退出或返回。任务task必须使用一个while(1)结构或其他类似的结构。任务task函数不带参数，也没有返回值。使用系统函数os_delete_task挂起(halt)一个运行的任务。
• ⑧ 中断服务程序的编写方式，与不使用RTX51 Tiny操作系统下的编写方式相同。
• ⑨ 编译和链接应用程序有2种途径，一种是使用集成开发环境μVision 2 IDE，另一种是使用命令行工具CommandLine Tools。一般采用德国Keil Software公司提供的集成开发环境 μVision 2 IDE。

其他的一些多任务划分方法与原则

任务划分要根据任务的特点和性质

任务的划分好坏直接关系到系统的设计的成败，往往好的任务划分，能够使设计更简单，任务多了，资源开销多，增加了任务之间的同步及频繁切换的开销，任务少了，可以减少共享资源的数量，降低了任务之间切换及同步的开销，不利于业务逻辑的并发调用。

• 1、设备依赖性原则：无论是通信、采集或是控制类任务都对设备具有不同程度的依赖性，同时因为外部设备的特点不同将导致任务的属性也发生变化，比如通信任务一般情况下外部设备的运行速率比主控芯片较低，所以在任务的执行周期，和任务的运行时间需要调整。“输入输出设备的速度差别是任务“并发运行的基础”“。所以通常将不同输入输出设备划分为不同的任务独立运行，也就是以CPU为中心，将和IO口相关的功能划分成若干个独立的任务。
• 2、关键任务：关键性（必须得到运行机会，即使遗漏执行一次也不行），一个系统中必有其关键功能，可以是一个也可以是多个，对于关键性任务划分的原则是使其功能独立，优先级较高，通过信号量或则消息与其他人物进行通信，简化关键任务的体积，尽可能的与其他任务剥离。一般将关键任务交给一个独立的高优先级任务或者ISR来执行，剩余的部分交给另外一个任务去实现，两者之间通过通讯机制来实现。
• 3、紧迫任务：紧迫性：是指一些具有较高的实时性要求的任务，必须在规定的时间内得到运行权，具有严格地执行周期。大多数紧迫任务都由异步事件触发，这些异步事件一般能够引发某种中断，所以将任务安排在ISR中较为合适。一般将紧迫功能分离出来，交给一个独立的任务或者ISR来执行，剩余的部分交给另外一个任务去实现，两者之间通过通讯机制来实现沟通。对于既“关键”又“紧迫”的任务，按紧迫任务去执行。
• 4、数据处理任务：通常一个系统必定会有大量的数据计算，这种数据计算通常会耗费大量的CPU时间，所以处理不当将会严重影响其他任务的实时性，比如如果一个任务具有较高的优先级，而且任务重含有大量的数据计算模块，将会长时间的占有CPU，严重影响其他任务的运行。通常将消耗较大的数据处理部分分离出来交给一个较低的优先级任务实现。
• 5、功能聚合任务：功能密切的任务封装为一个任务，达到功能聚合的效果，这样也会减少任务之间的同步过程，节省通信时间，功能密切一般分为数据关系密切和时序关系密切。
• 6、同等触发任务：触发条件相同的任务划分为一个任务，从而免除事件分发机制带来的额外系统开销。
• 7、将周期相同的功能组合在一起封装成一个任务，就可以避免一个时间事件触发几个任务，省去“事件分发”的操作与他们之间通信。
• 8、将若干按固定顺序执行的功能组合成为一个任务，从而免除同步接力通讯的麻烦。一般这些功能按固定顺序进行流水作业，相互之间完全没有并发性，则应该将这些功能组合为一个任务。这样一来也可以减少任务之间的同步过程。

任务优先级按照任务类型进行安排

1、中断关联性：与中断服务程序（ISR）相关的任务应该安排尽可能高的优先级，这样有利于处理异步时间提高系统的实时性，如果优先级设置的较低，则可能发生由于cpu一直被高优先级的任务霸占，导致在第二次发生中断时还没来的及处理上一次中断发生的事件！导致信号的丢失！
2、紧迫性：紧迫任务要求在规定的时间内完成，有很强的时间关联性，对时间要求较严，在安排紧迫任务的优先级的时候要按照紧迫程度将任务进行划分，越紧迫的任务优先级越高，一般来说，紧迫任务与ISR关联。
3、关键性：任务越关键，优先级越高，道理很简单，如果关键任务安排较低的优先级将不能获得更多的执行机会，导致关键人物得不到执行！关键性就荡然无存！
4、频繁性：越频繁的任务（周期越短）优先级应该设置的越高，以便及时得到执行。
5、快捷性：前面的条件相同相近时，越是快捷的任务优先级越高，这样避免后面的就绪任务延时短。
6、传递性：信息传递的上游任务优先级高于下游任务的优先级。如：信息采集任务的优先级要高于信息处理的优先级

举例说明优先级安排的：
在一个实际项目价值中，模拟信号采集任务，串口接收任务，串口发送任务，键盘监听任务，显示任务。下面分析一下：

模拟信号采集任务、串口发送任务、串口接收任务与ISR有关.
其中串口接收任务是关键任务也是紧迫任务，对实时性要求最高.
模拟信号采集任务是紧迫任务而不是关键任务，因为丢失一次信号的采集还不至于造成严重的后果。
串口任务cpu是主动方，优先级安排低点也可以，只要将数据发送出去就可以。
键盘监听任务和显示任务对实时性要求较低。
数据处理任务视计算量而定，如果计算量较小可以安排在键盘监听之前，因为它比较便捷。反之安排其后。

这样我们可以这样设定：

任务	优先级
串口接收任务	4
模拟信号采集任务	6
串口发送任务	8
数据处理任务	10
按键监听任务	12
显示任务	14

这样可以 #define OS_LOWEST_PRIO 18，优先级安排比较宽松的好处就是方便后续升级，添加任务不需要修改其他部分。

丢中断考量方法

假设所有指令都是单指令周期的，这样1个指令周期就对应一条指令，假设每条指令都是 2 个字节大小（16 位指令）。1ms 时间内 1MHz 的系统可以运行大约 2KB 的代码，一个 12MHz 的系统可以运行 24KB 的代码。在 1MHz 的系统中对于一个1KHz的毫秒中断，中断处理程序越接近 2KB，就说明系统越可能“丢中断“。

我们来看一个实例：评估一个 10KHz 的外中断，中断处理程序允许的理论最大安全尺寸是多少？
1、首先，我们要搞清楚系统的指令大小和指令集的周期数情况。以 ARM Cortex M3 为例，其指令大部分为单周期指令，支持 16 位指令和 32 位指令。为了评估中断处理程序的尺寸上线，可以分别以16 位指令和 32 位指令为基础计算出两个结果作为参考范围。
2、其次，我们要搞清楚系统频率。假设系统频率为 72MHz，已知 10KHz 等效于 100us，则中断处理
程序的理论最大尺寸范围是（72 * 100 * 2）字节到（72 * 100 * 4）字节，即 14.4KB 到 28.8K 之间。取最小值 14.4KB。
结论，中断处理程序及其调用的子函数，其尺寸总和至少要小于 14.4KB 才能确保 10KHz 的中断得到及时的响应。由于未考虑循环、分支以及其它任务的存在，以上结果仅用于粗略的快速评估，实际代码通常应该远小于这一上线值。当实际尺寸接近或者超过 14.4KB 时基本可以判定系统无法及时稳定的响应中断。

参考文章：

1、基于嵌入式操作系统的实时性多任务划分方法
2、基于嵌入式OS的任务设计-----任务划分
3、嵌入式系统任务优先级安排原则
4、玩转嵌入式多任务程序设计笔记三
5、嵌入式应用软件任务划分的原则