uC/OS-II 函数之信号量相关函数

上文主要介绍了时间相关的函数，本文介绍信号量相关的函数：OSSemCreate()建立信号量函数,OSSemPend()取得使用权函数,OSSemPost()使用权递加函数

信号量介绍

如果我们想对一个公共资源进行互斥访问，例如：如果我们想让两个任务Task1和Task2都可以调用Fun()函数，但不能同时调用，最好定义信号量：Semp = OSSemCreate(1)，同理在各自的任务中都需要调用OSSemPend(Semp,0,&err)请求此信号量，如果可用，则调用Fun（），然后再用OSSemPost(Semp)释放该信号量。这里就实现了一个资源的互斥访问。
（注：初始化OSSemCreate(1)，那么一个任务中有OSSemPend，那么可以执行，执行之后cnt==0，其他任务的OSSemPend无法获得sem，只能等待，除非任务一有OSSemPost，使其cnt++，这样其他任务的Pend可以执行。）
同理，如果一个任务要等待n个事件发生后才能执行，则应定义为Semp = OSSemCreate(n)。然后在这n个任务分别运行时调用OSSemPost(Semp),直到这n个事件均发生后，这个任务才能运行。
OSSemCreate(cnt)赋初始值cnt，OSSemPend一次，cnt– 一次，OSSemPost一次，cnt++一次。

下面对信号量函数做简要介绍：

OSSemCreate()建立信号量函数

1、主要作用：该函数建立并初始化一个信号量，信号量的作用如下：
允许一个任务和其他任务或者中断同步
取得设备的使用权
标志事件的发生
2、函数原型：OS_EVENT *OSSemCreate(INT16U value);
3、参数说明：value 参数是所建立的信号量的初始值，可以取0到65535之间的任何值。
4、返回值：OSSemCreate() 函数返回指向分配给所建立的信号量的控制块的指针。如果没有可用的控制块，OSSemCreate() 函数返回空指针。
5、函数主体在os_sem.c中

OSSemPend()取得使用权函数

1、主要作用： 该函数用于任务试图取得设备的使用权、任务需要和其他任务或中断同步、任务需要等待特定事件的发生的场合。如果任务调用OSSemPend() 函数时，信号量的值大于零，OSSemPend() 函数递减该值。如果调用时信号量值等于零，OSSemPend() 函数将任务加入该信号量的等待队列。OSSemPend() 函数挂起当前任务直到其他的任务或中断设置信号量或超出等待的预期时间。如果在预期的时钟节拍内信号量被设置，μC/OS-Ⅱ默认让最高优先级的任务取得信号量并回到就绪状态。一个被OSTaskSuspend() 函数挂起的任务也可以接受信号量，但这个任务将一直保持挂起状态直到通过调用OSTaskResume() 函数恢复该任务的运行。
2、函数原型：void OSSemPend ( OS_EVNNT *pevent, INT16U timeout, int8u *err );
3、参数说明：
pevent 是指向信号量的指针。该指针的值在建立该信号量时可以得到。（参考OSSemCreate() 函数）。
timeout 允许一个任务在经过了指定数目的时钟节拍后还没有得到需要的信号量时恢复就绪状态。如果该值为零表示任务将持续地等待信号量，最大的等待时间为65535个时钟节拍。这个时间长度并不是非常严格的，可能存在一个时钟节拍的误差。
err 是指向包含错误码的变量的指针，返回的错误码可能为下述几种：
OS_NO_ERR ：信号量不为零。
OS_TIMEOUT ：信号量没有在指定数目的时钟周期内被设置。
OS_ERR_PEND_ISR ：从中断调用该函数。虽然规定了不允许从中断调用该函数，但μC/OS-Ⅱ仍然包含了检测这种情况的功能。
OS_ERR_EVENT_TYPE ：pevent 不是指向信号量的指针。
4、返回值：无
5、函数主体在os_sem.c中

OSSemPost()使用权放弃函数

