启动ucosii之OSInit()

最新推荐文章于 2024-07-23 06:53:02 发布
最新推荐文章于 2024-07-23 06:53:02 发布
阅读量483 收藏
点赞数
分类专栏： RTOS

第一步: OSInit();//初始化uCOS_II.该函数位于OS_CORE.C,主要工作:
函数原型位于OS_CORE.C
OS_InitMisc();  /* 基础参数初始化 Initialize miscellaneous(混杂的,各种各样的) variables */
OS_InitRdyList(); /* 初始化任务就绪表 Initialize the Ready List */
OS_InitTCBList(); /* 初始化任务控制块 Initialize the free list of OS_TCBs */
OS_InitEventList(); /* 初始化事件控制块 Initialize the free list of OS_EVENTs */

函数原型位于OS_FLAG.C
#if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
    OS_FlagInit(); /* 事件标志组初始化 Initialize the event flag structures */
#endif

函数原型位于OS_MEM.C
#if (OS_MEM_EN > 0) && (OS_MAX_MEM_PART > 0)
    OS_MemInit(); /* 内存初始化 Initialize the memory manager */
#endif

函数原型位于OS_Q.C
#if (OS_Q_EN > 0) && (OS_MAX_QS > 0)
    OS_QInit(); /* 消息队列初始化 Initialize the message queue structures */
#endif

函数原型位于OS_CORE.C
    OS_InitTaskIdle(); /* 创建空闲任务(无条件)Create the Idle Task */
#if OS_TASK_STAT_EN > 0
    OS_InitTaskStat(); /* 创建统计任务Create the Statistic Task */
#endif

奋斗

1:static  void  OS_InitMisc (void)
{
#if OS_TIME_GET_SET_EN > 0 
    //0L→代表这个整型常量为long型的  
    OSTime        = 0L; /* 32位系统时钟变量,标示系统运行时间 Clear the 32-bit system clock*/
#endif

    OSIntNesting  = 0;  /* 中断嵌套次数 Clear the interrupt nesting counter */
    OSLockNesting = 0;  /* 调度器嵌套上锁次数 Clear the scheduling lock counter */

    OSTaskCtr     = 0;  /* 任务计时器,标示系统创建了多少个任务 Clear the number of tasks*/

    OSRunning     = FALSE; /* 标示内核是否运行 Indicate that multitasking not started*/
    
    OSCtxSwCtr    = 0; /* 系统任务切换次数 Clear the context switch counter */
    OSIdleCtr     = 0L; /* 空闲时间计数器 Clear the 32-bit idle counter */

#if (OS_TASK_STAT_EN > 0) && (OS_TASK_CREATE_EXT_EN > 0)
    OSIdleCtrRun  = 0L;//1秒前空闲任务计数器
    OSIdleCtrMax  = 0L;//1秒内空闲任务计数器可达最大值
    OSStatRdy     = FALSE; /* 统计任务标示,即是否执行统计任务 Statistic task is not ready */
#endif
}

奋斗

2:static  void  OS_InitRdyList (void)
{
    INT16U   i;
    INT8U   *prdytbl;

    OSRdyGrp      = 0x00; /* Clear the ready list */
    prdytbl       = &OSRdyTbl[0];
    for (i = 0; i < OS_RDY_TBL_SIZE; i++) {
        *prdytbl++ = 0x00;
    }

    OSPrioCur     = 0;
    OSPrioHighRdy = 0;

    OSTCBHighRdy  = (OS_TCB *)0;                                 
    OSTCBCur      = (OS_TCB *)0;
}

奋斗

//空闲任务键表OSTCBFreeList建立
3:static  void  OS_InitTCBList (void)
{
    INT8U    i;
    OS_TCB  *ptcb1;
    OS_TCB  *ptcb2;

    OSTCBList     = (OS_TCB *)0;                                 /* TCB Initialization                       */
    for (i = 0; i < (OS_LOWEST_PRIO + 1); i++) {                 /* Clear the priority table                 */
        OSTCBPrioTbl[i] = (OS_TCB *)0;
    }

//建立空闲任务列表
    ptcb1 = &OSTCBTbl[0];
    ptcb2 = &OSTCBTbl[1];
    for (i = 0; i < (OS_MAX_TASKS + OS_N_SYS_TASKS - 1); i++) {  /* Init. list of free TCBs                  */
        ptcb1->OSTCBNext = ptcb2;
        ptcb1++;
        ptcb2++;
    }
//列表最后一个任务的OSTCBNext设置为空
    ptcb1->OSTCBNext = (OS_TCB *)0;                              /* Last OS_TCB                              */

//将一整块空闲列表交给指针OSTCBFreeList
    OSTCBFreeList    = &OSTCBTbl[0];
}

