STM32 uC/OS-III

已于 2024-03-31 09:51:16 修改
阅读量774 收藏 11
点赞数 28
分类专栏： uC/OS-III 文章标签： stm32 驱动开发 嵌入式硬件
于 2024-03-31 00:48:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lanzh_syf/article/details/137187774
版权

What is uC/OS-III?

µC/OS-III 的发音为“Micro C O S Three”，这意味着 µC/OS-III 是基于 C 语言编写的第三代
小型操作系统，当然这里所说的第三代是相对于 µC/OS 的前两个版本 µC/OS 和 µC/OS-II 而言
的，后面也会介绍这三个版本的差别。µC/OS/III 是一个操作系统，准确地说应该是一个实时操
作系统，也就是 RTOS（Real Time Operating System），与之类似的 RTOS 还有 FreeRTOS、RTX、
RT-Thread 等.
官方手册，呀，跟github一个鸟样随缘访问，除非。。。。。。

uC/OS-III 的特点

抢占式多任务管理：

uC/OS-III 是一个支持多任务抢占的内核，因此总是优先执行任务优先级高的任务。

时间片调度：

uC/OS-III 允许系统中有多个相同任务优先级的任务，如果系统中处于就绪状态的任务中，优先级最高的任务有多个，那么 µC/OS-III 将以时间片的方式调度任务，即根据用户指定的时间（时间片）轮流调度这些任务。

极短的中断禁用时间：

uC/OS-III 通过锁定任务调度器代替禁用中断来保护一些关键区域（临界区），这确保了 uC/OS-III 能够快速地响应中断。

任务数量不限：

µC/OS-III 理论上支持不受限制的任务数量，但实际上，系统中任务的最大数量受处理器内存空间的限制。

任务优先级数量不限：

uC/OS-III 支持的任务优先级数量不受限制，但对于大多数应用场景而言，使用 32~256 个任务优先级就绰绰有余了。

内核对象数量不限：

uC/OS-III 提供了多种内核对象，如任务、信号量、事件标志、消息队列、软件定时器和内存区等，并且在不考虑处理器内存限制的情况下，用户可以无限制的创建这些内核对象。

时间戳：

uC/OS-III 提供了时间戳功能，用户可以非常方便地测量系统在运行过程中，处理器处理某些事件所消耗的时间，以方便用户对系统进行针对性的优化。自定义钩子函数：µC/OS-III 提供了一些在内核执行操作之前、之后或过程中的钩子函数，这样可以方便用户扩展 µC/OS-III 的功能。

防死锁：uC/OS-III 允许任务在等待某些内核对象前，设置一个等待的最大超时时间，这样

可以有效地防止死锁的发生。

软件定时器：

在 uC/OS-III 中，用户可以创建任意数量的“单次”和“周期”软件定时器，并且每个软件定时器都可以有独立的超时回调函数。

任务内嵌信号量：

uC/OS-III 提供了任务的内嵌信号量功能，这使得任务可以直接获取来自其他任务或中断的信号，而不需要任何的中间内核对象，大大地提高了系统的运行效率。

任务内嵌消息队列：

uC/OS-III 提供了任务的内嵌消息队列，这使得任务可以直接接收来自其他任务或中断的消息，而不需要任何的中间内核对象，大大地提高了系统的运行效率。

临界区

uC/Os-Ill defines one macro for entering a critical section and two macros for leaving（ucos定义了一个进入临界区的函数，两个退出临界区的函数）。

os_CRITICAL_ENTER(); //进入临界区
os_CRITICAL_EXIT(); //退出临界区
os_CRITICALEXIT_NO_SCHED(); //退出街区

任务

任务调度

任务优先级

任务优先级是决定任务调度器如何分配 CPU 使用权的因素之一。每一个任务都被分配一个0~(OS_CFG_PRIO_MAX-1)的任务优先级，并且 uC/OS-III 支持多了任务具有相同的任务优先级，宏 OS_CFG_PRIO_MAX 是在 uC/OS-III 的配置文 os_cfg.h 中定义配置的。在 cpu_cfg.h文件中有宏CPU_CFG_LEAD_ZEROS_ASM_PRESENT，该宏用于配置 µC/OS-III 使用硬件指令的方法或是软件算法的方法计算前导零数量，uC/OS-III 使用位图的方式记录当前系统中存在的所有任务优先级，在 uC/OS-III 系统中存在的最高任务优先级时，就会使用到前导零计数。对于 STM32 而言，STM32 是具有硬件计算前导零的指令的，并且最大支持 32比特位的数，因此宏 OS_CFG_PRIO_MAX 的最大值就是 32。当然，配置系统支持的任务优先级数量越多，系统消耗的资源也就越多，因此读者的实际的工程开发中，应当合理地根据实际需求配置宏 OS_CFG_PRIO_MAX。µC/OS-III 的任务优先级高低与其对应的任务优先级数值是成反比的，也就是说，任务优先级数值为 0 的任务是最高优先级的任务，任务优先级数值为(OS_CFG_PRIO_MAX-1)的任务是优先级最低的任务。如下图 在这里插入图片描述

