📄 os_mutex.src
字号:
; return;
; }
; #endif
; OS_ENTER_CRITICAL(); /* Is Mutex available? */
; if ((INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8) == OS_MUTEX_AVAILABLE) {
; pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8; /* Yes, Acquire the resource */
; pevent->OSEventCnt |= OSTCBCur->OSTCBPrio; /* Save priority of owning task */
; pevent->OSEventPtr = (void *)OSTCBCur; /* Point to owning task's OS_TCB */
; OS_EXIT_CRITICAL();
; *err = OS_NO_ERR;
; return;
; }
; pip = (INT8U)(pevent->OSEventCnt >> 8); /* No, Get PIP from mutex */
; mprio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8); /* Get priority of mutex owner */
; ptcb = (OS_TCB *)(pevent->OSEventPtr); /* Point to TCB of mutex owner */
; if (ptcb->OSTCBPrio != pip && mprio > OSTCBCur->OSTCBPrio) { /* Need to promote prio of owner?*/
; if ((OSRdyTbl[ptcb->OSTCBY] & ptcb->OSTCBBitX) != 0x00) { /* See if mutex owner is ready */
; /* Yes, Remove owner from Rdy ...*/
; /* ... list at current prio */
; if ((OSRdyTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0x00) {
; OSRdyGrp &= ~ptcb->OSTCBBitY;
; }
; rdy = TRUE;
; } else {
; rdy = FALSE; /* No */
; }
; ptcb->OSTCBPrio = pip; /* Change owner task prio to PIP */
; ptcb->OSTCBY = ptcb->OSTCBPrio >> 3;
; ptcb->OSTCBBitY = OSMapTbl[ptcb->OSTCBY];
; ptcb->OSTCBX = ptcb->OSTCBPrio & 0x07;
; ptcb->OSTCBBitX = OSMapTbl[ptcb->OSTCBX];
; if (rdy == TRUE) { /* If task was ready at owner's priority ...*/
; OSRdyGrp |= ptcb->OSTCBBitY; /* ... make it ready at new priority. */
; OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
; }
; OSTCBPrioTbl[pip] = (OS_TCB *)ptcb;
; }
; OSTCBCur->OSTCBStat |= OS_STAT_MUTEX; /* Mutex not available, pend current task */
; OSTCBCur->OSTCBDly = timeout; /* Store timeout in current task's 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();
; if (OSTCBCur->OSTCBStat & OS_STAT_MUTEX) { /* Must have timed out if still waiting for event*/
; OS_EventTO(pevent);
; OS_EXIT_CRITICAL();
; *err = OS_TIMEOUT; /* Indicate that we didn't get mutex within TO */
; return;
; }
; OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0;
; OS_EXIT_CRITICAL();
; *err = OS_NO_ERR;
; }
; /*$PAGE*/
; /*
; *********************************************************************************************************
; * POST TO A MUTUAL EXCLUSION SEMAPHORE
; *
; * Description: This function signals a mutual exclusion semaphore
; *
; * Arguments : pevent is a pointer to the event control block associated with the desired
; * mutex.
; *
; * Returns : OS_NO_ERR The call was successful and the mutex was signaled.
; * OS_ERR_EVENT_TYPE If you didn't pass a pointer to a mutex
; * OS_ERR_PEVENT_NULL 'pevent' is a NULL pointer
; * OS_ERR_POST_ISR Attempted to post from an ISR (not valid for MUTEXes)
; * OS_ERR_NOT_MUTEX_OWNER The task that did the post is NOT the owner of the MUTEX.
; *********************************************************************************************************
; */
;
; INT8U OSMutexPost (OS_EVENT *pevent)LG_REENTRANT
; {
; #if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
; OS_CPU_SR cpu_sr;
; #endif
; INT8U pip; /* Priority inheritance priority */
; INT8U prio;
;
;
; if (OSIntNesting > 0) { /* See if called from ISR ... */
; return (OS_ERR_POST_ISR); /* ... can't POST mutex from an ISR */
; }
; #if OS_ARG_CHK_EN > 0
; if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */
; return (OS_ERR_PEVENT_NULL);
; }
; if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) { /* Validate event block type */
; return (OS_ERR_EVENT_TYPE);
; }
; #endif
; OS_ENTER_CRITICAL();
; pip = (INT8U)(pevent->OSEventCnt >> 8); /* Get priority inheritance priority of mutex */
; prio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8); /* Get owner's original priority */
; if (OSTCBCur->OSTCBPrio != pip &&
; OSTCBCur->OSTCBPrio != prio) { /* See if posting task owns the MUTEX */
; OS_EXIT_CRITICAL();
; return (OS_ERR_NOT_MUTEX_OWNER);
; }
; if (OSTCBCur->OSTCBPrio == pip) { /* Did we have to raise current task's priority? */
; /* Yes, Return to original priority */
; /* Remove owner from ready list at 'pip' */
; if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) {
; OSRdyGrp &= ~OSTCBCur->OSTCBBitY;
; }
; OSTCBCur->OSTCBPrio = prio;
; OSTCBCur->OSTCBY = prio >> 3;
; OSTCBCur->OSTCBBitY = OSMapTbl[OSTCBCur->OSTCBY];
; OSTCBCur->OSTCBX = prio & 0x07;
; OSTCBCur->OSTCBBitX = OSMapTbl[OSTCBCur->OSTCBX];
; OSRdyGrp |= OSTCBCur->OSTCBBitY;
; OSRdyTbl[OSTCBCur->OSTCBY] |= OSTCBCur->OSTCBBitX;
; OSTCBPrioTbl[prio] = (OS_TCB *)OSTCBCur;
; }
; OSTCBPrioTbl[pip] = (OS_TCB *)1; /* Reserve table entry */
; if (pevent->OSEventGrp != 0x00) { /* Any task waiting for the mutex? */
; /* Yes, Make HPT waiting for mutex ready */
; prio = OS_EventTaskRdy(pevent, (void *)0, OS_STAT_MUTEX);
; pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8; /* Save priority of mutex's new owner */
; pevent->OSEventCnt |= prio;
; pevent->OSEventPtr = OSTCBPrioTbl[prio]; /* Link to mutex owner's OS_TCB */
; OS_EXIT_CRITICAL();
; OS_Sched(); /* Find highest priority task ready to run */
; return (OS_NO_ERR);
; }
; pevent->OSEventCnt |= OS_MUTEX_AVAILABLE; /* No, Mutex is now available */
; pevent->OSEventPtr = (void *)0;
; OS_EXIT_CRITICAL();
; return (OS_NO_ERR);
; }
; /*$PAGE*/
; /*
; *********************************************************************************************************
; * QUERY A MUTUAL EXCLUSION SEMAPHORE
; *
; * Description: This function obtains information about a mutex
; *
; * Arguments : pevent is a pointer to the event control block associated with the desired mutex
; *
; * pdata is a pointer to a structure that will contain information about the mutex
; *
; * Returns : OS_NO_ERR The call was successful and the message was sent
; * OS_ERR_QUERY_ISR If you called this function from an ISR
; * OS_ERR_PEVENT_NULL 'pevent' is a NULL pointer
; * OS_ERR_EVENT_TYPE If you are attempting to obtain data from a non mutex.
; *********************************************************************************************************
; */
;
; #if OS_MUTEX_QUERY_EN > 0
; INT8U OSMutexQuery (OS_EVENT *pevent, OS_MUTEX_DATA *os_pdata)LG_REENTRANT
; {
; #if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
; OS_CPU_SR cpu_sr;
; #endif
; INT8U *psrc;
; INT8U *pdest;
;
;
; if (OSIntNesting > 0) { /* See if called from ISR ... */
; return (OS_ERR_QUERY_ISR); /* ... can't QUERY mutex from an ISR */
; }
; #if OS_ARG_CHK_EN > 0
; if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */
; return (OS_ERR_PEVENT_NULL);
; }
; if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) { /* Validate event block type */
; return (OS_ERR_EVENT_TYPE);
; }
; #endif
; OS_ENTER_CRITICAL();
; os_pdata->OSMutexPIP = (INT8U)(pevent->OSEventCnt >> 8);
; os_pdata->OSOwnerPrio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8);
; if (os_pdata->OSOwnerPrio == 0xFF) {
; os_pdata->OSValue = 1;
; } else {
; os_pdata->OSValue = 0;
; }
; os_pdata->OSEventGrp = pevent->OSEventGrp; /* Copy wait list */
; psrc = &pevent->OSEventTbl[0];
; pdest = &os_pdata->OSEventTbl[0];
; #if OS_EVENT_TBL_SIZE > 0
; *pdest++ = *psrc++;
; #endif
;
; #if OS_EVENT_TBL_SIZE > 1
; *pdest++ = *psrc++;
; #endif
;
; #if OS_EVENT_TBL_SIZE > 2
; *pdest++ = *psrc++;
; #endif
;
; #if OS_EVENT_TBL_SIZE > 3
; *pdest++ = *psrc++;
; #endif
;
; #if OS_EVENT_TBL_SIZE > 4
; *pdest++ = *psrc++;
; #endif
;
; #if OS_EVENT_TBL_SIZE > 5
; *pdest++ = *psrc++;
; #endif
;
; #if OS_EVENT_TBL_SIZE > 6
; *pdest++ = *psrc++;
; #endif
;
; #if OS_EVENT_TBL_SIZE > 7
; *pdest = *psrc;
; #endif
; OS_EXIT_CRITICAL();
; return (OS_NO_ERR);
; }
; #endif /* OS_MUTEX_QUERY_EN */
; #endif /* OS_MUTEX_EN */
; *** sync lost ***
; *** sync lost ***
; *** sync lost ***
END
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -