UCOS_TI_LM3S_Keil
 全部 结构体 文件 函数 变量 类型定义 宏定义 页
宏定义 | 函数
os_mutex.c 文件参考
#include <ucos_ii.h>
os_mutex.c 的引用(Include)关系图:

浏览源代码.

宏定义

#define OS_MUTEX_KEEP_LOWER_8   ((INT16U)0x00FFu)
 
#define OS_MUTEX_KEEP_UPPER_8   ((INT16U)0xFF00u)
 
#define OS_MUTEX_AVAILABLE   ((INT16U)0x00FFu)
 

函数

static void OSMutex_RdyAtPrio (OS_TCB *ptcb, INT8U prio)
 
BOOLEAN OSMutexAccept (OS_EVENT *pevent, INT8U *perr)
 
OS_EVENT * OSMutexCreate (INT8U prio, INT8U *perr)
 
OS_EVENT * OSMutexDel (OS_EVENT *pevent, INT8U opt, INT8U *perr)
 
void OSMutexPend (OS_EVENT *pevent, INT32U timeout, INT8U *perr)
 
INT8U OSMutexPost (OS_EVENT *pevent)
 
INT8U OSMutexQuery (OS_EVENT *pevent, OS_MUTEX_DATA *p_mutex_data)
 

宏定义说明

#define OS_MUTEX_KEEP_LOWER_8   ((INT16U)0x00FFu)

在文件 os_mutex.c 第 36 行定义.

参考自 OSMutexAccept(), OSMutexDel(), OSMutexPend(), OSMutexPost() , 以及 OSMutexQuery().

#define OS_MUTEX_KEEP_UPPER_8   ((INT16U)0xFF00u)

在文件 os_mutex.c 第 37 行定义.

参考自 OSMutexAccept(), OSMutexPend() , 以及 OSMutexPost().

#define OS_MUTEX_AVAILABLE   ((INT16U)0x00FFu)

在文件 os_mutex.c 第 39 行定义.

参考自 OSMutexAccept(), OSMutexCreate(), OSMutexPend() , 以及 OSMutexPost().

函数说明

static void OSMutex_RdyAtPrio ( OS_TCB *  ptcb,
INT8U  prio 
)
static

在文件 os_mutex.c 第 691 行定义.

参考 OSPrioCur, OSRdyGrp, OSRdyTbl, OS_TCB::OSTCBBitX, OS_TCB::OSTCBBitY, OS_TCB::OSTCBPrio, OSTCBPrioTbl, OS_TCB::OSTCBX , 以及 OS_TCB::OSTCBY.

参考自 OSMutexDel() , 以及 OSMutexPost().

693 {
694  INT8U y;
695 
696 
697  y = ptcb->OSTCBY; /* Remove owner from ready list at 'pip' */
698  OSRdyTbl[y] &= ~ptcb->OSTCBBitX;
699  if (OSRdyTbl[y] == 0u) {
700  OSRdyGrp &= ~ptcb->OSTCBBitY;
701  }
702  ptcb->OSTCBPrio = prio;
703  OSPrioCur = prio; /* The current task is now at this priority */
704 #if OS_LOWEST_PRIO <= 63u
705  ptcb->OSTCBY = (INT8U)((prio >> (INT8U)3) & (INT8U)0x07);
706  ptcb->OSTCBX = (INT8U) (prio & (INT8U)0x07);
707  ptcb->OSTCBBitY = (INT8U)(1u << ptcb->OSTCBY);
708  ptcb->OSTCBBitX = (INT8U)(1u << ptcb->OSTCBX);
709 #else
710  ptcb->OSTCBY = (INT8U)((prio >> (INT8U)4) & (INT8U)0x0F);
711  ptcb->OSTCBX = (INT8U) (prio & (INT8U)0x0F);
712  ptcb->OSTCBBitY = (INT16U)(1u << ptcb->OSTCBY);
713  ptcb->OSTCBBitX = (INT16U)(1u << ptcb->OSTCBX);
714 #endif
715  OSRdyGrp |= ptcb->OSTCBBitY; /* Make task ready at original priority */
716  OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
717  OSTCBPrioTbl[prio] = ptcb;
718 
719 }