任务调度

任务调度是 uC/OS-III 的一部分，负责确定接下来应该运行哪一个任务。uC/OS-III 是一个
基于任务优先级的抢占式内核，抢占式调度是 uC/OS-III 的主要任务调度方式，并且 uC/OS-III
在抢占式调度的基础上还支持时间片调度，接下来分别介绍这两种任务调度方式。

抢占式

在 uC/OS-III 中，每一个任务都会根据其重要性被分配一个任务优先级，重要性高的任务分配到的任务优先级高，任务优先级高的任务就能够抢占任务优先级低的任务，从而获得 CPU的使用权。在抢占式调度中，如果一个具有高任务优先级的任务因等待某一事件而被挂起后，CPU 的使用权会交给任务优先级低的任务，此时，只要任务优先级高的任务等待的事件发生，那么uC/OS-III 会立即挂起正在运行的低任务优先级的任务，而去处理任务优先级高的任务，这一过程就是抢占的过程。
同样的如果被挂起的高优先级的任务所等待的事件在中断中发生，那么中断服务函数退出后不会返回任务优先级低的任务运行，而是会直接返回任务优先级高的任务去运行。抢占式调度主要是针对任务优先级不同的任务，每一个任务都有一个任务优先级，任务优先级高的任务可以抢占任务优先级低的任务运行，只有当任务优先级高的任务被挂起，低任务优先级的任务才能够运行。

时间片轮转

时间片调度是针对任务优先级相同的任务而言的，当多个具有相同任务优先级的任务就绪时，任务调度器会根据用户设置的任务时间片轮流地运行这些任务，当然这些任务的运行依然会被任务优先级更高的任务抢占。时间片是以一次系统时钟节拍为单位的，例如uC/OS-III 默认设置的任务时间片为 100，则 uC/OS-III 会在当前任务运行 100 次系统时钟节拍的时间后，切换到另一个相同任务优先级的任务中运行。

任务状态

任务状态

状态转换图

任务挂起
************************************************************************************************************************
*                                                   SUSPEND A TASK
*
* Description: This function is called to suspend a task.  The task can be the calling task if 'p_tcb' is a NULL pointer
*              or the pointer to the TCB of the calling task.
*
* Arguments  : p_tcb    is a pointer to the TCB to suspend.
*                       If p_tcb is a NULL pointer then, suspend the current task.
*
*              p_err    is a pointer to a variable that will receive an error code from this function.
*
*                           OS_ERR_NONE                      if the requested task is suspended
*                           OS_ERR_SCHED_LOCKED              you can't suspend the current task is the scheduler is
*                                                            locked
*                           OS_ERR_TASK_SUSPEND_ISR          if you called this function from an ISR
*                           OS_ERR_TASK_SUSPEND_IDLE         if you attempted to suspend the idle task which is not
*                                                            allowed.
*                           OS_ERR_TASK_SUSPEND_INT_HANDLER  if you attempted to suspend the idle task which is not
*                                                            allowed.
*
* Note(s)    : 1) This function is INTERNAL to uC/OS-III and your application should not call it.
*
*              2) You should use this function with great care.  If you suspend a task that is waiting for an event
*                 (i.e. a message, a semaphore, a queue ...) you will prevent this task from running when the event
*                 arrives.
************************************************************************************************************************

任务挂起函数

void   OS_TaskSuspend (OS_TCB  *p_tcb,  //任务TCB
                       OS_ERR  *p_err);	//错误返回值
