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

最新推荐文章于 2023-07-28 11:51:35 发布
最新推荐文章于 2023-07-28 11:51:35 发布
阅读量2.1k 收藏 1
点赞数 1
分类专栏： 操作系统篇：μC/OS-II 文章标签： uCOS-II 任务调度 任务数扩展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fovwin/article/details/9796587
版权

关于μ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;
}




鱼与熊掌不可兼得。


fovwin
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
μC/OS-II 的任务调度算法分析
fovwin的专栏
08-06 5491
任务调度是一个操作系统最核心的部分，μC/OS-II 通过三步走来完成这个过程。 1) 从就绪表中获得就绪任务的最高优先级：OSRdyTbl[]，OSRdyGrp，OSMapTbl[]，OSUnMapTbl[] 2) 获取最高优先级就绪任务的任务控制块：OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy] 3) 启动任务切换：OS_TASK_SW()
μC/OS II 任务调度详解（一）
fanwenjieok的专栏
11-07 1745
      UC/OS II 是一个多任务操作系统，从宏观角度来看，当前系统中可以有多个任务同时运行；但从微观角度来看，某一个时刻只能有一个任务处于运行状态（单CPU情况，事实上在单核时是不存在多任务的），所有其它任务都处于其他状态，这些任务在什么时候，哪种情况下进行状态切换，是由该任伤自身的属性和操作系统调度算法来决定的。     当一个正在执行的任务因某个事件发生需要转入其他状态时，需要停止该任务的运行，转而执行其它的任务（或中断），此时就需要操作系统执行调度功能。因此，调度是指操作系统在管理多任务时选