这是这个函数的调用关系图:

BOOLEAN OSMutexAccept ( OS_EVENT *  pevent,
INT8U *  perr 
)

在文件 os_mutex.c 第 84 行定义.

参考 OS_ENTER_CRITICAL, OS_ERR_EVENT_TYPE, OS_ERR_NONE, OS_ERR_PEND_ISR, OS_ERR_PEVENT_NULL, OS_ERR_PIP_LOWER, OS_EVENT_TYPE_MUTEX, OS_EXIT_CRITICAL, OS_FALSE, OS_MUTEX_AVAILABLE, OS_MUTEX_KEEP_LOWER_8, OS_MUTEX_KEEP_UPPER_8, OS_TRUE, OS_EVENT::OSEventCnt, OS_EVENT::OSEventPtr, OS_EVENT::OSEventType, OSIntNesting, OSTCBCur , 以及 OS_TCB::OSTCBPrio.

86 {
87  INT8U pip; /* Priority Inheritance Priority (PIP) */
88 #if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
89  OS_CPU_SR cpu_sr = 0u;
90 #endif
91 
92 
93 
94 #if OS_ARG_CHK_EN > 0u
95  if (perr == (INT8U *)0) { /* Validate 'perr' */
96  return (OS_FALSE);
97  }
98  if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */
99  *perr = OS_ERR_PEVENT_NULL;
100  return (OS_FALSE);
101  }
102 #endif
103  if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) { /* Validate event block type */
104  *perr = OS_ERR_EVENT_TYPE;
105  return (OS_FALSE);
106  }
107  if (OSIntNesting > 0u) { /* Make sure it's not called from an ISR */
108  *perr = OS_ERR_PEND_ISR;
109  return (OS_FALSE);
110  }
111  OS_ENTER_CRITICAL(); /* Get value (0 or 1) of Mutex */
112  pip = (INT8U)(pevent->OSEventCnt >> 8u); /* Get PIP from mutex */
113  if ((pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8) == OS_MUTEX_AVAILABLE) {
114  pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8; /* Mask off LSByte (Acquire Mutex) */
115  pevent->OSEventCnt |= OSTCBCur->OSTCBPrio; /* Save current task priority in LSByte */
116  pevent->OSEventPtr = (void *)OSTCBCur; /* Link TCB of task owning Mutex */
117  if (OSTCBCur->OSTCBPrio <= pip) { /* PIP 'must' have a SMALLER prio ... */
118  OS_EXIT_CRITICAL(); /* ... than current task! */
119  *perr = OS_ERR_PIP_LOWER;
120  } else {
121  OS_EXIT_CRITICAL();
122  *perr = OS_ERR_NONE;
123  }
124  return (OS_TRUE);
125  }
126  OS_EXIT_CRITICAL();
127  *perr = OS_ERR_NONE;
128  return (OS_FALSE);
129 }
OS_EVENT* OSMutexCreate ( INT8U  prio,
INT8U *  perr 
)

在文件 os_mutex.c 第 167 行定义.

参考 OS_ENTER_CRITICAL, OS_ERR_CREATE_ISR, OS_ERR_NONE, OS_ERR_PEVENT_NULL, OS_ERR_PRIO_EXIST, OS_ERR_PRIO_INVALID, OS_EVENT_TYPE_MUTEX, OS_EventWaitListInit(), OS_EXIT_CRITICAL, OS_LOWEST_PRIO, OS_MUTEX_AVAILABLE, OS_TCB_RESERVED, OS_EVENT::OSEventCnt, OSEventFreeList, OS_EVENT::OSEventName, OS_EVENT::OSEventPtr, OS_EVENT::OSEventType, OSIntNesting , 以及 OSTCBPrioTbl.