1、主要作用： 该函数用于设置指定的信号量。如果指定的信号量是零或大于零，OSSemPost() 函数递增该信号量的值并返回。如果有任何任务在等待该信号量，则最高优先级的任务将得到信号量并进入就绪状态。任务调度函数将进行任务调度，决定当前运行的任务是否仍然为最高优先级的就绪任务。
2、函数原型：INT8U OSSemPost（OS_EVENT *pevent）;
3、参数说明：pevent 是指向信号量的指针。该指针的值在建立该信号量时可以得到。（参考OSSemCreate() 函数）。
4、返回值：
OS_NO_ERR ：信号量被成功地设置
OS_SEM_OVF ：信号量的值溢出
OS_ERR_EVENT_TYPE ：pevent 不是指向信号量的指针
5、函数主体在os_sem.c中

附os_sem.c

/*
*********************************************************************************************************
* uC/OS-II
* The Real-Time Kernel
* SEMAPHORE MANAGEMENT
* * (c) Copyright 1992-2013, Micrium, Weston, FL
* All Rights Reserved
* * File    : OS_SEM.C
* By      : Jean J. Labrosse
* Version : V2.92.08
* * LICENSING TERMS:
* ---------------
* uC/OS-II is provided in source form for FREE evaluation, for educational use or for peaceful research.
* If you plan on using  uC/OS-II  in a commercial product you need to contact Micrium to properly license
* its use in your product. We provide ALL the source code for your convenience and to help you experience
* uC/OS-II.   The fact that the  source is provided does  NOT  mean that you can use it without  paying a
* licensing fee.
*********************************************************************************************************
*/

#define MICRIUM_SOURCE

#ifndef OS_MASTER_FILE
#include <ucos_ii.h>
#endif

#if OS_SEM_EN > 0u
/*$PAGE*/
/*
*********************************************************************************************************
* ACCEPT SEMAPHORE
* * Description: This function checks the semaphore to see if a resource is available or, if an event
* occurred.  Unlike OSSemPend(), OSSemAccept() does not suspend the calling task if the
* resource is not available or the event did not occur.
* * Arguments  : pevent     is a pointer to the event control block
* * Returns    : >  0       if the resource is available or the event did not occur the semaphore is
* decremented to obtain the resource.
* == 0       if the resource is not available or the event did not occur or,
* if 'pevent' is a NULL pointer or,
* if you didn't pass a pointer to a semaphore
*********************************************************************************************************
*/

#if OS_SEM_ACCEPT_EN > 0u
INT16U  OSSemAccept (OS_EVENT *pevent)
{
 INT16U cnt;
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
 OS_CPU_SR cpu_sr = 0u;
#endif



#if OS_ARG_CHK_EN > 0u
 if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */
 return (0u);
 }
#endif
 if (pevent->OSEventType != OS_EVENT_TYPE_SEM) { /* Validate event block type */
 return (0u);
 }
 OS_ENTER_CRITICAL();
 cnt = pevent->OSEventCnt;
 if (cnt > 0u) { /* See if resource is available */
 pevent->OSEventCnt--; /* Yes, decrement semaphore and notify caller */
 }
 OS_EXIT_CRITICAL();
 return (cnt); /* Return semaphore count */
}
#endif

/*$PAGE*/
/*
*********************************************************************************************************
* CREATE A SEMAPHORE
* * Description: This function creates a semaphore.
* * Arguments  : cnt           is the initial value for the semaphore.  If the value is 0, no resource is
* available (or no event has occurred).  You initialize the semaphore to a
* non-zero value to specify how many resources are available (e.g. if you have
* 10 resources, you would initialize the semaphore to 10).
* * Returns    : != (void *)0  is a pointer to the event control block (OS_EVENT) associated with the
* created semaphore
* == (void *)0  if no event control blocks were available
*********************************************************************************************************
*/