奋斗

4:static  void  OS_InitEventList (void)//初始化ECB
{
#if (OS_EVENT_EN > 0) && (OS_MAX_EVENTS > 0)
#if (OS_MAX_EVENTS > 1)
    INT16U     i;
    OS_EVENT  *pevent1;
    OS_EVENT  *pevent2;


    pevent1 = &OSEventTbl[0];
    pevent2 = &OSEventTbl[1];
    for (i = 0; i < (OS_MAX_EVENTS - 1); i++) { /* Init. list of free EVENT control blocks  */
        pevent1->OSEventType = OS_EVENT_TYPE_UNUSED;
        pevent1->OSEventPtr  = pevent2;
        pevent1++;
        pevent2++;
    }
    pevent1->OSEventType = OS_EVENT_TYPE_UNUSED;
    pevent1->OSEventPtr  = (OS_EVENT *)0;
    OSEventFreeList      = &OSEventTbl[0];
#else
    OSEventFreeList              = &OSEventTbl[0]; /* Only have ONE event control block        */
    OSEventFreeList->OSEventType = OS_EVENT_TYPE_UNUSED;
    OSEventFreeList->OSEventPtr  = (OS_EVENT *)0;
#endif
#endif
}

奋斗

5:void  OS_FlagInit (void)
{
#if OS_MAX_FLAGS == 1
    OSFlagFreeList                 = (OS_FLAG_GRP *)&OSFlagTbl[0];  /* Only ONE event flag group!      */
    OSFlagFreeList->OSFlagType     = OS_EVENT_TYPE_UNUSED;
    OSFlagFreeList->OSFlagWaitList = (void *)0;
#endif

#if OS_MAX_FLAGS >= 2
    INT8U        i;
    OS_FLAG_GRP *pgrp1;
    OS_FLAG_GRP *pgrp2;


    pgrp1 = &OSFlagTbl[0];
    pgrp2 = &OSFlagTbl[1];
    for (i = 0; i < (OS_MAX_FLAGS - 1); i++) {                      /* Init. list of free EVENT FLAGS  */
        pgrp1->OSFlagType     = OS_EVENT_TYPE_UNUSED;
        pgrp1->OSFlagWaitList = (void *)pgrp2;
        pgrp1++;
        pgrp2++;
    }
    pgrp1->OSFlagWaitList = (void *)0;
    OSFlagFreeList        = (OS_FLAG_GRP *)&OSFlagTbl[0];
#endif
}

奋斗

6:void  OS_MemInit (void)
{
#if OS_MAX_MEM_PART == 1
    OSMemFreeList                = (OS_MEM *)&OSMemTbl[0]; /* Point to beginning of free list          */
    OSMemFreeList->OSMemFreeList = (void *)0;              /* Initialize last node                     */
    OSMemFreeList->OSMemAddr     = (void *)0;              /* Store start address of memory partition  */
    OSMemFreeList->OSMemNFree    = 0;                      /* No free blocks                           */
    OSMemFreeList->OSMemNBlks    = 0;                      /* No blocks                                */
    OSMemFreeList->OSMemBlkSize  = 0;                      /* Zero size                                */
#endif

#if OS_MAX_MEM_PART >= 2
    OS_MEM  *pmem;
    INT16U   i;


    pmem = (OS_MEM *)&OSMemTbl[0];                    /* Point to memory control block (MCB)           */
    for (i = 0; i < (OS_MAX_MEM_PART - 1); i++) {     /* Init. list of free memory partitions          */
        pmem->OSMemFreeList = (void *)&OSMemTbl[i+1]; /* Chain list of free partitions                 */
        pmem->OSMemAddr     = (void *)0;              /* Store start address of memory partition       */
        pmem->OSMemNFree    = 0;                      /* No free blocks                                */
        pmem->OSMemNBlks    = 0;                      /* No blocks                                     */
        pmem->OSMemBlkSize  = 0;                      /* Zero size                                     */
        pmem++;
    }
    pmem->OSMemFreeList = (void *)0;                  /* Initialize last node                          */
    pmem->OSMemAddr     = (void *)0;                  /* Store start address of memory partition       */
    pmem->OSMemNFree    = 0;                          /* No free blocks                                */
    pmem->OSMemNBlks    = 0;                          /* No blocks                                     */
    pmem->OSMemBlkSize  = 0;                          /* Zero size                                     */

    OSMemFreeList       = (OS_MEM *)&OSMemTbl[0];     /* Point to beginning of free list               */
#endif
}