169 {
170  OS_EVENT *pevent;
171 #if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
172  OS_CPU_SR cpu_sr = 0u;
173 #endif
174 
175 
176 
177 #if OS_ARG_CHK_EN > 0u
178  if (perr == (INT8U *)0) { /* Validate 'perr' */
179  return ((OS_EVENT *)0);
180  }
181  if (prio >= OS_LOWEST_PRIO) { /* Validate PIP */
182  *perr = OS_ERR_PRIO_INVALID;
183  return ((OS_EVENT *)0);
184  }
185 #endif
186  if (OSIntNesting > 0u) { /* See if called from ISR ... */
187  *perr = OS_ERR_CREATE_ISR; /* ... can't CREATE mutex from an ISR */
188  return ((OS_EVENT *)0);
189  }
190  OS_ENTER_CRITICAL();
191  if (OSTCBPrioTbl[prio] != (OS_TCB *)0) { /* Mutex priority must not already exist */
192  OS_EXIT_CRITICAL(); /* Task already exist at priority ... */
193  *perr = OS_ERR_PRIO_EXIST; /* ... inheritance priority */
194  return ((OS_EVENT *)0);
195  }
196  OSTCBPrioTbl[prio] = OS_TCB_RESERVED; /* Reserve the table entry */
197  pevent = OSEventFreeList; /* Get next free event control block */
198  if (pevent == (OS_EVENT *)0) { /* See if an ECB was available */
199  OSTCBPrioTbl[prio] = (OS_TCB *)0; /* No, Release the table entry */
200  OS_EXIT_CRITICAL();
201  *perr = OS_ERR_PEVENT_NULL; /* No more event control blocks */
202  return (pevent);
203  }
204  OSEventFreeList = (OS_EVENT *)OSEventFreeList->OSEventPtr; /* Adjust the free list */
205  OS_EXIT_CRITICAL();
206  pevent->OSEventType = OS_EVENT_TYPE_MUTEX;
207  pevent->OSEventCnt = (INT16U)((INT16U)prio << 8u) | OS_MUTEX_AVAILABLE; /* Resource is avail. */
208  pevent->OSEventPtr = (void *)0; /* No task owning the mutex */
209 #if OS_EVENT_NAME_EN > 0u
210  pevent->OSEventName = (INT8U *)"?";
211 #endif
212  OS_EventWaitListInit(pevent);
213  *perr = OS_ERR_NONE;
214  return (pevent);
215 }

函数调用图:

OS_EVENT* OSMutexDel ( OS_EVENT *  pevent,
INT8U  opt,
INT8U *  perr 
)

在文件 os_mutex.c 第 259 行定义.

参考 OS_DEL_ALWAYS, OS_DEL_NO_PEND, OS_ENTER_CRITICAL, OS_ERR_DEL_ISR, OS_ERR_EVENT_TYPE, OS_ERR_INVALID_OPT, OS_ERR_NONE, OS_ERR_PEVENT_NULL, OS_ERR_TASK_WAITING, OS_EVENT_TYPE_MUTEX, OS_EVENT_TYPE_UNUSED, OS_EventTaskRdy(), OS_EXIT_CRITICAL, OS_FALSE, OS_MUTEX_KEEP_LOWER_8, OS_Sched(), OS_STAT_MUTEX, OS_STAT_PEND_OK, OS_TRUE, OS_EVENT::OSEventCnt, OSEventFreeList, OS_EVENT::OSEventGrp, OS_EVENT::OSEventName, OS_EVENT::OSEventPtr, OS_EVENT::OSEventType, OSIntNesting, OSMutex_RdyAtPrio(), OS_TCB::OSTCBPrio , 以及 OSTCBPrioTbl.

