μC/OS-II 的任务调度算法扩展之两种任务数扩充

最新推荐文章于 2023-10-26 21:32:45 发布
原创 最新推荐文章于 2023-10-26 21:32:45 发布 · 2.1k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#uCOS-II #任务调度 #任务数扩展

本文介绍μC/OS-II任务调度算法，并提供两种任务数扩展方案：一种支持512个任务，通过增加OSRdyGrpY[]和OSRdyTbl[][]实现；另一种支持128个任务，通过改变OSRdyGrp类型和OSRdyTbl[]长度实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

关于μC/OS-II原任务调度算法猛戳此处。

μC/OS-II 只支持64个任务（2.52），下面采用两种方法来对其支持的最大任务数进行扩充，第一个支持512个任务，（可以扩展到4096）但是需要额外的如下表的空间；第二种扩展方法支持128个任务，其实还可以扩展到256，但是按此种方法扩展并不优雅，所以只实现了128任务的方法。在看完以上的基础上，再单步调试下面的代码，应该比较容易理解了。
当然，我晓得2.86支持256个任务（找个时间看下，它到底咋整的），μC/OS-III支持无限多个（看了下，原作者将任务调度算法简单化了，取消了OSMapTbl和OSUnMapTbl，直接从最小开始往上走，碰到最小的就为最高优先级，这个对任务的设置有点小要求，当然对任务的三个操作中，最后一个：取最高优先级的时间复杂度也就不是O(1)了，不过我猜原作者应该是做过大量实验的，对实时性的影响应该不太明显）。

本文将原版，改进版1，改进版2都从μC/OS-II中独立出来进行调试，只关心最最核心的部分，当然，如果想要真正的用起来，还需要修改一些杂七杂八的，这里就不讲了，可以参考cnki的一篇小论文《uC/OS-Ⅱ任务数扩充的理论与实现》，一个老工程师写的，很“真”，里面都是“干货”。

直接上代码。

先看原版先：
 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#include <stdio.h>
typedef  unsigned  char  INT8U;           /* Unsigned  8 bit quantity       */ 

INT8U            OSRdyGrp;
INT8U            OSRdyTbl[ 8];                       //即将要运行的任务列表
//OSMapTbl[]：就绪任务表；对应OSRdyGrp和OSRbyTbl[i]的位值(0~7)
INT8U   const  OSMapTbl[]   = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};

//*******************************************************************************************************
//最高优先级任务查找表(PRIORITY RESOLUTION TABLE)
//注意: 变址索引表是位模式，找出就绪态最高优先级别任务，给定值应符合高优先级位位值(0~7)
//OSUnMapTbl[]：最高优先级任务查找表；对应OSRdy Grp和OSRbyTbl[i]的位值(0~7)
INT8U   const  OSUnMapTbl[] = {
     0,  0,  1,  0,  2,  0,  1,  0,  3,  0,  1,  0,  2,  0,  1,  0,        /* 0x00 to 0x0F                             */
     4,  0,  1,  0,  2,  0,  1,  0,  3,  0,  1,  0,  2,  0,  1,  0,        /* 0x10 to 0x1F                             */
     5,  0,  1,  0,  2,  0,  1,  0,  3,  0,  1,  0,  2,  0,  1,  0,        /* 0x20 to 0x2F                             */
     4,  0,  1,  0,  2,  0,  1,  0,  3,  0,  1,  0,  2,  0,  1,  0,        /* 0x30 to 0x3F                             */
     6,  0,  1,  0,  2,  0,  1,  0,  3,  0,  1,  0,  2,  0,  1,  0,        /* 0x40 to 0x4F                             */
     4,  0,  1,  0,  2,  0,  1,  0,  3,  0,  1,  0,  2,  0,  1,  0,        /* 0x50 to 0x5F                             */
     5,  0,  1,  0,  2,  0,  1,  0,  3,  0,  1,  0,  2,  0,  1,  0,        /* 0x60 to 0x6F                             */
     4,  0,  1,  0,  2,  0,  1,  0,  3,  0,  1,  0,  2,  0,  1,  0,        /* 0x70 to 0x7F                             */
     7,  0,  1,  0,  2,  0,  1,  0,  3,  0,  1,  0,  2,  0,  1,  0,        /* 0x80 to 0x8F                             */
     4,  0,  1,  0,  2,  0,  1,  0,  3,  0,  1,  0,  2,  0,  1,  0,        /* 0x90 to 0x9F                             */
     5,  0,  1,  0,  2,  0,  1,  0,  3,  0,  1,  0,  2,  0,  1,  0,        /* 0xA0 to 0xAF                             */
     4,  0,  1,  0,  2,  0,  1,  0,  3,  0,  1,  0,  2,  0,  1,  0,        /* 0xB0 to 0xBF                             */
     6,  0,  1,  0,  2,  0,  1,  0,  3,  0,  1,  0,  2,  0,  1,  0,        /* 0xC0 to 0xCF                             */
     4,  0,  1,  0,  2,  0,  1,  0,  3,  0,  1,  0,  2,  0,  1,  0,        /* 0xD0 to 0xDF                             */
     5,  0,  1,  0,  2,  0,  1,  0,  3,  0,  1,  0,  2,  0,  1,  0,        /* 0xE0 to 0xEF                             */
     4,  0,  1,  0,  2,  0,  1,  0,  3,  0,  1,  0,  2,  0,  1,  0         /* 0xF0 to 0xFF                             */
};