任务恢复
/*$PAGE*/
/*
************************************************************************************************************************
*                                               RESUME A SUSPENDED TASK
*
* Description: This function is called to resume a previously suspended task.  This is the only call that will remove an
*              explicit task suspension.
*
* Arguments  : p_tcb      Is a pointer to the task's OS_TCB to resume
*
*              p_err      Is a pointer to a variable that will contain an error code returned by this function
*
*                             OS_ERR_NONE                  if the requested task is resumed
*                             OS_ERR_STATE_INVALID         if the task is in an invalid state
*                             OS_ERR_TASK_RESUME_ISR       if you called this function from an ISR
*                             OS_ERR_TASK_RESUME_SELF      You cannot resume 'self'
*                             OS_ERR_TASK_NOT_SUSPENDED    if the task to resume has not been suspended
*
* Returns    : none
*
* Note(s)    : This function is INTERNAL to uC/OS-III and your application should not call it.
************************************************************************************************************************
*/

任务恢复函数

void  OS_TaskResume (OS_TCB  *p_tcb,
                     OS_ERR  *p_err);
任务删除
/*$PAGE*/
/*
************************************************************************************************************************
*                                                     DELETE A TASK
*
* Description: This function allows you to delete a task.  The calling task can delete itself by specifying a NULL
*              pointer for 'p_tcb'.  The deleted task is returned to the dormant state and can be re-activated by
*              creating the deleted task again.
*
* Arguments  : p_tcb      is the TCB of the tack to delete
*
*              p_err      is a pointer to an error code returned by this function:
*
*                             OS_ERR_NONE                  if the call is successful
*                             OS_ERR_STATE_INVALID         if the state of the task is invalid
*                             OS_ERR_TASK_DEL_IDLE         if you attempted to delete uC/OS-III's idle task
*                             OS_ERR_TASK_DEL_INVALID      if you attempted to delete uC/OS-III's ISR handler task
*                             OS_ERR_TASK_DEL_ISR          if you tried to delete a task from an ISR
*
* Note(s)    : 1) 'p_err' gets set to OS_ERR_NONE before OSSched() to allow the returned error code to be monitored even
*                 for a task that is deleting itself. In this case, 'p_err' MUST point to a global variable that can be
*                 accessed by another task.
************************************************************************************************************************
*/

任务删除函数

void  OSTaskDel (OS_TCB  *p_tcb,
                 OS_ERR  *p_err);

任务控制块

这个系统的TCB是真牛逼，管那么多。

struct os_tcb {  
 	 CPU_STK *StkPtr; /* 指向任务栈栈顶的指针 */
 	 void *ExtPtr;	/* 指向用户自定义数据的指针 */
     CPU_STK *StkLimitPtr; /* 指向任务栈“水位”限制的指针 */
 #if (OS_CFG_DBG_EN > 0u)
 	 CPU_CHAR *NamePtr; /* 指向任务名的指针 */
#endif
	 OS_TCB *NextPtr; /* 指向任务链表中下一个任务控制块的指针 */
	 OS_TCB *PrevPtr;  /* 指向任务链表中上一个任务控制块的指针 */
#if (OS_CFG_TICK_EN > 0u)
 	 OS_TCB *TickNextPtr;	 /* 指向 Tick 任务链表中下一个任务控制块的指针 */
  	 OS_TCB *TickPrevPtr;	/* 指向 Tick 任务链表中上一个任务控制块的指针 */
#endif 
#if ( (OS_CFG_DBG_EN > 0u) || \
 (OS_CFG_STAT_TASK_STK_CHK_EN > 0u) || \
 (OS_CFG_TASK_STK_REDZONE_EN > 0u))
 	 CPU_STK *StkBasePtr; /* 指向任务栈起始地址的指针 */
#endif
#if defined(OS_CFG_TLS_TBL_SIZE) && (OS_CFG_TLS_TBL_SIZE > 0u)
	 OS_TLS TLS_Tbl[OS_CFG_TLS_TBL_SIZE];	 /* 任务本地存储数组 */
#endif
 
#if (OS_CFG_DBG_EN > 0u)
 	OS_TASK_PTR TaskEntryAddr;  /* 指向任务函数的指针 */
 	void *TaskEntryArg;  /* 指向任务函数参数的指针 */
#endif
 	OS_TCB *PendNextPtr; /* 指向挂起态任务链表中下一个任务控制块的指针 */
 	OS_TCB *PendPrevPtr; /* 指向挂起态任务链表中上一个任务控制块的指针 */
	 OS_PEND_OBJ *PendObjPtr; /* 指向所等待内核对象的指针 */
	 OS_STATE PendOn;/* 任务挂起等待内核对象的类型 */
	 OS_STATUS PendStatus; /* 任务挂起的结果 */
	 OS_STATE TaskState; /* 任务当前的状态 */
	 OS_PRIO Prio; /* 任务优先级 */
#if (OS_CFG_MUTEX_EN > 0u)
	 OS_PRIO BasePrio; /* 任务原始优先级 */
	 OS_MUTEX *MutexGrpHeadPtr; /* 指向任务拥有的互斥信号量链表的指针 */
#endif
#if ( (OS_CFG_DBG_EN > 0u) || \
 (OS_CFG_STAT_TASK_STK_CHK_EN > 0u) || \
 (OS_CFG_TASK_STK_REDZONE_EN > 0u))
 	CPU_STK_SIZE StkSize; /* 任务栈大小 */
#endif
 	OS_OPT Opt; /* 任务操作选项 */
#if (OS_CFG_TS_EN > 0u)
	 CPU_TS TS; /* 任务时间戳 */
#endif
#if (defined(OS_CFG_TRACE_EN) && (OS_CFG_TRACE_EN > 0u))
	 CPU_INT16U SemID; /* 用于第三方调试工具 */
#endif
	 OS_SEM_CTR SemCtr;  /* 用于任务接收信号的计数型信号量 */
#if (OS_CFG_TICK_EN > 0u)
	 OS_TICK TickRemain; /* 任务延时的剩余时钟节拍数 */
	 OS_TICK TickCtrPrev; /* 用于任务周期延时 */
#endif
#if (OS_CFG_SCHED_ROUND_ROBIN_EN > 0u)
	 OS_TICK TimeQuanta; /* 任务时间片 */
 	 OS_TICK TimeQuantaCtr; /* 任务剩余时间片 */
#endif
#if (OS_MSG_EN > 0u)
	 void *MsgPtr;/* 指向任务接收到的消息的指针 */
	 OS_MSG_SIZE MsgSize; /* 任务接收到的消息的大小 */
#endif
#if (OS_CFG_TASK_Q_EN > 0u)
	 OS_MSG_Q MsgQ;  /* 任务内嵌消息队列 */
#if (OS_CFG_TASK_PROFILE_EN > 0u)
	 CPU_TS MsgQPendTime; /* 消息从发送到接收花费的时间 */
	 CPU_TS MsgQPendTimeMax; /* 消息从发送到接收花费的最长时间 */
#endif
#endif
#if (OS_CFG_TASK_REG_TBL_SIZE > 0u)
	 OS_REG RegTbl[OS_CFG_TASK_REG_TBL_SIZE]; /* 特定于任务的寄存器表 */
#endif 
#if (OS_CFG_FLAG_EN > 0u)
	 OS_FLAGS FlagsPend; /* 任务挂起等待的事件标志 */
	 OS_FLAGS FlagsRdy; /* 任务挂起等待但已发生的事件标志 */
	 OS_OPT FlagsOpt; /* 任务挂起等待事件标志的类型 */
#endif 
#if (OS_CFG_TASK_SUSPEND_EN > 0u)
 	OS_NESTING_CTR SuspendCtr; /* 记录任务被挂起的嵌套次数 */
#endif
#if (OS_CFG_TASK_PROFILE_EN > 0u)
	 OS_CPU_USAGE CPUUsage; /* 任务的 CPU 使用率 */
	 OS_CPU_USAGE CPUUsageMax; /* 任务最大的 CPU 使用率 */
	 OS_CTX_SW_CTR CtxSwCtr; /* 任务执行次数 */
 	 CPU_TS CyclesDelta;/* 任务在任务切换前的运行时间 */
	 CPU_TS CyclesStart;  /* 任务启动时的时间戳 */
	 OS_CYCLES CyclesTotal; /* 任务的总运行时间 */
	 OS_CYCLES CyclesTotalPrev;  /* 任务上次的总运行时间 */
	 CPU_TS SemPendTime;  /* 信号量发出信号所用时间 */
	 CPU_TS SemPendTimeMax;  /* 信号量发出信号所用的最大时间 */
#endif 
#if (OS_CFG_STAT_TASK_STK_CHK_EN > 0u)
	 CPU_STK_SIZE StkUsed;  /* 任务栈已使用量 */
 	 CPU_STK_SIZE StkFree;  /* 任务栈剩余量 */
#endif
 