262 {
263  BOOLEAN tasks_waiting;
264  OS_EVENT *pevent_return;
265  INT8U pip; /* Priority inheritance priority */
266  INT8U prio;
267  OS_TCB *ptcb;
268 #if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
269  OS_CPU_SR cpu_sr = 0u;
270 #endif
271 
272 
273 
274 #if OS_ARG_CHK_EN > 0u
275  if (perr == (INT8U *)0) { /* Validate 'perr' */
276  return (pevent);
277  }
278  if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */
279  *perr = OS_ERR_PEVENT_NULL;
280  return (pevent);
281  }
282 #endif
283  if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) { /* Validate event block type */
284  *perr = OS_ERR_EVENT_TYPE;
285  return (pevent);
286  }
287  if (OSIntNesting > 0u) { /* See if called from ISR ... */
288  *perr = OS_ERR_DEL_ISR; /* ... can't DELETE from an ISR */
289  return (pevent);
290  }
291  OS_ENTER_CRITICAL();
292  if (pevent->OSEventGrp != 0u) { /* See if any tasks waiting on mutex */
293  tasks_waiting = OS_TRUE; /* Yes */
294  } else {
295  tasks_waiting = OS_FALSE; /* No */
296  }
297  switch (opt) {
298  case OS_DEL_NO_PEND: /* DELETE MUTEX ONLY IF NO TASK WAITING --- */
299  if (tasks_waiting == OS_FALSE) {
300 #if OS_EVENT_NAME_EN > 0u
301  pevent->OSEventName = (INT8U *)"?";
302 #endif
303  pip = (INT8U)(pevent->OSEventCnt >> 8u);
304  OSTCBPrioTbl[pip] = (OS_TCB *)0; /* Free up the PIP */
305  pevent->OSEventType = OS_EVENT_TYPE_UNUSED;
306  pevent->OSEventPtr = OSEventFreeList; /* Return Event Control Block to free list */
307  pevent->OSEventCnt = 0u;
308  OSEventFreeList = pevent;
309  OS_EXIT_CRITICAL();
310  *perr = OS_ERR_NONE;
311  pevent_return = (OS_EVENT *)0; /* Mutex has been deleted */
312  } else {
313  OS_EXIT_CRITICAL();
314  *perr = OS_ERR_TASK_WAITING;
315  pevent_return = pevent;
316  }
317  break;
318 
319  case OS_DEL_ALWAYS: /* ALWAYS DELETE THE MUTEX ---------------- */
320  pip = (INT8U)(pevent->OSEventCnt >> 8u); /* Get PIP of mutex */
321  prio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8); /* Get owner's original prio */
322  ptcb = (OS_TCB *)pevent->OSEventPtr;
323  if (ptcb != (OS_TCB *)0) { /* See if any task owns the mutex */
324  if (ptcb->OSTCBPrio == pip) { /* See if original prio was changed */
325  OSMutex_RdyAtPrio(ptcb, prio); /* Yes, Restore the task's original prio */
326  }
327  }
328  while (pevent->OSEventGrp != 0u) { /* Ready ALL tasks waiting for mutex */
329  (void)OS_EventTaskRdy(pevent, (void *)0, OS_STAT_MUTEX, OS_STAT_PEND_OK);
330  }
331 #if OS_EVENT_NAME_EN > 0u
332  pevent->OSEventName = (INT8U *)"?";
333 #endif
334  pip = (INT8U)(pevent->OSEventCnt >> 8u);
335  OSTCBPrioTbl[pip] = (OS_TCB *)0; /* Free up the PIP */
336  pevent->OSEventType = OS_EVENT_TYPE_UNUSED;
337  pevent->OSEventPtr = OSEventFreeList; /* Return Event Control Block to free list */
338  pevent->OSEventCnt = 0u;
339  OSEventFreeList = pevent; /* Get next free event control block */
340  OS_EXIT_CRITICAL();
341  if (tasks_waiting == OS_TRUE) { /* Reschedule only if task(s) were waiting */
342  OS_Sched(); /* Find highest priority task ready to run */
343  }
344  *perr = OS_ERR_NONE;
345  pevent_return = (OS_EVENT *)0; /* Mutex has been deleted */
346  break;
347 
348  default:
349  OS_EXIT_CRITICAL();
350  *perr = OS_ERR_INVALID_OPT;
351  pevent_return = pevent;
352  break;
353  }
354  return (pevent_return);
355 }