int main( void)
{   
    INT8U x,y;
    INT8U prio;

     //使任务进入就绪状态
    prio =  5;
    OSRdyGrp |= OSMapTbl[prio >>  3];
    OSRdyTbl[prio >> 3] |= OSMapTbl[prio & 0x07];

    prio =  15;
    OSRdyGrp |= OSMapTbl[prio >>  3];
    OSRdyTbl[prio >> 3] |= OSMapTbl[prio & 0x07];

    prio =  25;
    OSRdyGrp |= OSMapTbl[prio >>  3];
    OSRdyTbl[prio >> 3] |= OSMapTbl[prio & 0x07];

    prio =  35;
    OSRdyGrp |= OSMapTbl[prio >>  3];
    OSRdyTbl[prio >> 3] |= OSMapTbl[prio & 0x07];

    prio =  45;
    OSRdyGrp |= OSMapTbl[prio >>  3];
    OSRdyTbl[prio >> 3] |= OSMapTbl[prio & 0x07];

    prio =  5;
     //使任务脱离就绪状态
     if((OSRdyTbl[prio >>  3] &= ~OSMapTbl[prio & 0x07]) ==  0)
        OSRdyGrp &= ~OSMapTbl[prio >>  3];

    y    = OSUnMapTbl[OSRdyGrp];
    x    = OSUnMapTbl[OSRdyTbl[y]];
    prio = (y <<  3) + x;
 

    printf( "High Priority = %d \n",prio);
    printf( "x = %d \n",x);
    printf( "y = %d \n",y);

    getchar();
     return  0;
}




再看改进版1：

支持的任务数 额外开辟的内存空间
原版：64 256-OSUnMapTbl[256]+8-OSMapTbl[]+1-OSRdyGrp
512 256-OSUnMapTbl[256]+8-OSMapTbl[]+1-OSRdyGrpX+8-OSRdyGrpY8[]
4096 256-OSUnMapTbl[256]+8-OSMapTbl[]+1-OSRdyGrpX+8-OSRdyGrpY[8]+64-OSRdyGrpZ[8][8]
此方法需要额外的空间来换取时间，换取的比率大致是64倍（抛去固定项，即在原版本的基础之上的空间），即如果要支持512个任务，则需要额外8byte的字节空间；如果要支持4096个任务，则需要额外64个byte的空间。
而且必须8倍8倍的张，原因是此方法是在维度上面的扩充，原版本相当于2维空间，此处为3维空间，当然还可以在扩，但是实现比较复杂。
 支持512个任务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include <stdio.h>

typedef unsigned char  INT8U;           /* Unsigned  8 bit quantity       */

INT8U             OSRdyGrpX;
INT8U             OSRdyGrpY[8]; 
INT8U             OSRdyTbl[8][8];                       //即将要运行的任务列表

//OSMapTbl[]：就绪任务表；对应OSRdyGrp和OSRbyTbl[i]的位值(0~7)
INT8U  const  OSMapTbl[]   = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};

//*******************************************************************************************************
//最高优先级任务查找表(PRIORITY RESOLUTION TABLE)
//注意: 变址索引表是位模式，找出就绪态最高优先级别任务，给定值应符合高优先级位位值(0~7)