【算法分析】μC/OS的任务调度算法分析
HaoBBNuanMM的博客
12-31 476
目录   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 329
如何描述一个task 代码描述 把内部的固定执⾏函数来看，task就是⼀个执⾏的函数，⼀个⽆限循环的void函数 • 为什么是⽆限循环？ 因为⼀个任务要在系统当中不断地调度，⽽不是⽤⼀次就废了 • 为什么返回void，task是独⽴存在的，不需要为其他task做什么（即便需要也是共享或者通信） 下⾯我们通过代码进程块来了解⼀下task进程块在计算机当中的使⽤（调度）⽅法。 上⾯两段代码分别是两个task的代码。在循环外的代码主要⽬的是设置时钟节拍（晶体振荡器），剩下⼏个是寻找对应的引脚来控制指定引脚灯
μC/OS-II操作系统中的任务
qq_46337496的博客
04-04 1664
任务的基本概念（任务及其种类） 1.任务和任务的控制块 我们在做一件事时，可以把这件事看成一个任务，然后将这个任务分成多个小任务，去处理这些小的任务，最终将一件事做成。对于uC/OS-II来说，它就是一个能够对这些小任务进行调度和管理，然后通过并发的方式去处理这些小任务的操作系统。 什么是并发方式呢？？ 对于一个计算机或者特别是在嵌入式操作系统中来说，处理器的数目通常只有一个，但是任务的数量远远大...
嵌入式系统/ARM技术中的基于μC/OS-II的时间片调度法设计
11-12
μC/OS-II是一种广泛应用的嵌入式实时操作系统，它采用了基于优先级的可剥夺调度策略。在这种调度机制下，CPU优先执行优先级最高的任务，一旦有更高优先级的任务变为就绪状态，当前任务的执行会被立即打断。任务可以...
一种μC/OS-II任务调度硬件指令的实现
10-22
任务调度是μC/OS-II的核心功能之一，其高效性主要依赖于任务就绪表的设计。任务就绪表由两个变量OSrdyGrp和OSRdyTb1[]以及两张表OSMapTb1[]和OSUnMaTb1[]共同维护。系统最多可以支持64个任务，每个任务拥有从0到OS_...
嵌入式系统/ARM技术中的一种μC/OS-II任务调度硬件指令的实现
11-03
μC/OS-II 是一种基于优先级的抢占式多任务实时操作系统，包含了实时内核、任务管理、时间管理、任务间通信同步（信号量，邮箱，消息 队列）和内存管理等功能。它可以使各个任务独立工作，互不干涉，很容易实现准时...
嵌入式实时系统μC/OS-Ⅱ任务调度算法分析及改进
10-26
技术论文,站点首页,技术,嵌入式系统
嵌入式系统/ARM技术中的操作系统μC/OS－II的文件体系结构
11-13
μC/OS-II是一种广泛应用的实时嵌入式操作系统，尤其在ARM处理器平台上有着广泛的使用。其文件体系结构清晰，便于理解和开发。以下是关于μC/OS-II文件体系结构的详细说明： 1. **核心部分** 核心部分是μC/OS-II...
操作系统OS - 常见系统的调度算法
anchenhe9360的博客
04-22 142
https://en.wikipedia.org/wiki/Scheduling_(computing) 在wiki的下面可以找到 转载于:https://www.cnblogs.com/allen2333/p/8904618.html
OS01- OS模块概述【任务类型和一致性类】
12-10 1887
文章目录1 多任务系统2 任务类型和一致性类2.1 基本任务2.2 扩展任务2.3 一致性类 1 多任务系统 一个大型的工程通常会划分为一些独立的子系统程序，已完成各自的功能任务，以便于管理和开发。这些独立程序在执行时都称为任务。 任务的结构： 1 代码和数据(任务专属访问)。 2 独立上下文（维护任务的状态和控制信息）。 3 共享资源（资源根据分配的特权，可供允许的任务访问）。 OS内核提供了多任务运行的环境，根据调度算法让多任务进行轮流并行的执行，以快速响应多个离散的事件。 2 任务类型和一致性类
Autosar - 【1 OS模块】
最新发布
hammershr2012的博客
07-28 3332
Autosar (Automotive Open System Architecture)是一种汽车电子系统的标准化框架，旨在提高汽车电子系统的可重用性、可扩展性和可靠性。OS模块是Autosar中的一个重要模块，用于管理汽车电子系统中的任务和资源。
RTA OS系列介绍03-Event
initiallizer的博客
11-21 2540
RTA OS系列介绍之Event（扩展任务所等待的事件）
查表法实现方法
quanguoheme的专栏
10-11 1356
/* ********************************************************************************************************* *                                       PRIORITY RESOLUTION TABLE * * Note: Index into
AUTOSAR基础篇之OS(上)
热门推荐
king110108的专栏
05-29 1万+
前言 首先，请问大家几个小小的问题，你清楚： 为什么汽车电子ECU需要使用OS呢，它的必要性在哪里？ ECU软件运行过程中是如何实现任务切换的吗？ 多核系统OS又是如何协同启动或者关闭的呢？ 。。。。。。 今天，我们来一起探索并回答这些问题。为了便于大家理解，以下是本文的主题大纲： 正文为啥要用OS？ 我们知道传统所说的“裸机编程”就是不带操作系统的编程，在系统需求相对比较简单的情况下使用裸机编程可以满足要求。但是随着系统需求越来越复杂，此时就需要用到模块化设计方法以及多任务编程思想，否则后期软件.
uc/os调度机制深度解析
weixin_30670925的博客
03-22 155
一、准备工作： //OSMapTbl与OSUnMapTbl定义 /* ********************************************************************************************************* * MAPPING TABLE TO MA...
逐字逐句解析ucos ii 源代码-》OS_CORE.c
一条狗的自我修养
01-31 1513
//BY 简单的元清//部分内容引用了其他博主的文章，对这些博主表示感谢，时间关系就不一一指出了。//如有转载，请说明，谢谢 /* ********************************************************************************************************* *
基于µC/OS-II的时间片调度法设计
ninver2007的专栏
09-26 2037
摘要  多任务的调度算法多种多样，各种调度算法也各有千秋。在某些应用场合，时间片调度法就比纯粹的优先级调度法更具优势。本文提出了基于µC/OS-II的时间片调度法的设计原理，给出了实现该调度法的关键部分源代码，并且通过一个简单的应用实例将该时间片调度法与优先级调度法进行比较。 关键词  多任务、时间片调度法、优先级调度法、µC/OS-II 引言 µC/OS-II嵌入式实时操作系统采用的是基于
μC/OS-II任务调度与就绪表解析
任务调度是多任务操作系统的核心，μC/OS-II的调度策略是始终尝试运行优先级最高的就绪任务。通过任务就绪表，系统能够实时更新哪个任务已准备执行。该表是一个二维数组OSRdyTbl[ ]，每个任务在表中占有一位置，状态...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值