函数调用图:

void OSMutexPend ( OS_EVENT *  pevent,
INT32U  timeout,
INT8U *  perr 
)

在文件 os_mutex.c 第 399 行定义.

参考 OS_ENTER_CRITICAL, OS_ERR_EVENT_TYPE, OS_ERR_NONE, OS_ERR_PEND_ABORT, OS_ERR_PEND_ISR, OS_ERR_PEND_LOCKED, OS_ERR_PEVENT_NULL, OS_ERR_PIP_LOWER, OS_ERR_TIMEOUT, OS_EVENT_TYPE_MUTEX, OS_EventTaskRemove(), OS_EventTaskWait(), OS_EXIT_CRITICAL, OS_FALSE, OS_MUTEX_AVAILABLE, OS_MUTEX_KEEP_LOWER_8, OS_MUTEX_KEEP_UPPER_8, OS_Sched(), OS_STAT_MUTEX, OS_STAT_PEND_ABORT, OS_STAT_PEND_OK, OS_STAT_PEND_TO, OS_STAT_RDY, OS_TRUE, OS_EVENT::OSEventCnt, OS_EVENT::OSEventGrp, OS_EVENT::OSEventPtr, OS_EVENT::OSEventTbl, OS_EVENT::OSEventType, OSIntNesting, OSLockNesting, OSRdyGrp, OSRdyTbl, OS_TCB::OSTCBBitX, OS_TCB::OSTCBBitY, OSTCBCur, OS_TCB::OSTCBDly, OS_TCB::OSTCBEventMultiPtr, OS_TCB::OSTCBEventPtr, OS_TCB::OSTCBPrio, OSTCBPrioTbl, OS_TCB::OSTCBStat, OS_TCB::OSTCBStatPend, OS_TCB::OSTCBX , 以及 OS_TCB::OSTCBY.