OS_EVENT  *OSSemCreate (INT16U cnt)
{
 OS_EVENT *pevent;
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
 OS_CPU_SR cpu_sr = 0u;
#endif



#ifdef OS_SAFETY_CRITICAL_IEC61508
 if (OSSafetyCriticalStartFlag == OS_TRUE) {
 OS_SAFETY_CRITICAL_EXCEPTION();
 return ((OS_EVENT *)0);
 }
#endif

 if (OSIntNesting > 0u) { /* See if called from ISR ... */
 return ((OS_EVENT *)0); /* ... can't CREATE from an ISR */
 }
 OS_ENTER_CRITICAL();
 pevent = OSEventFreeList; /* Get next free event control block */
 if (OSEventFreeList != (OS_EVENT *)0) { /* See if pool of free ECB pool was empty */
 OSEventFreeList = (OS_EVENT *)OSEventFreeList->OSEventPtr;
 }
 OS_EXIT_CRITICAL();
 if (pevent != (OS_EVENT *)0) { /* Get an event control block */
 pevent->OSEventType = OS_EVENT_TYPE_SEM;
 pevent->OSEventCnt = cnt; /* Set semaphore value */
 pevent->OSEventPtr = (void *)0; /* Unlink from ECB free list */
#if OS_EVENT_NAME_EN > 0u
 pevent->OSEventName = (INT8U *)(void *)"?";
#endif
 OS_EventWaitListInit(pevent); /* Initialize to 'nobody waiting' on sem. */
 }
 return (pevent);
}

/*$PAGE*/
/*
*********************************************************************************************************
* DELETE A SEMAPHORE
* * Description: This function deletes a semaphore and readies all tasks pending on the semaphore.
* * Arguments  : pevent        is a pointer to the event control block associated with the desired
* semaphore.
* * opt           determines delete options as follows:
* opt == OS_DEL_NO_PEND   Delete semaphore ONLY if no task pending
* opt == OS_DEL_ALWAYS    Deletes the semaphore even if tasks are waiting.
* In this case, all the tasks pending will be readied.
* * perr          is a pointer to an error code that can contain one of the following values:
* OS_ERR_NONE             The call was successful and the semaphore was deleted
* OS_ERR_DEL_ISR          If you attempted to delete the semaphore from an ISR
* OS_ERR_INVALID_OPT      An invalid option was specified
* OS_ERR_TASK_WAITING     One or more tasks were waiting on the semaphore
* OS_ERR_EVENT_TYPE       If you didn't pass a pointer to a semaphore
* OS_ERR_PEVENT_NULL      If 'pevent' is a NULL pointer.
* * Returns    : pevent        upon error
* (OS_EVENT *)0 if the semaphore was successfully deleted.
* * Note(s)    : 1) This function must be used with care.  Tasks that would normally expect the presence of
* the semaphore MUST check the return code of OSSemPend().
* 2) OSSemAccept() callers will not know that the intended semaphore has been deleted unless
* they check 'pevent' to see that it's a NULL pointer.
* 3) This call can potentially disable interrupts for a long time.  The interrupt disable
* time is directly proportional to the number of tasks waiting on the semaphore.
* 4) Because ALL tasks pending on the semaphore will be readied, you MUST be careful in
* applications where the semaphore is used for mutual exclusion because the resource(s)
* will no longer be guarded by the semaphore.
* 5) All tasks that were waiting for the semaphore will be readied and returned an 
* OS_ERR_PEND_ABORT if OSSemDel() was called with OS_DEL_ALWAYS
*********************************************************************************************************
*/

#if OS_SEM_DEL_EN > 0u
OS_EVENT *OSSemDel (OS_EVENT  *pevent,
 INT8U opt,
 INT8U *perr)
{
 BOOLEAN tasks_waiting;
 OS_EVENT *pevent_return;
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
 OS_CPU_SR cpu_sr = 0u;
#endif



#ifdef OS_SAFETY_CRITICAL
 if (perr == (INT8U *)0) {
 OS_SAFETY_CRITICAL_EXCEPTION();
 return ((OS_EVENT *)0);
 }
#endif

#if OS_ARG_CHK_EN > 0u
 if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */
 *perr = OS_ERR_PEVENT_NULL;
 return (pevent);
 }
