学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);
884
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