//OSUnMapTbl[]：最高优先级任务查找表；对应OSRdy Grp和OSRbyTbl[i]的位值(0~7)
INT8U  const  OSUnMapTbl[] = {
    0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x00 to 0x0F                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x10 to 0x1F                             */
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x20 to 0x2F                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x30 to 0x3F                             */
    6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x40 to 0x4F                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x50 to 0x5F                             */
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x60 to 0x6F                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x70 to 0x7F                             */
    7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x80 to 0x8F                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x90 to 0x9F                             */
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xA0 to 0xAF                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xB0 to 0xBF                             */
    6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xC0 to 0xCF                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xD0 to 0xDF                             */
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xE0 to 0xEF                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0        /* 0xF0 to 0xFF                             */
};

#define t1 (prio >> 6)
#define t2 ((prio >> 3) & 0x07)
#define t3 (prio & 0x07)

int main(void)
{   
    INT8U x,y,z;
    int prio;

    //使任务进入就绪状态
    prio = 257;
    OSRdyGrpX |= OSMapTbl[t1];
    OSRdyGrpY[t1] |= OSMapTbl[t2];
    OSRdyTbl[t1][t2] |= OSMapTbl[t3];
    
    prio = 113;
    OSRdyGrpX |= OSMapTbl[t1];
    OSRdyGrpY[t1] |= OSMapTbl[t2];
    OSRdyTbl[t1][t2] |= OSMapTbl[t3];

    prio = 14;
    OSRdyGrpX |= OSMapTbl[t1];
    OSRdyGrpY[t1] |= OSMapTbl[t2];
    OSRdyTbl[t1][t2] |= OSMapTbl[t3];

    prio = 11;
    OSRdyGrpX |= OSMapTbl[t1];
    OSRdyGrpY[t1] |= OSMapTbl[t2];
    OSRdyTbl[t1][t2] |= OSMapTbl[t3];

    prio = 11;
    //使任务脱离就绪状态
    if((OSRdyTbl[t1][t2] &= ~OSMapTbl[t3]) == 0)
    {
        OSRdyGrpY[t2] &= ~OSMapTbl[t2];
        if((OSRdyGrpY[t1] &= ~OSMapTbl[t2]) == 0)
            OSRdyGrpX &= ~OSMapTbl[t1];
    }

    z = OSUnMapTbl[OSRdyGrpX];
    y = OSUnMapTbl[OSRdyGrpY[z]];
    x = OSUnMapTbl[OSRdyTbl[z][y]];
    prio = (z<<6)+(y<<3) + x;
    
    printf("High Priority = %d \n",prio);
    printf("x = %d \n",x);
    printf("y = %d \n",y);
    printf("z = %d \n",z);
    getchar();
    return 0;
}



再再看改进版2：

此方法为线性扩张，需要修改OSRdyGrp的类型和OSRdyTbl[]的长度，每增加64个任务，就增加一个判断分支，需要的额外空间没有改进版1多，实现较简单，但是扩张速度没有改进版1来得快，是线性的。
 支持128个任务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#include <stdio.h>
typedef unsigned char  INT8U;          /* Unsigned  8 bit quantity       */ 
typedef unsigned short  INT16U;

INT16U            OSRdyGrp;
INT8U            OSRdyTbl[16];                      //即将要运行的任务列表

//OSMapTbl[]：就绪任务表；对应OSRdyGrp和OSRbyTbl[i]的位值(0~7)
INT16U  const  OSMapTbl[]   = { 0x0001, 0x0002, 0x0004, 0x0008,
                                0x0010, 0x0020, 0x0040, 0x0080,
                                0x0100, 0x0200, 0x0400, 0x0800,
                                0x1000, 0x2000, 0x4000, 0x8000};

//*******************************************************************************************************
//最高优先级任务查找表(PRIORITY RESOLUTION TABLE)
//注意: 变址索引表是位模式，找出就绪态最高优先级别任务，给定值应符合高优先级位位值(0~7)

//OSUnMapTbl[]：最高优先级任务查找表；对应OSRdy Grp和OSRbyTbl[i]的位值(0~7)
INT8U  const  OSUnMapTbl[] = {
    0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x00 to 0x0F                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x10 to 0x1F                             */
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x20 to 0x2F                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x30 to 0x3F                             */
    6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x40 to 0x4F                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x50 to 0x5F                             */
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x60 to 0x6F                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x70 to 0x7F                             */
    7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x80 to 0x8F                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0x90 to 0x9F                             */
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xA0 to 0xAF                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xB0 to 0xBF                             */
    6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xC0 to 0xCF                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xD0 to 0xDF                             */
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,       /* 0xE0 to 0xEF                             */
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0        /* 0xF0 to 0xFF                             */
};