402 {
403  INT8U pip; /* Priority Inheritance Priority (PIP) */
404  INT8U mprio; /* Mutex owner priority */
405  BOOLEAN rdy; /* Flag indicating task was ready */
406  OS_TCB *ptcb;
407  OS_EVENT *pevent2;
408  INT8U y;
409 #if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
410  OS_CPU_SR cpu_sr = 0u;
411 #endif
412 
413 
414 
415 #if OS_ARG_CHK_EN > 0u
416  if (perr == (INT8U *)0) { /* Validate 'perr' */
417  return;
418  }
419  if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */
420  *perr = OS_ERR_PEVENT_NULL;
421  return;
422  }
423 #endif
424  if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) { /* Validate event block type */
425  *perr = OS_ERR_EVENT_TYPE;
426  return;
427  }
428  if (OSIntNesting > 0u) { /* See if called from ISR ... */
429  *perr = OS_ERR_PEND_ISR; /* ... can't PEND from an ISR */
430  return;
431  }
432  if (OSLockNesting > 0u) { /* See if called with scheduler locked ... */
433  *perr = OS_ERR_PEND_LOCKED; /* ... can't PEND when locked */
434  return;
435  }
436 /*$PAGE*/
437  OS_ENTER_CRITICAL();
438  pip = (INT8U)(pevent->OSEventCnt >> 8u); /* Get PIP from mutex */
439  /* Is Mutex available? */
440  if ((INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8) == OS_MUTEX_AVAILABLE) {
441  pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8; /* Yes, Acquire the resource */
442  pevent->OSEventCnt |= OSTCBCur->OSTCBPrio; /* Save priority of owning task */
443  pevent->OSEventPtr = (void *)OSTCBCur; /* Point to owning task's OS_TCB */
444  if (OSTCBCur->OSTCBPrio <= pip) { /* PIP 'must' have a SMALLER prio ... */
445  OS_EXIT_CRITICAL(); /* ... than current task! */
446  *perr = OS_ERR_PIP_LOWER;
447  } else {
448  OS_EXIT_CRITICAL();
449  *perr = OS_ERR_NONE;
450  }
451  return;
452  }
453  mprio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8); /* No, Get priority of mutex owner */
454  ptcb = (OS_TCB *)(pevent->OSEventPtr); /* Point to TCB of mutex owner */
455  if (ptcb->OSTCBPrio > pip) { /* Need to promote prio of owner?*/
456  if (mprio > OSTCBCur->OSTCBPrio) {
457  y = ptcb->OSTCBY;
458  if ((OSRdyTbl[y] & ptcb->OSTCBBitX) != 0u) { /* See if mutex owner is ready */
459  OSRdyTbl[y] &= ~ptcb->OSTCBBitX; /* Yes, Remove owner from Rdy ...*/
460  if (OSRdyTbl[y] == 0u) { /* ... list at current prio */
461  OSRdyGrp &= ~ptcb->OSTCBBitY;
462  }
463  rdy = OS_TRUE;
464  } else {
465  pevent2 = ptcb->OSTCBEventPtr;
466  if (pevent2 != (OS_EVENT *)0) { /* Remove from event wait list */
467  if ((pevent2->OSEventTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0) {
468  pevent2->OSEventGrp &= ~ptcb->OSTCBBitY;
469  }
470  }
471  rdy = OS_FALSE; /* No */
472  }
473  ptcb->OSTCBPrio = pip; /* Change owner task prio to PIP */
474 #if OS_LOWEST_PRIO <= 63u
475  ptcb->OSTCBY = (INT8U)( ptcb->OSTCBPrio >> 3u);
476  ptcb->OSTCBX = (INT8U)( ptcb->OSTCBPrio & 0x07u);
477  ptcb->OSTCBBitY = (INT8U)(1u << ptcb->OSTCBY);
478  ptcb->OSTCBBitX = (INT8U)(1u << ptcb->OSTCBX);
479 #else
480  ptcb->OSTCBY = (INT8U)((ptcb->OSTCBPrio >> 4u) & 0xFFu);
481  ptcb->OSTCBX = (INT8U)( ptcb->OSTCBPrio & 0x0Fu);
482  ptcb->OSTCBBitY = (INT16U)(1u << ptcb->OSTCBY);
483  ptcb->OSTCBBitX = (INT16U)(1u << ptcb->OSTCBX);
484 #endif
485  if (rdy == OS_TRUE) { /* If task was ready at owner's priority ...*/
486  OSRdyGrp |= ptcb->OSTCBBitY; /* ... make it ready at new priority. */
487  OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
488  } else {
489  pevent2 = ptcb->OSTCBEventPtr;
490  if (pevent2 != (OS_EVENT *)0) { /* Add to event wait list */
491  pevent2->OSEventGrp |= ptcb->OSTCBBitY;
492  pevent2->OSEventTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
493  }
494  }
495  OSTCBPrioTbl[pip] = ptcb;
496  }
497  }
498  OSTCBCur->OSTCBStat |= OS_STAT_MUTEX; /* Mutex not available, pend current task */
499  OSTCBCur->OSTCBStatPend = OS_STAT_PEND_OK;
500  OSTCBCur->OSTCBDly = timeout; /* Store timeout in current task's TCB */
501  OS_EventTaskWait(pevent); /* Suspend task until event or timeout occurs */
502  OS_EXIT_CRITICAL();
503  OS_Sched(); /* Find next highest priority task ready */
504  OS_ENTER_CRITICAL();
505  switch (OSTCBCur->OSTCBStatPend) { /* See if we timed-out or aborted */
506  case OS_STAT_PEND_OK:
507  *perr = OS_ERR_NONE;
508  break;
509 
510  case OS_STAT_PEND_ABORT:
511  *perr = OS_ERR_PEND_ABORT; /* Indicate that we aborted getting mutex */
512  break;
513 
514  case OS_STAT_PEND_TO:
515  default:
516  OS_EventTaskRemove(OSTCBCur, pevent);
517  *perr = OS_ERR_TIMEOUT; /* Indicate that we didn't get mutex within TO */
518  break;
519  }
520  OSTCBCur->OSTCBStat = OS_STAT_RDY; /* Set task status to ready */
521  OSTCBCur->OSTCBStatPend = OS_STAT_PEND_OK; /* Clear pend status */
522  OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0; /* Clear event pointers */
523 #if (OS_EVENT_MULTI_EN > 0u)
524  OSTCBCur->OSTCBEventMultiPtr = (OS_EVENT **)0;
525 #endif
526  OS_EXIT_CRITICAL();
527 }