#ifdef CPU_CFG_INT_DIS_MEAS_EN
	 CPU_TS IntDisTimeMax;  /* 任务关闭中断的最长时间 */
#endif
#if (OS_CFG_SCHED_LOCK_TIME_MEAS_EN > 0u)
	 CPU_TS SchedLockTimeMax;  /* 任务锁定任务调度器的最长时间 */
#endif
#if (OS_CFG_DBG_EN > 0u)
	 OS_TCB *DbgPrevPtr;  /* 指向用于代码调式的任务链表中上一个任务控制块的指针 */
	 OS_TCB *DbgNextPtr; /* 指向用于代码调试的任务链表中下一个任务控制块的指针 */
	 CPU_CHAR *DbgNamePtr;  /* 指向用于代码调试的任务名的指针 */
#endif
#if (defined(OS_CFG_TRACE_EN) && (OS_CFG_TRACE_EN > 0u))
	 CPU_INT16U TaskID; /* 用于第三方调试工具 */
#endif
};

任务栈

对于 uC/OS-III，在创建一个任务前，需要为任务准备好一块内存空间，这一内存空间将作为任务的栈空间进行使用。
用CPU_STK 数据类型来定义任务堆栈，CPU_STK在 cpu.h中有定义，其实CPU_STK就是CPU_INT32U，可以看出一个CPU_STK变量为4字节，因此任务的实际堆栈大小应该为我们定义的4倍。下面代码就是我们定义了一个任务堆栈TASK_STK，堆栈大小为64*4=256字节。
任务的栈占用的是MCU 内部的 RAM，当任务越多的时候，需要使用的栈空间就越大，即需要使用的 RAM空间就越多。一个 MCU 能够支持多少任务，就得看你的 RAM 空间有多少。

创建任务

参数说明

/*$PAGE*/
/*
************************************************************************************************************************
*                                                    CREATE A TASK
*
* Description: This function is used to have uC/OS-III manage the execution of a task.  Tasks can either be created
*              prior to the start of multitasking or by a running task.  A task cannot be created by an ISR.
*
* Arguments  : p_tcb          is a pointer to the task's TCB（任务控制块）
*
*              p_name         is a pointer to an ASCII string to provide a name to the task.（任务名字）
*
*              p_task         is a pointer to the task's code （任务函数）
*
*              p_arg          is a pointer to an optional data area which can be used to pass parameters to
*                             the task when the task first executes.  Where the task is concerned it thinks
*                             it was invoked and passed the argument 'p_arg' as follows:（任务函数参数）
*
*                                 void Task (void *p_arg)
*                                 {
*                                     for (;;) {
*                                         Task code;
*                                     }
*                                 }
*
*              prio           is the task's priority.  A unique priority MUST be assigned to each task and the
*                             lower the number, the higher the priority.（任务优先级）
*
*              p_stk_base     is a pointer to the base address of the stack (i.e. low address).（堆栈基地址）
*
*              stk_limit      is the number of stack elements to set as 'watermark' limit for the stack.  This value
*                             represents the number of CPU_STK entries left before the stack is full.  For example,
*                             specifying 10% of the 'stk_size' value indicates that the stack limit will be reached
*                             when the stack reaches 90% full.（任务堆栈预警值）
*
*              stk_size       is the size of the stack in number of elements.  If CPU_STK is set to CPU_INT08U,
*                             'stk_size' corresponds to the number of bytes available.  If CPU_STK is set to
*                             CPU_INT16U, 'stk_size' contains the number of 16-bit entries available.  Finally, if
*                             CPU_STK is set to CPU_INT32U, 'stk_size' contains the number of 32-bit entries
*                             available on the stack.（以元素个数表示的堆栈大小。）
*
*              q_size         is the maximum number of messages that can be sent to the task（消息数量）
*
*              time_quanta    amount of time (in ticks) for time slice when round-robin between tasks.  Specify 0 to use
*                             the default.（时间片调度时所占时间）
*
*              p_ext          is a pointer to a user supplied memory location which is used as a TCB extension.
*                             For example, this user memory can hold the contents of floating-point registers
*                             during a context switch, the time each task takes to execute, the number of times
*                             the task has been switched-in, etc.
*
*              opt            contains additional information (or options) about the behavior of the task.
*                             See OS_OPT_TASK_xxx in OS.H.  Current choices are:（任务选项）
*
*                                 OS_OPT_TASK_NONE            No option selected （没有）
*                                 OS_OPT_TASK_STK_CHK         Stack checking to be allowed for the task（堆栈检查）
*                                 OS_OPT_TASK_STK_CLR         Clear the stack when the task is created（创建任务时先打扫卫生）
*                                 OS_OPT_TASK_SAVE_FP         If the CPU has floating-point registers, save them
*                                                             during a context switch.
*                                 OS_OPT_TASK_NO_TLS          If the caller doesn't want or need TLS (Thread Local 
*                                                             Storage) support for the task.  If you do not include this
*                                                             option, TLS will be supported by default.
*
*              p_err          is a pointer to an error code that will be set during this call.  The value pointer
*                             to by 'p_err' can be:
*
*                                 OS_ERR_NONE                    if the function was successful.
*                                 OS_ERR_ILLEGAL_CREATE_RUN_TIME if you are trying to create the task after you called
*                                                                   OSSafetyCriticalStart().
*                                 OS_ERR_NAME                    if 'p_name' is a NULL pointer
*                                 OS_ERR_PRIO_INVALID            if the priority you specify is higher that the maximum
*                                                                   allowed (i.e. >= OS_CFG_PRIO_MAX-1) or,
*                                                                if OS_CFG_ISR_POST_DEFERRED_EN is set to 1 and you tried
*                                                                   to use priority 0 which is reserved.
*                                 OS_ERR_STK_INVALID             if you specified a NULL pointer for 'p_stk_base'
*                                 OS_ERR_STK_SIZE_INVALID        if you specified zero for the 'stk_size'
*                                 OS_ERR_STK_LIMIT_INVALID       if you specified a 'stk_limit' greater than or equal
*                                                                   to 'stk_size'
*                                 OS_ERR_TASK_CREATE_ISR         if you tried to create a task from an ISR.
*                                 OS_ERR_TASK_INVALID            if you specified a NULL pointer for 'p_task'
*                                 OS_ERR_TCB_INVALID             if you specified a NULL pointer for 'p_tcb'
*
* Returns    : A pointer to the TCB of the task created.  This pointer must be used as an ID (i.e handle) to the task.
************************************************************************************************************************
*/

