uCOS-III 函数整理

xiaoxiao2026-01-12 1

学uC/OS-III的时候觉得这些常用的函数找起来太麻烦，便整理在一起，方便复制粘贴用。

更改任务优先级

void OSTaskChangePrio( OS_TCB *p_tcb, //需要更改优先级的任务函数名称。可以为空，即改变当前任务优先级。

OS_PRIO prio_new, //需要更改的新优先级。不能为0和大于或等于OS_CFG_PRIO_MAX-1的数值。

OS_ERR *p_err);

OSTaskChangePrio((OS_TCB *)&Main2TaskLedTCB, 3, &err);

if(OS_ERR_NONE == err)

{

printf("Main2Task Change Prio To 3 Success\n");

}

任务创建

OSTaskCreate( (OS_TCB *)&AppTaskStartTCB,/*创建任务控制块 */

(CPU_CHAR *)"App Task Start",/*非任务函数名称，系统本身不知道任务名称，仅知道任务地址与指针，此为输出或调试时使用任务名称的代替字符串*/

(OS_TASK_PTR )AppTaskStart,

(void *)0u,/*定义函数形参，可以为&取址全局变量。若只有局部变量，可用static定义局部变量*/

(OS_PRIO )APP_CFG_TASK_START_PRIO, /*任务优先级*/

(CPU_STK *)&AppTaskStartStk[0u],/*给任务分配的RAM，0为首地址*/

(CPU_STK_SIZE )APP_CFG_TASK_START_STK_SIZE / 10u,/*堆栈溢出警戒线*/

(CPU_STK_SIZE )APP_CFG_TASK_START_STK_SIZE,/*堆栈大小*/

(OS_MSG_QTY )0u,

(OS_TICK )0u,

(void *)0u,/*需打开浮点开关，存储浮点数至外扩区域。定义全局CPU_INT32U out_buf[256];则此处填写out_buf[0]或者out_buf（外扩区首地址）*/

(OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR | OS_OPT_TASK_SAVE_FP),

/* CPU支持选项OS_OPT_TASK_STK_CHK是否允许检测该任务堆栈

OS_OPT_TASK_STK_CLR是否需要清零该任务堆栈

OS_OPT_TASK_SAVE_FP是否储存浮点运算寄存器*/

(OS_ERR *)&err);

OS_ERR err;

OSTaskCreate((OS_TCB *)&Main3TaskLedTCB,/*创建任务控制块 */

(CPU_CHAR *)"Main3",

(OS_TASK_PTR )main3,

(void *)10u,/*定义函数形参，可以为&取址全局变量。若只有局部变量，可用static定义局部变量*/

(OS_PRIO )3,/*任务优先级*/

(CPU_STK *)&Main3TaskLedStk[0u],

(CPU_STK_SIZE )APP_CFG_TASK_START_STK_SIZE / 10u,

(CPU_STK_SIZE )APP_CFG_TASK_START_STK_SIZE,

(OS_MSG_QTY )0u,

(OS_TICK )0u,

(void *)0u,/*浮点开关。定义全局CPU_INT32U out_buf[256];则此处填写out_buf*/

(OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),

(OS_ERR *)&err);

钩子函数

在主函数前添加钩子函数

void MyAppCreateHook(OS_TCB *p_tcb) //形参填写任务函数名称

{

printf("任务%s被创建\n",p_tcb->NamePtr);

}

在主函数中添加

OS_AppTaskCreateHookPtr = (OS_APP_HOOK_TCB)MyAppCreateHook;

删除任务

OS_ERR err;

if(*key == 'd')

{

printf("KeyHook Get key:%c\n",*key);

OSTaskDel(&Main3TaskLedTCB,&err);

if(OS_ERR_NONE == err)

{

printf("Del main3 success!!\n");

}

*key = 0;

}

不可重入数组赋值

void OSTaskRegSet (OS_TCB *p_tcb,//任务指针，NULL即为当前任务

OS_REG_ID id,//数组下标

OS_REG value,//数组[id]中的值

OS_ERR *p_err)

OS_ERR err;

OS_REG reg;

if(*key == 's')

{

printf("KeyHook Get key:%c\n",*key);

OSTaskRegSet(&Main3TaskLedTCB,3,126,&err);

printf("Set reg = 126\n");

*key = 0;

}

不可重入数组取值

OS_ERR err;

OS_REG reg;