奋斗

7:void  OS_QInit (void)
{
#if OS_MAX_QS == 1
    OSQFreeList         = &OSQTbl[0];            /* Only ONE queue!                                    */
    OSQFreeList->OSQPtr = (OS_Q *)0;
#endif

#if OS_MAX_QS >= 2
    INT16U  i;
    OS_Q   *pq1;
    OS_Q   *pq2;


    pq1 = &OSQTbl[0];
    pq2 = &OSQTbl[1];
    for (i = 0; i < (OS_MAX_QS - 1); i++) {      /* Init. list of free QUEUE control blocks            */
        pq1->OSQPtr = pq2;
        pq1++;
        pq2++;
    }
    pq1->OSQPtr = (OS_Q *)0;
    OSQFreeList = &OSQTbl[0];
#endif
}

奋斗

/* 创建空闲任务(无条件)Create the Idle Task */
//变量在OS_CFG.H、uCOS_II.H中定义
8:static  void  OS_InitTaskIdle (void)
{
#if OS_TASK_CREATE_EXT_EN > 0
    #if OS_STK_GROWTH == 1
    (void)OSTaskCreateExt(OS_TaskIdle,
                          (void *)0,                                 /* No arguments passed to OS_TaskIdle() */
                          &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], /* Set Top-Of-Stack                     */
                          OS_IDLE_PRIO,                              /* Lowest priority level                */
                          OS_TASK_IDLE_ID,
                          &OSTaskIdleStk[0],                         /* Set Bottom-Of-Stack                  */
                          OS_TASK_IDLE_STK_SIZE,
                          (void *)0,                                 /* No TCB extension                     */
                          OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);/* Enable stack checking + clear stack  */
    #else
    (void)OSTaskCreateExt(OS_TaskIdle,
                          (void *)0,                                 /* No arguments passed to OS_TaskIdle() */
                          &OSTaskIdleStk[0],                         /* Set Top-Of-Stack                     */
                          OS_IDLE_PRIO,                              /* Lowest priority level                */
                          OS_TASK_IDLE_ID,
                          &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], /* Set Bottom-Of-Stack                  */
                          OS_TASK_IDLE_STK_SIZE,
                          (void *)0,                                 /* No TCB extension                     */
                          OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);/* Enable stack checking + clear stack  */
    #endif
#else
    #if OS_STK_GROWTH == 1
    (void)OSTaskCreate(OS_TaskIdle,
                       (void *)0,
                       &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1],
                       OS_IDLE_PRIO);
    #else
    (void)OSTaskCreate(OS_TaskIdle,
                       (void *)0,
                       &OSTaskIdleStk[0],
                       OS_IDLE_PRIO);
    #endif
#endif
}

奋斗

/* 创建统计任务Create the Statistic Task */
9:static  void  OS_InitTaskStat (void)
{
#if OS_TASK_CREATE_EXT_EN > 0
    #if OS_STK_GROWTH == 1
    (void)OSTaskCreateExt(OS_TaskStat,
                          (void *)0,                                   /* No args passed to OS_TaskStat()*/
                          &OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1],   /* Set Top-Of-Stack               */
                          OS_STAT_PRIO,                                /* One higher than the idle task  */
                          OS_TASK_STAT_ID,
                          &OSTaskStatStk[0],                           /* Set Bottom-Of-Stack            */
                          OS_TASK_STAT_STK_SIZE,
                          (void *)0,                                   /* No TCB extension               */
                          OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);  /* Enable stack checking + clear  */
    #else
    (void)OSTaskCreateExt(OS_TaskStat,
                          (void *)0,                                   /* No args passed to OS_TaskStat()*/
                          &OSTaskStatStk[0],                           /* Set Top-Of-Stack               */
                          OS_STAT_PRIO,                                /* One higher than the idle task  */
                          OS_TASK_STAT_ID,
                          &OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1],   /* Set Bottom-Of-Stack            */
                          OS_TASK_STAT_STK_SIZE,
                          (void *)0,                                   /* No TCB extension               */
                          OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);  /* Enable stack checking + clear  */
    #endif