#endif
 if (pevent->OSEventType != OS_EVENT_TYPE_SEM) { /* Validate event block type */
 *perr = OS_ERR_EVENT_TYPE;
 return (pevent);
 }
 if (OSIntNesting > 0u) { /* See if called from ISR ... */
 *perr = OS_ERR_DEL_ISR; /* ... can't DELETE from an ISR */
 return (pevent);
 }
 OS_ENTER_CRITICAL();
 if (pevent->OSEventGrp != 0u) { /* See if any tasks waiting on semaphore */
 tasks_waiting = OS_TRUE; /* Yes */
 } else {
 tasks_waiting = OS_FALSE; /* No */
 }
 switch (opt) {
 case OS_DEL_NO_PEND: /* Delete semaphore only if no task waiting */
 if (tasks_waiting == OS_FALSE) {
#if OS_EVENT_NAME_EN > 0u
 pevent->OSEventName = (INT8U *)(void *)"?";
#endif
 pevent->OSEventType = OS_EVENT_TYPE_UNUSED;
 pevent->OSEventPtr = OSEventFreeList; /* Return Event Control Block to free list */
 pevent->OSEventCnt = 0u;
 OSEventFreeList = pevent; /* Get next free event control block */
 OS_EXIT_CRITICAL();
 *perr = OS_ERR_NONE;
 pevent_return = (OS_EVENT *)0; /* Semaphore has been deleted */
 } else {
 OS_EXIT_CRITICAL();
 *perr = OS_ERR_TASK_WAITING;
 pevent_return = pevent;
 }
 break;

 case OS_DEL_ALWAYS: /* Always delete the semaphore */
 while (pevent->OSEventGrp != 0u) { /* Ready ALL tasks waiting for semaphore */
 (void)OS_EventTaskRdy(pevent, (void *)0, OS_STAT_SEM, OS_STAT_PEND_ABORT);
 }
#if OS_EVENT_NAME_EN > 0u
 pevent->OSEventName = (INT8U *)(void *)"?";
#endif
 pevent->OSEventType = OS_EVENT_TYPE_UNUSED;
 pevent->OSEventPtr = OSEventFreeList; /* Return Event Control Block to free list */
 pevent->OSEventCnt = 0u;
 OSEventFreeList = pevent; /* Get next free event control block */
 OS_EXIT_CRITICAL();
 if (tasks_waiting == OS_TRUE) { /* Reschedule only if task(s) were waiting */
 OS_Sched(); /* Find highest priority task ready to run */
 }
 *perr = OS_ERR_NONE;
 pevent_return = (OS_EVENT *)0; /* Semaphore has been deleted */
 break;

 default:
 OS_EXIT_CRITICAL();
 *perr = OS_ERR_INVALID_OPT;
 pevent_return = pevent;
 break;
 }
 return (pevent_return);
}
#endif

/*$PAGE*/
/*
*********************************************************************************************************
* PEND ON SEMAPHORE
* * Description: This function waits for a semaphore.
* * Arguments  : pevent        is a pointer to the event control block associated with the desired
* semaphore.
* * timeout       is an optional timeout period (in clock ticks).  If non-zero, your task will
* wait for the resource up to the amount of time specified by this argument.
* If you specify 0, however, your task will wait forever at the specified
* semaphore or, until the resource becomes available (or the event occurs).
* * perr          is a pointer to where an error message will be deposited.  Possible error
* messages are:
* * OS_ERR_NONE         The call was successful and your task owns the resource
* or, the event you are waiting for occurred.
* OS_ERR_TIMEOUT      The semaphore was not received within the specified
* 'timeout'.
* OS_ERR_PEND_ABORT   The wait on the semaphore was aborted.
* OS_ERR_EVENT_TYPE   If you didn't pass a pointer to a semaphore.
* OS_ERR_PEND_ISR     If you called this function from an ISR and the result
* would lead to a suspension.
* OS_ERR_PEVENT_NULL  If 'pevent' is a NULL pointer.
* OS_ERR_PEND_LOCKED  If you called this function when the scheduler is locked
* * Returns    : none
*********************************************************************************************************
*/
/*$PAGE*/
void  OSSemPend (OS_EVENT  *pevent,
 INT32U timeout,
 INT8U *perr)
{
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
 OS_CPU_SR cpu_sr = 0u;
#endif



#ifdef OS_SAFETY_CRITICAL
 if (perr == (INT8U *)0) {
 OS_SAFETY_CRITICAL_EXCEPTION();
 return;
 }
#endif

#if OS_ARG_CHK_EN > 0u
 if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */
 *perr = OS_ERR_PEVENT_NULL;
 return;
 }