任务创建函数

void  OSTaskCreate (OS_TCB        *p_tcb, //任务控制块，由用户自己定义。
                    CPU_CHAR      *p_name, //任务名字，字符串形式，这里任务名字最好要与任务函数入口名字一致，方便进行调试。
                    OS_TASK_PTR    p_task,//：任务入口函数，即任务函数的名称，需要我们自己定义并且实现。
                    void          *p_arg,//任务入口函数形参，不用的时候配置为 0 或者 NULL 即可，p_arg是指向可选数据区域的指针，用于将参数传递给任务，因为任务一旦执行，那必须是在一个死循环中，所以传参只在首次执行时有效。
                    OS_PRIO        prio,//任务的优先级，由用户自己定义。
                    CPU_STK       *p_stk_base,//指向堆栈基址的指针（即堆栈的起始地址）。
                    CPU_STK_SIZE   stk_limit,//设置堆栈深度的限制位置。这个值表示任务的堆栈满溢之前剩余的堆栈容量。例如，指定 stk_size 值的 10％表示将达到堆栈限制，当堆栈达到 90％满就表示任务的堆栈已满。
                    CPU_STK_SIZE   stk_size,//任务堆栈大小，单位由用户决定，如果 CPU_STK 被设置为CPU_INT08U，则单位为字节，而如果 CPU_STK 被设置为 CPU_INT16U，则单位为半字，同理，如果 CPU_STK 被设置为 CPU_INT32U，单位为字。在 32 位的处理器下（STM32），一个字等于 4 个字节，那么任务大小就为 APP_TASK_START_STK_SIZE * 4 字节。
                    OS_MSG_QTY     q_size,//设置可以发送到任务的最大消息数，按需设置即可。
                    OS_TICK        time_quanta,//在任务之间循环时的时间片的时间量（以滴答为单位）。指定 0则使用默认值
                    void          *p_ext,//是指向用户提供的内存位置的指针，用作 TCB 扩展。例如，该用户存储器可以保存浮点寄存器的内容在上下文切换期间，每个任务执行的时间，次数、任务已经切换等。
                    OS_OPT         opt,//用户可选的任务特定选项
                    OS_ERR        *p_err);//用于保存返回的错误代码。

启动任务和删除任务

删除任务函数

void  OSTaskDel (OS_TCB  *p_tcb,
                 OS_ERR  *p_err);

启动任务函数

void  OSStart (OS_ERR  *p_err);

系统内部任务

1、空闲任务

void  OS_IdleTask (void  *p_arg)

2、时钟节拍任务

void  OS_TickTask (void  *p_arg);

3、统计任务

void  OSStatTaskCPUUsageInit (OS_ERR  *p_err)

4、定时任务

void  OS_TmrInit (OS_ERR  *p_err);

5、中断服务任务

void  OS_IntQTask(void *p_arg);

6、钩子函数

void  OSIdleTaskHook(void);

消息队列

后面再写。

sayang_shao
关注
  • 28
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STM32的IIC
小草光明与嵌入式
01-01 9679
经过一天的奋斗，从零基础学习IIC，感觉到这个总线真的很强大，有点驾驭不了，比着各种资料和stm32官方库的头文件写着自己摸不着头脑的程序，很苦闷的一天啊。 MMA7455L加速度传感器IIC总线器件地址0x1d，在stm32固件库（V3.5）中应这样描述 I2C_Send7bitAddress(I2C1,0x1d 使用I2C1接口，方向为发送器； 在每次发送数据或地址后务必等待ACK应答
uC/OS-III移植STM32F103C8T6范例工程
10-14
《uC/OS-III在STM32F103C8T6上的移植与应用实践》 uC/OS-III是一款流行的实时操作系统（RTOS），它以其高效、稳定和可扩展性受到众多嵌入式开发者的青睐。STM32F103C8T6是意法半导体（STMicroelectronics）生产的一...
五大嵌入式操作系统
hbl_hz的博客
11-27 4235
[掌握这五大嵌入式操作系统，你就是STM32牛人 技术往往更新得非常快，并且总是让我们觉得学起来有难度而且有些迷茫。不过没有关系我们发烧友专注于在快乐中学习，要学习STM32，我们首先了解下五大嵌入式操作系统：μClinux、μC／OS-II、eCos、FreeRTOS和RT-thread。 TOP1：μClinux μClinux是一种优秀的嵌入式Linux版本，从字面意思看...
【uC/OS-III篇】uC/OS-III 移植到 STM32 简明教程
晨少的博客
03-31 2125
uC/OS-III 是 MicroC/OS-III 的一种版本，是由 Micrium 公司开发的一款实时操作系统（RTOS）。以下是有关 uC/OS-III 的一些介绍：发布时间和来源：uC/OS-III 于 2008 年发布，由 Jean Labrosse 创立的 Micrium 公司开发。Micrium 公司专注于提供嵌入式系统软件解决方案，包括实时操作系统、TCP/IP 协议栈、USB 协议栈等。
UCOS-III任务调度
m0_56326397的博客
05-09 739
任务控制块是用来记录与任务相关的信息的数据结构，每个任务都要有自己的任务控制块。没有用完的时间片不会再使用，如果有任务在执行时被中途挂起了，那么下次执行这个任务的时候还是。是一个结构体，描述任务控制块，任务控制块的成员比哪里用户不能直接访问，更不能改变他们。允许一个优先级下多个任务，每个任务可以执行指定时间（时间片），然后轮到下一个任务，这个。针对优先级相同的任务，多个任务优先级相同且就绪时，任务调度器会根据用户设置的时间片轮。挂起态：一个运行态的任务因延时或等待某一事件发生时被挂起，这个任务处于挂起态。
CenterV1.1_uC/OS-III_emwin_STM32F470_
10-03
标题“CenterV1.1_uC/OS-III_emwin_STM32F470_”揭示了这是一个关于物联网(IoT)集中器的项目，版本为V1.1，它采用了嵌入式实时操作系统(uC/OS-III)，图形用户界面库(eMWin)，并基于STM32F470微控制器。这个项目集成...
uc/OS-IIv2.86移植在STM32
12-22
【标题】"uc/OS-IIv2.86移植在STM32"涉及的主要知识点是嵌入式系统中的实时操作系统（RTOS）移植和微控制器应用。uC/OS-II是一款广泛应用的开源RTOS，专为微处理器设计，具有抢占式多任务调度、内存管理、信号量、...
UC/OS-III移植样例
10-26
这个"UC/OS-III移植样例"项目是将UC/OS-III操作系统成功移植到STM32F107微控制器上的实例。 首先，移植UC/OS-III到STM32F107的过程中，你需要理解UC/OS-III的体系结构。UC/OS-III的核心包括任务管理、时间管理、...
stm32学习笔记：基于uC/OS-III多任务实验
01-11
在本学习笔记中，我们将深入探讨如何在STM32平台上实现基于uC/OS-III的多任务实验。uC/OS-III是一种实时操作系统（RTOS），为嵌入式系统提供了高效的多任务调度和管理能力。 首先，我们需要了解uC/OS-III的基本概念...
STM32智能仓库管理系统教程
stm32d1219的博客
07-14 617
本教程详细介绍了如何在STM32嵌入式系统中实现智能仓库管理系统，从硬件选择、软件实现到系统配置和应用场景都进行了全面的阐述。通过合理的技术选择和系统设计，可以构建一个高效且功能强大的智能仓库管理系统。
中科微电子ATGM336H GPS定位模块STM32应用
最新发布
weixin_47577143的博客
07-15 1101
GPS模块的使用，以及STM32移植代码
STM32+三色LED智能调光系统源程序 易安卓APP 原理图
qq_35654286的博客
07-14 263
利用开发的智能手机软件，对照明三色LED进行智能调光。包含的功能有，支持多手机同时连接服务端，互动调光。支持关闭照明，快捷设置灯光颜色，支持自定义灯光的颜色。理论上支持无限种色彩。ESP8266：WIFI信号接收端。STM32F030F4：主控制器。IRFP1205：LED驱动。
【stm32】GPIO介绍及使用
qq_62917398的博客
07-14 923
GPIO（General Purpose Input Output）通用输入输出口可配置为8种输入输出模式引脚电平：0V~3.3V，部分引脚可容忍5V输出模式下可控制端口输出高低电平，用以驱动LED、控制蜂鸣器、模拟通信协议输出时序等输入模式下可读取端口的高低电平或电压，用于读取按键输入、外接模块电平信号输入、ADC电压采集、模拟通信协议接收数据等1.LED：发光二极管，正向通电点亮，反向通电不亮发光二极管如何分辨正负极：如果是引脚没有剪过的LED，那其中长脚是正极，短脚是负极。
STM32之八：IIC通信协议
guaizaiguaizai的博客
07-15 889
IIC协议是一个半双工、同步、一主多从、多主多从的串行通用数据总线。该通信模式需要2根线：SCL、SDA，即时钟线和数据线。
STM32自己从零开始实操：PCB全过程
Xuexi_touteng的博客
07-15 251
其他的都是个人经验，我也不知道该怎么描述，只可意会，不可言传把。
STM32智能农业监测系统教程
stm32d1219的博客
07-15 1595
本教程详细介绍了如何在STM32嵌入式系统中实现智能农业监测系统，从硬件选择、软件实现到系统配置和应用场景都进行了全面的阐述。通过合理的技术选择和系统设计，可以构建一个高效且功能强大的智能农业监测系统。
STM32+TMC2209控制步进电机正反转。
eettttttt的博客
07-15 866
本实验采用2项步进电机，电机只有2项，A+\A-\B+\B-。电机步距角1.8°8细分控制精度=1.8°/8=0.225°，电机转一周需要1600个脉冲。16细分控制精度=1.8°/16=0.1125°，电机转一周需要3200个脉冲。32细分控制精度=1.8°/32=0.05625°，电机转一周需要6400个脉冲。64细分控制精度=1.8°/64=0.0140625°，电机转一周需要12800个脉冲。满足绝大多数精度场景，如低精度机床、家电、3D打印等。
STM32智能医疗监测系统教程
2401_84204806的博客
07-15 1005
本教程详细介绍了如何在STM32嵌入式系统中实现智能医疗监测系统，从硬件选择、软件实现到系统配置和应用场景都进行了全面的阐述。通过合理的技术选择和系统设计，可以构建一个高效且功能强大的智能医疗监测系统。在未来的发展中，智能医疗监测系统可以进一步结合人工智能和大数据分析技术，提升系统的智能化程度，为医疗监测和管理提供更强大的技术支持。希望本教程能够为读者提供有价值的参考和指导，助力智能医疗监测系统的开发与实现。
uC/OS-III实时内核详解
屈环宇在翻译过程中分享了他的学习经历和移植uC/OS-III到STM32F103RB处理器的成功案例，表明了该系统不仅理论性强，而且具有很高的实践价值。通过他的努力，中文社区的开发者们有了更便于理解的参考资料，有助于他们...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值