#else
    #if OS_STK_GROWTH == 1
    (void)OSTaskCreate(OS_TaskStat,
                       (void *)0,                                      /* No args passed to OS_TaskStat()*/
                       &OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1],      /* Set Top-Of-Stack               */
                       OS_STAT_PRIO);                                  /* One higher than the idle task  */
    #else
    (void)OSTaskCreate(OS_TaskStat,
                       (void *)0,                                      /* No args passed to OS_TaskStat()*/
                       &OSTaskStatStk[0],                              /* Set Top-Of-Stack               */
                       OS_STAT_PRIO);                                  /* One higher than the idle task  */
    #endif
#endif
}

csshuke
关注
专栏目录
OSInit( );
silenceee的专栏
11-17 6335
uC/OS II学习时的一个重要函数 OSInit( );在uC/OS II的学习中，OSInit( );是一个重要的函数，它在OS应用中的void main();函数中首先被调用，是OS运行的第一个函数,如下程序，它完成各初始变量的初始化，建立任务空闲键表OSTCBFreeList, 建立事件空闲键表OSEventFreeList.创建一个空闲任务OS_TaskIdle，以及初始化其它如
启动ucosii之一OSInit()
aimarpp的专栏
05-24 4599
第一步: OSInit();//初始化uCOS_II.该函数位于OS_CORE.C,主要工作: 函数原型位于OS_CORE.C OS_InitMisc();  /* 基础参数初始化 Initialize miscellaneous(混杂的,各种各样的) variables */ OS_InitRdyList(); /* 初始化任务就绪表 Initialize the Ready List *
UCOS-III之 OSInit() UCOSIII初始化函数
THEXIAO1996的博客
10-28 836
UCOS-III之 OSInit() UCOSIII初始化函数 OSInit()函数是UCOSIII的初始化函数，其必须在调用任何其他UCOSIII服务函数之前调用它，包括多任务运行函数OSStart()，同时在OSInit() 调用的任何子函数遇到错误，OSInit() 都会立即返回。 函数OSInit()主要负责初始化就绪优先级列表，就绪表等一些数据结构，并对系统使用的全局变量进行初始化。 OS_PrioInit();
uCO/OS-ii OSInit( )注解
xiaogu0322的博客
11-23 594
source\os_core.c里void OSInit (void)注解
stm32_ucos学习---Osinit()
adaixiaoxiao的专栏
01-23 589
uC/OS-II主函数如下： main(){ OSInit();    //初始化uC/OS_II TaskCreate(...);    //创建用户任务 OSStart();   //启动任务且之前不易打开中断 } 下面首先对uC/OS-II的初始化函数OSInit()进行分析： OSInit（）： 最先看看OSInit完成哪些初始化：
ucosII.rar_Ucosii实验代码_ucosii_ucosii实验_ucosii移植实验
09-21
3. **UCOSII初始化**：调用OSInit()函数初始化UCOSII内核。 4. **任务创建**：编写任务函数，并使用OSTaskCreate()创建任务，设定任务优先级和栈空间。 5. **时钟节拍设置**：设置时钟节拍中断，通常用于调度和计时...
ucosii.rar_UCOS C51_c51 ucosii_keil C51 源码_ucos keil c51_ucosii
09-20
2. **内核初始化**：编写启动代码，初始化堆栈、内存区域、中断服务函数等，然后调用UCOSII的`OSInit()`函数进行内核初始化。 3. **任务创建**：根据应用需求，定义并注册各个任务，调用`OSTaskCreate()`函数创建...
stm321f407_UCOSII-任务调度_STM32F407UCOSII_
10-03
3. **RTOS内核初始化**：启动后，需要调用UCOSII的`OSInit()`函数来初始化操作系统内核。这包括创建任务堆栈、设置任务调度参数等。 4. **任务创建**：UCOSII的核心是任务调度，你需要定义多个任务并使用`...
UcosII移植
07-25
1. 初始化设置：移植的第一步是编写操作系统启动代码，初始化堆栈、设置中断向量表，并调用UCOSII的初始化函数`OSInit()`。 2. 内存管理：UcosII需要一个连续的内存区域用于任务堆栈和内核数据结构。根据目标平台的...
ucosII入门教程
03-31
《UCOSII入门教程》是一份专为初学者设计的嵌入式实时操作系统学习资源，主要涵盖UCOSII（μC/OS-II）的基本概念、使用方法和移植实践。UCOSII是由Micrium公司开发的一款小巧、高效且可移植的实时操作系统，广泛应用...
ucosiii OSInit()函数简略解析
03-18
文档是excel 文件，我仅是把OSInit() 函数的流程，简要的整理了一下。从这个函数中发现了洞天。传上来让各位再次补充。里面肯定有错误或不当的说法。但是对于内核的学习很有帮助。
ucosii-51上奔跑-外扩RAM-大模式下编译
06-01
51下测试ucosii，有protues仿真
嵌入式实时操作系统ucosii课后答案任哲版
10-30
嵌入式实时操作系统ucosii课后答案任哲版
uC/OS II学习时的一个重要函数 OSInit( );
edo_full的专栏
04-03 654
<br /><br />在uC/OS II的学习中，OSInit( );是一个重要的函数，它在OS应用中的void main();函数中首先被调用，是OS运行的第一个函数,如下程序，它完成各初始变量的初始化，建立任务空闲键表OSTCBFreeList, 建立事件空闲键表OSEventFreeList.创建一个空闲任务OS_TaskIdle，以及初始化其它如果有用到的功能 Q,MEM等。我个人的理解也是从这里开始的。通过空闲任务的创建基本上涉及到OS中任务块和事件块的管理。我想这也是理解了OS在内
OSInit 函数
sunrier的专栏
06-07 1917
/************************************************************* FileName : Os_core.c FileFunc : 内核管理文件 Version : V0.1 Author : Sunrier Date : 2011-06-07 Descp
OS_Init
u012937842的博客
01-18 1341
OSInit(&err)中开启的系统任务 将开启两个必要任务和两个可选任务： OS_IntQTaskInit(&p_err)[OS_CFG_ISR_POST_DEFERRED_EN] OS_IdleTaskInit(&p_err) OS_TickTaskInit(&p_err) OS_StatTaskInit(&p_err)[OS_CFG_STA
OS-Init
wcl130的专栏
07-22 517
<br />uC/OS II学习时的一个重要函数 OSInit( );<br />在uC/OS II的学习中，OSInit( );是一个重要的函数，它在OS应用中的void main();函数中首先被调用，是OS运行的第一个函数,如下程序，它完成各初始变量的初始化，建立任务空闲键表OSTCBFreeList, 建立事件空闲键表OSEventFreeList.创建一个空闲任务OS_TaskIdle，以及初始化其它如果有用到的功能 Q,MEM等。我个人的理解也是从这里开始的。通过空闲任务的创建基本上涉及到OS中
UCOSIII 系统初始化接口(OSInit)详解
最新发布
TechIoT - 探索物联网与嵌入式系统
07-23 354
初始化中断堆栈 清除和初始化系统计数器和指针 初始化优先级位图表 初始化各个管理模块 初始化任务管理器 初始化空闲任务 初始化时钟节拍管理器 初始化统计任务 初始化定时器管理器 调用用户自定义的初始化钩子函数
ucos-ii嵌入式操作系统(三)---系统初始化OSInit和系统启动OSStart
myselfzhangji的博客
05-04 2922
一 概述 前面我们介绍了如何在K60平台上移植第一个ucos系统，我们知道创建一个task并启动它，需要三个函数支持，分别是OSInit、OSTaskCreate以及OSStart，今天我们先来看看OSInit和OSStart分别作了什么。 二 分析 系统初始化OSInit 话不多说，直接先看源代码，如下： void OSInit (void) { #if OS_TASK_CREATE_EX...
STM32 uCOSII移植指南：步步解析
5. **启动代码**：可能需要修改启动文件，以便在启动过程中初始化RTOS，如设置堆栈指针和调用OSInit()。 6. **任务创建**：编写任务函数，根据应用需求创建并配置任务，设置优先级和栈大小。 7. **时钟源设置**：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值