#endif
 if (pevent->OSEventType != OS_EVENT_TYPE_SEM) { /* Validate event block type */
 *perr = OS_ERR_EVENT_TYPE;
 return;
 }
 if (OSIntNesting > 0u) { /* See if called from ISR ... */
 *perr = OS_ERR_PEND_ISR; /* ... can't PEND from an ISR */
 return;
 }
 if (OSLockNesting > 0u) { /* See if called with scheduler locked ... */
 *perr = OS_ERR_PEND_LOCKED; /* ... can't PEND when locked */
 return;
 }
 OS_ENTER_CRITICAL();
 if (pevent->OSEventCnt > 0u) { /* If sem. is positive, resource available ... */
 pevent->OSEventCnt--; /* ... decrement semaphore only if positive. */
 OS_EXIT_CRITICAL();
 *perr = OS_ERR_NONE;
 return;
 }
 /* Otherwise, must wait until event occurs */
 OSTCBCur->OSTCBStat |= OS_STAT_SEM; /* Resource not available, pend on semaphore */
 OSTCBCur->OSTCBStatPend = OS_STAT_PEND_OK;
 OSTCBCur->OSTCBDly = timeout; /* Store pend timeout in TCB */
 OS_EventTaskWait(pevent); /* Suspend task until event or timeout occurs */
 OS_EXIT_CRITICAL();
 OS_Sched(); /* Find next highest priority task ready */
 OS_ENTER_CRITICAL();
 switch (OSTCBCur->OSTCBStatPend) { /* See if we timed-out or aborted */
 case OS_STAT_PEND_OK:
 *perr = OS_ERR_NONE;
 break;

 case OS_STAT_PEND_ABORT:
 *perr = OS_ERR_PEND_ABORT; /* Indicate that we aborted */
 break;

 case OS_STAT_PEND_TO:
 default:
 OS_EventTaskRemove(OSTCBCur, pevent);
 *perr = OS_ERR_TIMEOUT; /* Indicate that we didn't get event within TO */
 break;
 }
 OSTCBCur->OSTCBStat = OS_STAT_RDY; /* Set task status to ready */
 OSTCBCur->OSTCBStatPend = OS_STAT_PEND_OK; /* Clear pend status */
 OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0; /* Clear event pointers */
#if (OS_EVENT_MULTI_EN > 0u)
 OSTCBCur->OSTCBEventMultiPtr = (OS_EVENT **)0;
#endif
 OS_EXIT_CRITICAL();
}

/*$PAGE*/
/*
*********************************************************************************************************
* ABORT WAITING ON A SEMAPHORE
* * Description: This function aborts & readies any tasks currently waiting on a semaphore.  This function
* should be used to fault-abort the wait on the semaphore, rather than to normally signal
* the semaphore via OSSemPost().
* * Arguments  : pevent        is a pointer to the event control block associated with the desired
* semaphore.
* * opt           determines the type of ABORT performed:
* OS_PEND_OPT_NONE         ABORT wait for a single task (HPT) waiting on the
* semaphore
* OS_PEND_OPT_BROADCAST    ABORT wait for ALL tasks that are  waiting on the
* semaphore
* * perr          is a pointer to where an error message will be deposited.  Possible error
* messages are:
* * OS_ERR_NONE         No tasks were     waiting on the semaphore.
* OS_ERR_PEND_ABORT   At least one task waiting on the semaphore was readied
* and informed of the aborted wait; check return value
* for the number of tasks whose wait on the semaphore
* was aborted.
* OS_ERR_EVENT_TYPE   If you didn't pass a pointer to a semaphore.
* OS_ERR_PEVENT_NULL  If 'pevent' is a NULL pointer.
* * Returns    : == 0          if no tasks were waiting on the semaphore, or upon error.
* >  0          if one or more tasks waiting on the semaphore are now readied and informed.
*********************************************************************************************************
*/