if(*key == 'g')

{

printf("KeyHook Get key:%c\n",*key);

reg = OSTaskRegGet(&Main3TaskLedTCB,3,&err);

printf("Get reg = %d\n",reg);

*key = 0;

}

任务挂起

OS_ERR err;

if(*key == 'u')

{

printf("KeyHook Get key:%c\n",*key);

OSTaskSuspend(&Main3TaskLedTCB,&err);

if(OS_ERR_NONE == err)

{

printf("Main3 has been suspend success!!\n");

}

*key = 0;

}

挂起任务恢复任务被挂起几次需调用几次此函数

OS_ERR err;

if(*key == 'r')

{

printf("KeyHook Get key:%c\n",*key);

OSTaskResume(&Main3TaskLedTCB,&err);

if(OS_ERR_NONE == err)

{

printf("Main3 resumed success!!\n");

}

*key = 0;

}

堆栈检查函数

OS_ERR err;

CPU_STK_SIZE free,used;

if(*key == 't')

{

printf("KeyHook Get key:%c\n",*key);

OSTaskStkChk(&Main3TaskLedTCB,&free,&used,&err);

if(OS_ERR_NONE == err)

{

printf("free = %d,used = %d\n",free,used);

}

*key = 0;

}

硬件定时器

主函数中初始化：TIM3_Init(2563,65535);

Time.h

#ifndef __TIMER_H

#define __TIMER_H

#include "stm32f4xx_conf.h"

void TIM3_Init(u32 TIM_scale, u32 TIM_Period);

#endif

Timer.c

#include "timer.h"

#include <includes.h>

中断函数

void TIM3_ISR(void)

{

if(TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)

{

TIM_ClearITPendingBit(TIM3, TIM_IT_Update);

}

void TIM3_Init(u32 TIM_scale, u32 TIM_Period)//TIM_Period为16位的数

{

TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;

NVIC_InitTypeDef NVIC_InitStructure;

RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);

NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;

NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;

NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;

NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

NVIC_Init(&NVIC_InitStructure);

TIM_TimeBaseStructure.TIM_Period = TIM_Period;//计数器重装值

TIM_TimeBaseStructure.TIM_Prescaler = 0;

TIM_TimeBaseStructure.TIM_ClockDivision = 0;

TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;

TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);

TIM_PrescalerConfig(TIM3, (TIM_scale-1), TIM_PSCReloadMode_Immediate);

BSP_IntVectSet (BSP_INT_ID_TIM3,(CPU_FNCT_VOID)TIM3_ISR);

TIM_ITConfig(TIM3, TIM_IT_Update, ENABLE);

TIM_Cmd(TIM3, ENABLE);

}

软件定时器

OS_TMR tmrTest;//定时器名字

OS_ERR err;

void TmrTestIsr(void) //中断函数

{

printf("TmrTestIsr\n");

}

void OSTmrCreate (OS_TMR *p_tmr, //定时器名字

CPU_CHAR *p_name, //调试调用名称

OS_TICK dly, //若是选择单次模式则为定时长度dly*10ms，若为周期模式则为前等待dly*10ms后开始进入周期循环，

OS_TICK period, //单次模式下为0，周期模式下为定时器周期间隔

OS_OPT opt,//OS_OPT_TMR_ONE_SHOT单次模式。 OS_OPT_TMR_PERIODIC周期模式

OS_TMR_CALLBACK_PTR p_callback, //中断函数名称exc:(OS_TMR_CALLBACK_PTR)TmrTestIsr

void *p_callback_arg, //定时结束传递给回调函数的参数（形参初值）

OS_ERR *p_err) //错误返回

OSTmrCreate(&tmrTest,"TimerTest",100,200,OS_OPT_TMR_PERIODIC,(OS_TMR_CALLBACK_PTR)TmrTestIsr,(void *)0,&err);//100*10ms后开始运行，每200*10ms进一次中断。

OSTmrStart(&tmrTest,&err);//使能定时器

printf("OSTimeTick = %ld\n",OSTimeGet(&err));

延时函数

ucos内核驱动心脏：OSTimeTick()

这里在os_cpu_c.c的OS_CPU_SysTickHandler()中

我们需要让他跑起来，只需要不停的调用它就可以了，至于是定时器还是其他，如按键触发

都无所谓，定时器触发只是提供了一个准确的时间

OS_ERR err;