函数调用图:

INT8U OSMutexPost ( OS_EVENT *  pevent)

在文件 os_mutex.c 第 553 行定义.

参考 OS_ENTER_CRITICAL, OS_ERR_EVENT_TYPE, OS_ERR_NONE, OS_ERR_NOT_MUTEX_OWNER, OS_ERR_PEVENT_NULL, OS_ERR_PIP_LOWER, OS_ERR_POST_ISR, OS_EVENT_TYPE_MUTEX, OS_EventTaskRdy(), OS_EXIT_CRITICAL, OS_MUTEX_AVAILABLE, OS_MUTEX_KEEP_LOWER_8, OS_MUTEX_KEEP_UPPER_8, OS_Sched(), OS_STAT_MUTEX, OS_STAT_PEND_OK, OS_TCB_RESERVED, OS_EVENT::OSEventCnt, OS_EVENT::OSEventGrp, OS_EVENT::OSEventPtr, OS_EVENT::OSEventType, OSIntNesting, OSMutex_RdyAtPrio(), OSTCBCur, OS_TCB::OSTCBPrio , 以及 OSTCBPrioTbl.

554 {
555  INT8U pip; /* Priority inheritance priority */
556  INT8U prio;
557 #if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
558  OS_CPU_SR cpu_sr = 0u;
559 #endif
560 
561 
562 
563  if (OSIntNesting > 0u) { /* See if called from ISR ... */
564  return (OS_ERR_POST_ISR); /* ... can't POST mutex from an ISR */
565  }
566 #if OS_ARG_CHK_EN > 0u
567  if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */
568  return (OS_ERR_PEVENT_NULL);
569  }
570 #endif
571  if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) { /* Validate event block type */
572  return (OS_ERR_EVENT_TYPE);
573  }
574  OS_ENTER_CRITICAL();
575  pip = (INT8U)(pevent->OSEventCnt >> 8u); /* Get priority inheritance priority of mutex */
576  prio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8); /* Get owner's original priority */
577  if (OSTCBCur != (OS_TCB *)pevent->OSEventPtr) { /* See if posting task owns the MUTEX */
578  OS_EXIT_CRITICAL();
579  return (OS_ERR_NOT_MUTEX_OWNER);
580  }
581  if (OSTCBCur->OSTCBPrio == pip) { /* Did we have to raise current task's priority? */
582  OSMutex_RdyAtPrio(OSTCBCur, prio); /* Restore the task's original priority */
583  }
584  OSTCBPrioTbl[pip] = OS_TCB_RESERVED; /* Reserve table entry */
585  if (pevent->OSEventGrp != 0u) { /* Any task waiting for the mutex? */
586  /* Yes, Make HPT waiting for mutex ready */
587  prio = OS_EventTaskRdy(pevent, (void *)0, OS_STAT_MUTEX, OS_STAT_PEND_OK);
588  pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8; /* Save priority of mutex's new owner */
589  pevent->OSEventCnt |= prio;
590  pevent->OSEventPtr = OSTCBPrioTbl[prio]; /* Link to new mutex owner's OS_TCB */
591  if (prio <= pip) { /* PIP 'must' have a SMALLER prio ... */
592  OS_EXIT_CRITICAL(); /* ... than current task! */
593  OS_Sched(); /* Find highest priority task ready to run */
594  return (OS_ERR_PIP_LOWER);
595  } else {
596  OS_EXIT_CRITICAL();
597  OS_Sched(); /* Find highest priority task ready to run */
598  return (OS_ERR_NONE);
599  }
600  }
601  pevent->OSEventCnt |= OS_MUTEX_AVAILABLE; /* No, Mutex is now available */
602  pevent->OSEventPtr = (void *)0;
603  OS_EXIT_CRITICAL();
604  return (OS_ERR_NONE);
605 }