#if OS_SEM_PEND_ABORT_EN > 0u
INT8U  OSSemPendAbort (OS_EVENT  *pevent,
 INT8U opt,
 INT8U *perr)
{
 INT8U nbr_tasks;
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
 OS_CPU_SR cpu_sr = 0u;
#endif



#ifdef OS_SAFETY_CRITICAL
 if (perr == (INT8U *)0) {
 OS_SAFETY_CRITICAL_EXCEPTION();
 return (0u);
 }
#endif

#if OS_ARG_CHK_EN > 0u
 if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */
 *perr = OS_ERR_PEVENT_NULL;
 return (0u);
 }
#endif
 if (pevent->OSEventType != OS_EVENT_TYPE_SEM) { /* Validate event block type */
 *perr = OS_ERR_EVENT_TYPE;
 return (0u);
 }
 OS_ENTER_CRITICAL();
 if (pevent->OSEventGrp != 0u) { /* See if any task waiting on semaphore? */
 nbr_tasks = 0u;
 switch (opt) {
 case OS_PEND_OPT_BROADCAST: /* Do we need to abort ALL waiting tasks? */
 while (pevent->OSEventGrp != 0u) { /* Yes, ready ALL tasks waiting on semaphore */
 (void)OS_EventTaskRdy(pevent, (void *)0, OS_STAT_SEM, OS_STAT_PEND_ABORT);
 nbr_tasks++;
 }
 break;

 case OS_PEND_OPT_NONE:
 default: /* No, ready HPT waiting on semaphore */
 (void)OS_EventTaskRdy(pevent, (void *)0, OS_STAT_SEM, OS_STAT_PEND_ABORT);
 nbr_tasks++;
 break;
 }
 OS_EXIT_CRITICAL();
 OS_Sched(); /* Find HPT ready to run */
 *perr = OS_ERR_PEND_ABORT;
 return (nbr_tasks);
 }
 OS_EXIT_CRITICAL();
 *perr = OS_ERR_NONE;
 return (0u); /* No tasks waiting on semaphore */
}
#endif

/*$PAGE*/
/*
*********************************************************************************************************
* POST TO A SEMAPHORE
* * Description: This function signals a semaphore
* * Arguments  : pevent        is a pointer to the event control block associated with the desired
* semaphore.
* * Returns    : OS_ERR_NONE         The call was successful and the semaphore was signaled.
* OS_ERR_SEM_OVF      If the semaphore count exceeded its limit. In other words, you have
* signaled the semaphore more often than you waited on it with either
* OSSemAccept() or OSSemPend().
* OS_ERR_EVENT_TYPE   If you didn't pass a pointer to a semaphore
* OS_ERR_PEVENT_NULL  If 'pevent' is a NULL pointer.
*********************************************************************************************************
*/

INT8U  OSSemPost (OS_EVENT *pevent)
{
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
 OS_CPU_SR cpu_sr = 0u;
#endif



#if OS_ARG_CHK_EN > 0u
 if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */
 return (OS_ERR_PEVENT_NULL);
 }
#endif
 if (pevent->OSEventType != OS_EVENT_TYPE_SEM) { /* Validate event block type */
 return (OS_ERR_EVENT_TYPE);
 }
 OS_ENTER_CRITICAL();
 if (pevent->OSEventGrp != 0u) { /* See if any task waiting for semaphore */
 /* Ready HPT waiting on event */
 (void)OS_EventTaskRdy(pevent, (void *)0, OS_STAT_SEM, OS_STAT_PEND_OK);
 OS_EXIT_CRITICAL();
 OS_Sched(); /* Find HPT ready to run */
 return (OS_ERR_NONE);
 }
 if (pevent->OSEventCnt < 65535u) { /* Make sure semaphore will not overflow */
 pevent->OSEventCnt++; /* Increment semaphore count to register event */
 OS_EXIT_CRITICAL();
 return (OS_ERR_NONE);
 }
 OS_EXIT_CRITICAL(); /* Semaphore value has reached its maximum */
 return (OS_ERR_SEM_OVF);
}