int main(void)
{   
    INT8U x,y;
    INT8U prio;

    //使任务进入就绪状态
    prio = 5;
    OSRdyGrp |= OSMapTbl[prio >> 3];
    OSRdyTbl[prio >>3] |= OSMapTbl[prio & 0x07];

    prio = 100;
    OSRdyGrp |= OSMapTbl[prio >> 3];
    OSRdyTbl[prio >>3] |= OSMapTbl[prio & 0x07];

    prio = 111;
    OSRdyGrp |= OSMapTbl[prio >> 3];
    OSRdyTbl[prio >>3] |= OSMapTbl[prio & 0x07];

    prio = 120;
    OSRdyGrp |= OSMapTbl[prio >> 3];
    OSRdyTbl[prio >>3] |= OSMapTbl[prio & 0x07];

    prio = 125;
    OSRdyGrp |= OSMapTbl[prio >> 3];
    OSRdyTbl[prio >>3] |= OSMapTbl[prio & 0x07];

    prio = 5;
    //使任务脱离就绪状态
    if((OSRdyTbl[prio >> 3] &= ~OSMapTbl[prio & 0x07]) == 0)
        OSRdyGrp &= ~OSMapTbl[prio >> 3];
    
    if((OSRdyGrp & 0xff) != 0)
    {
        y    = OSUnMapTbl[OSRdyGrp & 0xff];
        x    = OSUnMapTbl[OSRdyTbl[y]];
        prio = (y << 3) + x;
    }
    else
    {
        y    = OSUnMapTbl[OSRdyGrp >> 8];
        x    = OSUnMapTbl[OSRdyTbl[y + 8]];
        prio = 64 + (y << 3) + x;
    }

    printf("High Priority = %d \n",prio);
    printf("x = %d \n",x);
    printf("y = %d \n",y);

    getchar();
    return 0;
}




鱼与熊掌不可兼得。


OS01- OS模块概述【任务类型和一致性类】
12-10 2080
文章目录1 多任务系统2 任务类型和一致性类2.1 基本任务2.2 扩展任务2.3 一致性类 1 多任务系统 一个大型的工程通常会划分为一些独立的子系统程序，已完成各自的功能任务，以便于管理和开发。这些独立程序在执行时都称为任务。 任务的结构： 1 代码和数据(任务专属访问)。 2 独立上下文（维护任务的状态和控制信息）。 3 共享资源（资源根据分配的特权，可供允许的任务访问）。 OS内核提供了多任务运行的环境，根据调度算法让多任务进行轮流并行的执行，以快速响应多个离散的事件。 2 任务类型和一致性类
μC/OS-II 的任务调度算法分析
fovwin的专栏
08-06 5670
任务调度是一个操作系统最核心的部分，μC/OS-II 通过三步走来完成这个过程。 1) 从就绪表中获得就绪任务的最高优先级：OSRdyTbl[]，OSRdyGrp，OSMapTbl[]，OSUnMapTbl[] 2) 获取最高优先级就绪任务的任务控制块：OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy] 3) 启动任务切换：OS_TASK_SW()
μC/OS II 任务调度详解（一）
fanwenjieok的专栏
11-07 1962
      UC/OS II 是一个多任务操作系统，从宏观角度来看，当前系统中可以有多个任务同时运行；但从微观角度来看，某一个时刻只能有一个任务处于运行状态（单CPU情况，事实上在单核时是不存在多任务的），所有其它任务都处于其他状态，这些任务在什么时候，哪种情况下进行状态切换，是由该任伤自身的属性和操作系统调度算法来决定的。     当一个正在执行的任务因某个事件发生需要转入其他状态时，需要停止该任务的运行，转而执行其它的任务（或中断），此时就需要操作系统执行调度功能。因此，调度是指操作系统在管理多任务时选