void OSTimeDly (OS_TICK dly, //滴答时钟计数数值. 为0时表示不拖延。1000表示1000ms

OS_OPT opt, //相对模式、周期模式（指定多长时间间隔执行一次）、绝对模式(OSTickCtr >= dly时程序不再停止在此函数)

OS_ERR *p_err) //错误返回值

void OSTimeDlyHMSM (CPU_INT16U hours,

CPU_INT16U minutes,

CPU_INT16U seconds,

CPU_INT32U milli,

OS_OPT opt, // ————

OS_ERR *p_err)// |

// |

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

// OS_OPT_TIME_HMSM_STRICT strictly allow only hours (0...99)

// Minutes (0...59)

// seconds (0...59)

// Milliseconds (0...999)

// OS_OPT_TIME_HMSM_NON_STRICT allow any value of hours (0...999)

minutes (0...9999)

seconds (0...65535)

milliseconds (0...4294967295)

if(*key == 'y')

{

printf("KeyHook Get key:%c\n",*key);

OSTimeDlyResume(&Main3TaskLedTCB,&err);//main3的延时本次跳出

if(OS_ERR_NONE == err)

{

printf("Main3 Dly Resumed!\n");

}

*key = 0;

}

查看系统计数器

OS_ERR err;

ucos有个系统计数器：OSTickCtr 这个是全局变量

printf("OSTimeTick = %ld\n",OSTimeGet(&err));

开关总中断

void main2(char *arg)