/*$PAGE*/
/*
*********************************************************************************************************
* QUERY A SEMAPHORE
* * Description: This function obtains information about a semaphore
* * Arguments  : pevent        is a pointer to the event control block associated with the desired
* semaphore
* * p_sem_data    is a pointer to a structure that will contain information about the
* semaphore.
* * Returns    : OS_ERR_NONE         The call was successful and the message was sent
* OS_ERR_EVENT_TYPE   If you are attempting to obtain data from a non semaphore.
* OS_ERR_PEVENT_NULL  If 'pevent'     is a NULL pointer.
* OS_ERR_PDATA_NULL If 'p_sem_data' is a NULL pointer
*********************************************************************************************************
*/

#if OS_SEM_QUERY_EN > 0u
INT8U  OSSemQuery (OS_EVENT     *pevent,
 OS_SEM_DATA *p_sem_data)
{
 INT8U i;
 OS_PRIO *psrc;
 OS_PRIO *pdest;
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
 OS_CPU_SR cpu_sr = 0u;
#endif



#if OS_ARG_CHK_EN > 0u
 if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */
 return (OS_ERR_PEVENT_NULL);
 }
 if (p_sem_data == (OS_SEM_DATA *)0) { /* Validate 'p_sem_data' */
 return (OS_ERR_PDATA_NULL);
 }
#endif
 if (pevent->OSEventType != OS_EVENT_TYPE_SEM) { /* Validate event block type */
 return (OS_ERR_EVENT_TYPE);
 }
 OS_ENTER_CRITICAL();
 p_sem_data->OSEventGrp = pevent->OSEventGrp; /* Copy message mailbox wait list */
 psrc = &pevent->OSEventTbl[0];
 pdest = &p_sem_data->OSEventTbl[0];
 for (i = 0u; i < OS_EVENT_TBL_SIZE; i++) {
 *pdest++ = *psrc++;
 }
 p_sem_data->OSCnt = pevent->OSEventCnt; /* Get semaphore count */
 OS_EXIT_CRITICAL();
 return (OS_ERR_NONE);
}
#endif /* OS_SEM_QUERY_EN */

/*$PAGE*/
/*
*********************************************************************************************************
* SET SEMAPHORE
* * Description: This function sets the semaphore count to the value specified as an argument.  Typically,
* this value would be 0.
* * You would typically use this function when a semaphore is used as a signaling mechanism
* and, you want to reset the count value.
* * Arguments  : pevent     is a pointer to the event control block
* * cnt        is the new value for the semaphore count.  You would pass 0 to reset the
* semaphore count.
* * perr       is a pointer to an error code returned by the function as follows:
* * OS_ERR_NONE          The call was successful and the semaphore value was set.
* OS_ERR_EVENT_TYPE    If you didn't pass a pointer to a semaphore.
* OS_ERR_PEVENT_NULL   If 'pevent' is a NULL pointer.
* OS_ERR_TASK_WAITING  If tasks are waiting on the semaphore.
*********************************************************************************************************
*/

#if OS_SEM_SET_EN > 0u
void  OSSemSet (OS_EVENT  *pevent,
 INT16U cnt,
 INT8U *perr)
{
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
 OS_CPU_SR cpu_sr = 0u;
#endif



#ifdef OS_SAFETY_CRITICAL
 if (perr == (INT8U *)0) {
 OS_SAFETY_CRITICAL_EXCEPTION();
 return;
 }
#endif

#if OS_ARG_CHK_EN > 0u
 if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */
 *perr = OS_ERR_PEVENT_NULL;
 return;
 }
#endif
 if (pevent->OSEventType != OS_EVENT_TYPE_SEM) { /* Validate event block type */
 *perr = OS_ERR_EVENT_TYPE;
 return;
 }
 OS_ENTER_CRITICAL();
 *perr = OS_ERR_NONE;
 if (pevent->OSEventCnt > 0u) { /* See if semaphore already has a count */
 pevent->OSEventCnt = cnt; /* Yes, set it to the new value specified. */
 } else { /* No */
 if (pevent->OSEventGrp == 0u) { /* See if task(s) waiting? */
 pevent->OSEventCnt = cnt; /* No, OK to set the value */
 } else {
 *perr = OS_ERR_TASK_WAITING;
 }
 }
 OS_EXIT_CRITICAL();
}
#endif

#endif /* OS_SEM_EN */