【算法分析】μC/OS的任务调度算法分析
HaoBBNuanMM的博客
12-31 582
目录   RTOS调度算法 基础数据结构 调度算法 RTOS调度算法 μC/OS是RTOS系统，它的任务调度算法可以在O(1)的时间复杂度中完成如下的工作，本文着重分析该算法的实现原理 当Task Ready，标记Task为Ready状态 当Task sleep或者block，清除Task Ready状态 当要调度Task执行，寻找最高优先级并且Ready状态的Task作为调度对...
μC-OSⅡ操作系统任务调度
weixin_43394977的博客
09-05 421
如何描述一个task 代码描述 把内部的固定执⾏函数来看，task就是⼀个执⾏的函数，⼀个⽆限循环的void函数 • 为什么是⽆限循环？ 因为⼀个任务要在系统当中不断地调度，⽽不是⽤⼀次就废了 • 为什么返回void，task是独⽴存在的，不需要为其他task做什么（即便需要也是共享或者通信） 下⾯我们通过代码进程块来了解⼀下task进程块在计算机当中的使⽤（调度）⽅法。 上⾯两段代码分别是两个task的代码。在循环外的代码主要⽬的是设置时钟节拍（晶体振荡器），剩下⼏个是寻找对应的引脚来控制指定引脚灯
μC/OS-II操作系统中的任务
qq_46337496的博客
04-04 1766
任务的基本概念（任务及其种类） 1.任务和任务的控制块 我们在做一件事时，可以把这件事看成一个任务，然后将这个任务分成多个小任务，去处理这些小的任务，最终将一件事做成。对于uC/OS-II来说，它就是一个能够对这些小任务进行调度和管理，然后通过并发的方式去处理这些小任务的操作系统。 什么是并发方式呢？？ 对于一个计算机或者特别是在嵌入式操作系统中来说，处理器的数目通常只有一个，但是任务的数量远远大...
μC/OS-II 源码阅读笔记 —— 内核深度剖析
wangshixu0633的专栏
03-16 779
该笔记并非源代码的详细讲解，亦非μC/OS-II的使用说明，而是汇总了阅读源码过程中产生的疑问及解答，进而从中归纳总结出μC/OS-II系统的内在机理，对于想从本质和源头探索操作系统的程序猿或许有点参考帮助，或许能够启发更优质的使用μC/OS-II的方法，甚者若能就实际情况来优化μC/OS-II的内核以提高软件的质量则更当令此文欣慰了。
新版uC/OS-II操作系统发布，功能增强与bug修复
μC/OS-II的调度算法负责决定哪个任务在何时获得CPU的使用权。它必须保证即使在多个任务竞争CPU资源时，每个任务也能及时得到执行，这对于满足实时性要求至关重要。μC/OS-II的调度算法是基于优先级的，最新的版本...
STM32F103C8T6基于HAL库移植uC/OS-III实现多任务
qq_52340288的博客
11-03 1388
学习嵌入式实时操作系统（RTOS）,以uc/OS为例，将其移植到stm32F103上，构建至少3个任务（task）:其中两个task分别以1s和3s周期对LED灯进行点亮-熄灭的控制；另外一个task以2s周期通过串口发送“hello uc/OS”。记录详细的移植过程。
UCOS操作系统时间片轮转调度功能扩充
文档“ucos_time.rar_ucos_ucos 扩充优_ucos-ii_ucos优先级抢占”和包含的“4UCOS时间片轮转调度算法详解.pdf”文件，主要描述了μC/OS操作系统及其调度策略的改进，具体为通过时间片轮转调度算法为同优先级任务的...
请根据我给的格式，使用markdown格式生成一篇文章，用于发布在csdn上面，主要目的是为了获取更多粉丝和浏览量，要求内容详细，易懂，并提供示例，回答不能太简单，示例如下：第 1 章 计算机系统概述 1.1 操作系统的基本概念 1.1.1 操作系统的概念、功能和目标（系统资源的管理者、提供接口、作为扩充机器、虚拟机） 1.1.2 操作系统的特征（并发、共享、虚拟、异步） 1.2 操作系统的发展和分类 1.2.1 操作系统的发展和分类（手工、单道/多道批处理、分时、实时、网络、分布式、嵌入式、个人计算机） 1.3 操作系统的运行机制和体系结构 1.3.1 操作系统的运行机制和体系结构（大内核、小内核） 1.3.2 中断和异常（内中断和外中断、中断处理过程） 1.3.3 系统调用（执行过程、访管指令、库函数与系统调用） 1.0.0 第一章操作系统概述错题整理 第 2 章 进程管理 2.1 进程与线程 2.1.1 进程的定义、特征、组成、组织 2.1.2 进程的状态（运行、就绪、阻塞、创建、终止）及转换（就绪->运行、运行->就绪、运行->阻塞、阻塞->就绪） 2.1.3 原语实现对进程的控制 2.1.4 进程之间的通信（共享通信、消息传递、管道通信） 2.1.5 线程概念与多线程模型 2.2 处理机的调度 2.2.1 处理机调度的概念及层次 2.2.2 进程调度的时机（主动放弃与被动放弃）、切换与过程（广义与狭义）、方式（非剥夺与剥夺） 2.2.3 度算法的评价指标（cpu利用率、系统吞吐量、周转时间、等待时间、响应时间） 2.2.4 作业/进程调度算法（FCFS先来先服务、SJF短作业优先、HRRN高响应比优先） 2.2.5 作业/进程调度算法（时间片轮转调度算法、优先级调度算法、多级反馈队列调度算法） 2.3 进程的同步与互斥 2.3.1 进程的同步与互斥 2.3.2 实现临界区进程互斥的软件实现方法 2.3.3 实现临界区进程互斥的硬件实现方法 2.3.4 信号量机制（整型信号量、记录型信号量P、V） 2.3.5 信号量机制实现进程的互斥、同步与前驱关系 2.3.6 进程同步与互斥经典问题（生产者-消费者问题、多生产者-多消费者问题、吸烟者问题、读者-写者问题、哲学家进餐问题） 2.3.7 管程和java中实现管程的机制 2.4 死锁 2.4.1 死锁详解(预防、避免、检测、解除)
最新发布
03-11
> 思考题：在多核CPU环境下，传统调度算法需要做哪些改进？ 3. **内容传播**： - 添加`#操作系统考研#`、`#校招面试#`等话题标签 - 建议读者"关注合集"获取后续更新通知 **数据支持**： - 优快云统计显示含代码...
操作系统OS - 常见系统的调度算法
anchenhe9360的博客
04-22 182
https://en.wikipedia.org/wiki/Scheduling_(computing) 在wiki的下面可以找到 转载于:https://www.cnblogs.com/allen2333/p/8904618.html
Autosar - 【1 OS模块】
hammershr2012的博客
07-28 5181
Autosar (Automotive Open System Architecture)是一种汽车电子系统的标准化框架，旨在提高汽车电子系统的可重用性、可扩展性和可靠性。OS模块是Autosar中的一个重要模块，用于管理汽车电子系统中的任务和资源。
RTA OS系列介绍03-Event
initiallizer的博客
11-21 3163
RTA OS系列介绍之Event（扩展任务所等待的事件）
【OS基础】符合AUTOSAR标准的RTA-OS-Task详解
qq_36056498的博客
10-26 3878
符合AUTOSAR标准的RTA-OS-Task详解
查表法实现方法
quanguoheme的专栏
10-11 1410
/* ********************************************************************************************************* *                                       PRIORITY RESOLUTION TABLE * * Note: Index into
AUTOSAR基础篇之OS(上)
热门推荐
king110108的专栏
05-29 1万+
前言 首先，请问大家几个小小的问题，你清楚： 为什么汽车电子ECU需要使用OS呢，它的必要性在哪里？ ECU软件运行过程中是如何实现任务切换的吗？ 多核系统OS又是如何协同启动或者关闭的呢？ 。。。。。。 今天，我们来一起探索并回答这些问题。为了便于大家理解，以下是本文的主题大纲： 正文为啥要用OS？ 我们知道传统所说的“裸机编程”就是不带操作系统的编程，在系统需求相对比较简单的情况下使用裸机编程可以满足要求。但是随着系统需求越来越复杂，此时就需要用到模块化设计方法以及多任务编程思想，否则后期软件.
uc/os调度机制深度解析
weixin_30670925的博客
03-22 206
一、准备工作： //OSMapTbl与OSUnMapTbl定义 /* ********************************************************************************************************* * MAPPING TABLE TO MA...
逐字逐句解析ucos ii 源代码-》OS_CORE.c
一条狗的自我修养
01-31 1600
//BY 简单的元清//部分内容引用了其他博主的文章，对这些博主表示感谢，时间关系就不一一指出了。//如有转载，请说明，谢谢 /* ********************************************************************************************************* *
μC/OS-II任务调度与就绪表解析
任务调度是多任务操作系统的核心，μC/OS-II的调度策略是始终尝试运行优先级最高的就绪任务。通过任务就绪表，系统能够实时更新哪个任务已准备执行。该表是一个二维数组OSRdyTbl[ ]，每个任务在表中占有一位置，状态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值