函数调用图:

INT8U OSMutexQuery ( OS_EVENT *  pevent,
OS_MUTEX_DATA *  p_mutex_data 
)

在文件 os_mutex.c 第 626 行定义.

参考 OS_ENTER_CRITICAL, OS_ERR_EVENT_TYPE, OS_ERR_NONE, OS_ERR_PDATA_NULL, OS_ERR_PEVENT_NULL, OS_ERR_QUERY_ISR, OS_EVENT_TBL_SIZE, OS_EVENT_TYPE_MUTEX, OS_EXIT_CRITICAL, OS_FALSE, OS_MUTEX_KEEP_LOWER_8, OS_TRUE, OS_EVENT::OSEventCnt, OS_EVENT::OSEventGrp, OS_MUTEX_DATA::OSEventGrp, OS_EVENT::OSEventTbl, OS_MUTEX_DATA::OSEventTbl, OS_EVENT::OSEventType, OSIntNesting, OS_MUTEX_DATA::OSMutexPIP, OS_MUTEX_DATA::OSOwnerPrio , 以及 OS_MUTEX_DATA::OSValue.

628 {
629  INT8U i;
630 #if OS_LOWEST_PRIO <= 63u
631  INT8U *psrc;
632  INT8U *pdest;
633 #else
634  INT16U *psrc;
635  INT16U *pdest;
636 #endif
637 #if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
638  OS_CPU_SR cpu_sr = 0u;
639 #endif
640 
641 
642 
643  if (OSIntNesting > 0u) { /* See if called from ISR ... */
644  return (OS_ERR_QUERY_ISR); /* ... can't QUERY mutex from an ISR */
645  }
646 #if OS_ARG_CHK_EN > 0u
647  if (pevent == (OS_EVENT *)0) { /* Validate 'pevent' */
648  return (OS_ERR_PEVENT_NULL);
649  }
650  if (p_mutex_data == (OS_MUTEX_DATA *)0) { /* Validate 'p_mutex_data' */
651  return (OS_ERR_PDATA_NULL);
652  }
653 #endif
654  if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) { /* Validate event block type */
655  return (OS_ERR_EVENT_TYPE);
656  }
657  OS_ENTER_CRITICAL();
658  p_mutex_data->OSMutexPIP = (INT8U)(pevent->OSEventCnt >> 8u);
659  p_mutex_data->OSOwnerPrio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8);
660  if (p_mutex_data->OSOwnerPrio == 0xFFu) {
661  p_mutex_data->OSValue = OS_TRUE;
662  } else {
663  p_mutex_data->OSValue = OS_FALSE;
664  }
665  p_mutex_data->OSEventGrp = pevent->OSEventGrp; /* Copy wait list */
666  psrc = &pevent->OSEventTbl[0];
667  pdest = &p_mutex_data->OSEventTbl[0];
668  for (i = 0u; i < OS_EVENT_TBL_SIZE; i++) {
669  *pdest++ = *psrc++;
670  }
671  OS_EXIT_CRITICAL();
672  return (OS_ERR_NONE);
673 }