{

CPU_SR_ALLOC();

OS_ERR err;

while(1)

{

OS_CRITICAL_ENTER();

//。。。

OS_CRITICAL_EXIT();

OSTimeDlyHMSM(0u, 0u, 0u, 10u,OS_OPT_TIME_HMSM_STRICT,&err);//让出CPU，并且附带了DelayMs的功能

}

任务调度上锁、解锁

OS_ERR err;

OSSchedLock(&err);

//。。。

OSSchedUnlock(&err);

创建互斥信号量（对象创建）

OS_MUTEX atom1Section;

OS_ERR err;

void OSMutexCreate (OS_MUTEX *p_mutex,//互斥信号量指针

CPU_CHAR *p_name,//调试用的字符串名称

OS_ERR *p_err)

OSSemCreate(&atom1Section,"atom1Section",&err);

创建信号量（对象创建）

OS_SEM atom1Section;

OS_ERR err;

void OSSemCreate (OS_SEM *p_sem,//信号量指针

CPU_CHAR *p_name,//调试用的字符串名称

OS_SEM_CTR cnt,//创建几个信号量

OS_ERR *p_err)

OSSemCreate(&atom1Section,"atom1Section",1,&err);

接收、发送互斥信号量

OS_ERR err;

void OSMutexPend (OS_MUTEX *p_mutex,//互斥信号量指针

OS_TICK timeout,//等待信号量超时时间，若超时则任务恢复执行不在挂起。若为0，一直等。不精确

OS_OPT opt,//是否选择阻塞模式OS_OPT_PEND_BLOCKING无信号量时，任务挂起等待信号量

//OS_OPT_PEND_NON_BLOCKING无信号量任务直接返回

CPU_TS *p_ts,//NULL表示用户不要求时间戳.发送信号亮至任务恢复的时间delta=OS_TS_GET() - * P_ts;

OS_ERR *p_err)

void OSMutexPost (OS_MUTEX *p_mutex,//互斥信号量指针

OS_OPT opt,//OS_OPT_POST_NONE NULL

//OS_OPT_POST_NO_SCHED 发送后禁止任务调度？？？？？

接收、发送信号量

OS_ERR err;

OS_SEM_CTR OSSemPend (OS_SEM *p_sem,//信号量指针

OS_TICK timeout,//等待信号量超时时间，若超时则任务恢复执行不在挂起。若为0，一直等。不精确

OS_OPT opt,//是否选择阻塞模式OS_OPT_PEND_BLOCKING无信号量时，任务挂起等待信号量

//OS_OPT_PEND_NON_BLOCKING无信号量任务直接返回

CPU_TS *p_ts,//NULL表示用户不要求时间戳.发送信号亮至任务恢复的时间delta=OS_TS_GET() - * P_ts;

OS_ERR *p_err)

OS_SEM_CTR OSSemPost (OS_SEM *p_sem,

OS_OPT opt,//选择信号量发送方式

//OS_OPT_POST_1 仅向等待该信号量的优先级最高的任务发送

//OS_OPT_POST_ALL 想等待该信号量的所有任务发送。不能用作资源共享时使用，仅用作信号机制

//OS_OPT_POST_NO_SCHED 发送后禁止任务调度

OS_ERR *p_err)

OSSemPend(&atom1Section,0,OS_OPT_PEND_BLOCKING,NULL,&err);

。。。

OSSemPost(&atom1Section,OS_OPT_POST_1,&err);

终止任务等待互斥信号量

OS_OBJ_QTY OSMutexPendAbort (OS_MUTEX *p_mutex,//互斥信号量指针

OS_OPT opt,//OS_OPT_PEND_ABORT_1 仅终止等待该信号量的最高优先级任务

//OS_OPT_PEND_ABORT 终止所有等待该信号量的任务

//OS_OPT_POST_NO_SCHED 取消等待信号量后禁止任务调度

OS_ERR *p_err)

终止任务等待信号量

OS_ERR err;

OS_OBJ_QTY OSSemPendAbort (OS_SEM *p_sem,//信号量指针

OS_OPT opt, //OS_OPT_PEND_ABORT_1 仅终止等待该信号量的最高优先级任务

//OS_OPT_PEND_ABORT 终止所有等待该信号量的任务

//OS_OPT_POST_NO_SCHED 取消等待信号量后禁止任务调度

OS_ERR *p_err)

if(*key == 'f')

{

printf("KeyHook Get key:%c\n",*key);

semAbortCnt = OSSemPendAbort(&atom1Section,OS_OPT_PEND_ABORT_ALL,&err);

if(OS_ERR_NONE == err)

{

printf("atom1Section Aborded = %d\n",semAbortCnt);

}

*key = 0;

}

终止任务等待任务信号量

OS_ERR err;

CPU_BOOLEAN OSTaskQPendAbort (OS_TCB *p_tcb,//任务指针

OS_OPT opt, //OS_OPT_POST_NONE无指定

//OS_OPT_POST_NO_SCHED 取消等待信号量后禁止任务调度

OS_ERR *p_err)

终止任务等待事件标志组

OS_OBJ_QTY OSFlagPendAbort (OS_FLAG_GRP *p_grp,//事件标志组指针myEventFlag

OS_OPT opt,//OS_OPT_PEND_ABORT_1 仅终止等待该信号量的最高优先级任务

//OS_OPT_PEND_ABORT 终止所有等待该信号量的任务

//OS_OPT_POST_NO_SCHED 取消等待信号量后禁止任务调度

OS_ERR *p_err)

接收、发送任务信号量

OS_ERR err;

OS_SEM_CTR OSTaskSemPend (OS_TICK timeout,//等待信号量超时时间，若超时则任务恢复执行不在挂起。若为0，一直等。不精确

OS_OPT opt,//是否选择阻塞模式OS_OPT_PEND_BLOCKING无信号量时，任务挂起等待信号量

//OS_OPT_PEND_NON_BLOCKING无信号量任务直接返回

CPU_TS *p_ts,//NULL表示用户不要求时间戳.发送信号量至任务恢复的时间delta=OS_TS_GET() - * P_ts;

OS_ERR *p_err)

OS_SEM_CTR OSTaskSemPost (OS_TCB *p_tcb,//任务指针

OS_OPT opt,//OS_OPT_PEND_BLOCKING 无指定

//OS_OPT_PEND_NON_BLOCKING发送后禁止任务调度

OS_ERR *p_err

删除互斥信号量

OS_ERR err;

OS_OBJ_QTY OSMutexDel (OS_MUTEX *p_mutex,//信号量指针

OS_OPT opt,//OS_OPT_DEL_NO_PEND 没有任务等待这个信号量时才删除

// OS_OPT_DEL_ALWAYS 不管是否有任务在等待信号量都删除此信号量。等待该信号量的任务进入就绪状态

OS_ERR *p_err)

删除信号量

OS_ERR err;

OS_OBJ_QTY OSSemDel (OS_SEM *p_sem,//信号量指针

OS_OPT opt,//OS_OPT_DEL_NO_PEND 没有任务等待这个信号量时才删除

// OS_OPT_DEL_ALWAYS 不管是否有任务在等待信号量都删除此信号量。等待该信号量的任务进入就绪状态

OS_ERR *p_err)

if(*key == 'j')

{

printf("KeyHook Get key:%c\n",*key);

OSSemDel(&atom1Section,OS_OPT_DEL_ALWAYS,&err);

if(OS_ERR_NONE == err)

{

printf("atom1Section OSSemDel！\n");

}

*key = 0;

}

修改信号量计数值

OS_ERR err;

void OSSemSet (OS_SEM *p_sem,//信号量指针

OS_SEM_CTR cnt,//需设定的信号量计数值

OS_ERR *p_err)

修改任务信号量计数值

OS_ERR err;

OS_SEM_CTR OSTaskSemSet (OS_TCB *p_tcb,//任务指针

OS_SEM_CTR cnt,几个信号量

OS_ERR *p_err))

创建事件标志组

OS_FLAG_GRP myEventFlag;

OS_ERR err;

#define MY_EVENT_BIT00x01

#define MY_EVENT_BIT1 0x02

#define MY_EVENT_BIT2 0x04

void OSFlagCreate (OS_FLAG_GRP *p_grp,//事件标志组指针myEventFlag;

CPU_CHAR *p_name,//调试用的字符串名称

OS_FLAGS flags,//MY_EVENT_BIT0 MY_EVENT_BIT1 MY_EVENT_BIT2。。。

OS_ERR *p_err)

OSFlagCreate(&myEventFlag,"myEventFlag",0,&err);

删除事件标志组

OS_ERR err;

OS_OBJ_QTY OSFlagDel (OS_FLAG_GRP *p_grp, //事件标志组指针myEventFlag

OS_OPT opt,//OS_OPT_DEL_NO_PEND 没有任务等待这个事件标志组时才删除

//OS_OPT_DEL_ALWAYS 不管是否有任务在等待这个事件标志组都删除，若在等待的任务会进入就绪态

OS_ERR *p_err)

接收、发送事件标志组

OS_ERR err;

OS_FLAGS OSFlagPend (OS_FLAG_GRP *p_grp,//任务事件标志组指针myEventFlag

OS_FLAGS flags,//MY_EVENT_BIT0、MY_EVENT_BIT1、MY_EVENT_BIT2。可以相加

OS_TICK timeout,//等待事件标志组的超时时间，若超时则任务恢复执行不在挂起。若为0，一直等。不精确

OS_OPT opt,//OS_OPT_PEND_FLAG_CLR_ALL 等待所有标志组置0

OS_OPT_PEND_FLAG_CLR_ANY 等待标志组任意一个标志置0

OS_OPT_PEND_FLAG_SET_ALL 等代标志组的所有标志位被置1

OS_OPT_PEND_FLAG_SET_ANY 等待标志组的任意一个标志位被置1

若需条件满足后事件标志组的置1标志位清零+ OS_OPT_PEND_FLAG_CONSUME

CPU_TS *p_ts,//NULL表示用户不要求时间戳.发送信号量至任务恢复的时间delta=OS_TS_GET() - * P_ts;

OS_ERR *p_err)

OSFlagPend(&myEventFlag,MY_EVENT_BIT0 + MY_EVENT_BIT1,0,OS_OPT_PEND_FLAG_SET_ALL + OS_OPT_PEND_FLAG_CONSUME,NULL,&err);

OS_FLAGS OSFlagPost (OS_FLAG_GRP *p_grp,//任务事件标志组指针myEventFlag

OS_FLAGS flags,//填写对哪些标志位置1或置0

OS_OPT opt,//OS_OPT_POST_FLAG_SET 置1有效

//OS_OPT_POST_FLAG_CLR 置0有效

//若上面两个选项 + OS_OPT_POST_NO_SCHED ，在发送信号后不会调用任务调度。

OS_ERR *p_err)

OSFlagPost(&myEventFlag,MY_EVENT_BIT2,OS_OPT_POST_FLAG_SET + OS_OPT_POST_NO_SCHED,&err);

获取使任务进入就绪状态的事件标志组的标志位

OS_FLAGS rdyFLags;

OS_ERR err;

rdyFLags = OSFlagPendGetFlagsRdy(&err);

printf("rdyFLags = %d\n",rdyFLags);

创建消息列队

OS_Q myAdQ;

OS_ERR err;

void OSQCreate (OS_Q *p_q,//消息列队指针

CPU_CHAR *p_name,//调试用字符串名称

OS_MSG_QTY max_qty,消息列队最大长度，必须非零

OS_ERR *p_err)

OSQCreate(&myAdQ,"myAdQ",10,&err);

接收、发送消息列队

OS_ERR err;

void *OSQPend (OS_Q *p_q,//消息列队指针

OS_TICK timeout,//等待消息队列的超时时间，若超时则任务恢复执行不在挂起。若为0，一直等。不精确

OS_OPT opt,//OS_OPT_PEND_BLOCKING一直等

//OS_OPT_PEND_NON_BLOCKING

OS_MSG_SIZE *p_msg_size,//指向一个变量，表示收到消息的大小

CPU_TS *p_ts,//NULL表示用户不要求时间戳.发送信号量至任务恢复的时间delta=OS_TS_GET() - * P_ts;

OS_ERR *p_err)

pAdBuf = (CPU_INT08U *)OSQPend(&myAdQ,0,OS_OPT_PEND_BLOCKING,(OS_MSG_SIZE *)&nSize,NULL,&err);

for(i = 0;i < nSize;i ++)

{

if((i % 10) == 0)printf("\n");

printf("%02x ",pAdBuf[i]);

}

OS_ERR err;

void OSQPost (OS_Q *p_q,//消息列队指针

void *p_void,//发送的内容

OS_MSG_SIZE msg_size,//设置消息的大小

OS_OPT opt, //OS_OPT_POST_FIFO先进先出

//OS_OPT_POST_LIFO后进后出

// + OS_OPT_POST_ALL将消息发送给所有等待该消息列队的任务，若不设置，则发送给优先级最高的

// + OS_OPT_POST_NO_SCHED禁止本函数任务调度

OS_ERR *p_err)

OSQPost(&myAdQ,(void *)ucAdBuf[n],AD_BUF_SIZE,OS_OPT_POST_FIFO,&err);

终止任务等待消息队列返回操作成功的任务数量

OS_ERR err;

OS_OBJ_QTY OSQPendAbort (OS_Q *p_q,//消息队列名称

OS_OPT opt,//OS_OPT_PEND_ABORT_1 仅终止等待该信号量的最高优先级任务

//OS_OPT_PEND_ABORT 终止所有等待该信号量的任务

//OS_OPT_POST_NO_SCHED 取消等待信号量后禁止任务调度

OS_ERR *p_err)

清空消息队列返回释放的消息数量

OS_MSG_QTY OSQFlush (OS_Q *p_q,//消息队列指针

OS_ERR *p_err)

等待多个内核对象返回等待中可用对象数目

OS_PEND_DATA mPendBuf[2];

OS_ERR err;

OS_OBJ_QTY OSPendMulti (OS_PEND_DATA *p_pend_data_tbl,//mPendBuf[2];

OS_OBJ_QTY tbl_size,//等待对象的数目

OS_TICK timeout,//等待消息队列的超时时间，若超时则任务恢复执行不在挂起。若为0，一直等。不精确

OS_OPT opt,//OS_OPT_PEND_BLOCKING一直等

//OS_OPT_PEND_NON_BLOCKING

OS_ERR *p_err)

nObjPend = OSPendMulti(mPendBuf,2,0,OS_OPT_PEND_BLOCKING,&err);

创建内存分区

OS_MEM myMemMng;

CPU_INT08U myMemPartion[4][100];

OS_ERR err;

void OSMemCreate (OS_MEM *p_mem,//内存控制块指针

CPU_CHAR *p_name,调试用字符串名称

void *p_addr,//创建数组(void *)&myMemPartion[0][0]

OS_MEM_QTY n_blks,//分区内内存块数量

OS_MEM_SIZE blk_size,//每个内存块大小

OS_ERR *p_err)

OSMemCreate(&myMemMng,"myMemMng",(void *)&myMemPartion[0][0],4,100,&err);

将内存块返回内存分区

void OSMemPut (OS_MEM *p_mem,//内存控制块指针myMemMng;

void *p_blk,//要释放的内存块

OS_ERR *p_err)

OSMemPut(&myMemMng,(void *)pAdBuf,&err);

从内存分区获取控制块返回被分配内存块指针

void *OSMemGet (OS_MEM *p_mem,//内存控制块指针myMemMng;

OS_ERR *p_err)

pBuf = OSMemGet(&myMemMng,&err);

转载请注明原文地址: https://ju.6miu.com/read-1305912.html

最新回复(0)