SAM4S-EK_FreeRTOS+FAT-SL  1.0
An example project to test the functionality of FreeRTOS+FAT-SL using SD card as data storage medium
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Macros Modules
queue.h
Go to the documentation of this file.
1 /*
2  FreeRTOS V8.0.1 - Copyright (C) 2014 Real Time Engineers Ltd.
3  All rights reserved
4 
5  VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
6 
7  ***************************************************************************
8  * *
9  * FreeRTOS provides completely free yet professionally developed, *
10  * robust, strictly quality controlled, supported, and cross *
11  * platform software that has become a de facto standard. *
12  * *
13  * Help yourself get started quickly and support the FreeRTOS *
14  * project by purchasing a FreeRTOS tutorial book, reference *
15  * manual, or both from: http://www.FreeRTOS.org/Documentation *
16  * *
17  * Thank you! *
18  * *
19  ***************************************************************************
20 
21  This file is part of the FreeRTOS distribution.
22 
23  FreeRTOS is free software; you can redistribute it and/or modify it under
24  the terms of the GNU General Public License (version 2) as published by the
25  Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.
26 
27  >>! NOTE: The modification to the GPL is included to allow you to !<<
28  >>! distribute a combined work that includes FreeRTOS without being !<<
29  >>! obliged to provide the source code for proprietary components !<<
30  >>! outside of the FreeRTOS kernel. !<<
31 
32  FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
33  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
34  FOR A PARTICULAR PURPOSE. Full license text is available from the following
35  link: http://www.freertos.org/a00114.html
36 
37  1 tab == 4 spaces!
38 
39  ***************************************************************************
40  * *
41  * Having a problem? Start by reading the FAQ "My application does *
42  * not run, what could be wrong?" *
43  * *
44  * http://www.FreeRTOS.org/FAQHelp.html *
45  * *
46  ***************************************************************************
47 
48  http://www.FreeRTOS.org - Documentation, books, training, latest versions,
49  license and Real Time Engineers Ltd. contact details.
50 
51  http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
52  including FreeRTOS+Trace - an indispensable productivity tool, a DOS
53  compatible FAT file system, and our tiny thread aware UDP/IP stack.
54 
55  http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High
56  Integrity Systems to sell under the OpenRTOS brand. Low cost OpenRTOS
57  licenses offer ticketed support, indemnification and middleware.
58 
59  http://www.SafeRTOS.com - High Integrity Systems also provide a safety
60  engineered and independently SIL3 certified version for use in safety and
61  mission critical applications that require provable dependability.
62 
63  1 tab == 4 spaces!
64 */
65 
66 
67 #ifndef QUEUE_H
68 #define QUEUE_H
69 
70 #ifndef INC_FREERTOS_H
71  #error "include FreeRTOS.h" must appear in source files before "include queue.h"
72 #endif
73 
74 #ifdef __cplusplus
75 extern "C" {
76 #endif
77 
78 
84 typedef void * QueueHandle_t;
85 
91 typedef void * QueueSetHandle_t;
92 
98 typedef void * QueueSetMemberHandle_t;
99 
100 /* For internal use only. */
101 #define queueSEND_TO_BACK ( ( BaseType_t ) 0 )
102 #define queueSEND_TO_FRONT ( ( BaseType_t ) 1 )
103 #define queueOVERWRITE ( ( BaseType_t ) 2 )
104 
105 /* For internal use only. These definitions *must* match those in queue.c. */
106 #define queueQUEUE_TYPE_BASE ( ( uint8_t ) 0U )
107 #define queueQUEUE_TYPE_SET ( ( uint8_t ) 0U )
108 #define queueQUEUE_TYPE_MUTEX ( ( uint8_t ) 1U )
109 #define queueQUEUE_TYPE_COUNTING_SEMAPHORE ( ( uint8_t ) 2U )
110 #define queueQUEUE_TYPE_BINARY_SEMAPHORE ( ( uint8_t ) 3U )
111 #define queueQUEUE_TYPE_RECURSIVE_MUTEX ( ( uint8_t ) 4U )
112 
169 #define xQueueCreate( uxQueueLength, uxItemSize ) xQueueGenericCreate( uxQueueLength, uxItemSize, queueQUEUE_TYPE_BASE )
170 
251 #define xQueueSendToFront( xQueue, pvItemToQueue, xTicksToWait ) xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_FRONT )
252 
333 #define xQueueSendToBack( xQueue, pvItemToQueue, xTicksToWait ) xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )
334 
417 #define xQueueSend( xQueue, pvItemToQueue, xTicksToWait ) xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )
418 
500 #define xQueueOverwrite( xQueue, pvItemToQueue ) xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), 0, queueOVERWRITE )
501 
502 
588 BaseType_t xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, const BaseType_t xCopyPosition ) PRIVILEGED_FUNCTION;
589 
684 #define xQueuePeek( xQueue, pvBuffer, xTicksToWait ) xQueueGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdTRUE )
685 
717 BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue, void * const pvBuffer ) PRIVILEGED_FUNCTION;
718 
810 #define xQueueReceive( xQueue, pvBuffer, xTicksToWait ) xQueueGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdFALSE )
811 
812 
909 BaseType_t xQueueGenericReceive( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait, const BaseType_t xJustPeek ) PRIVILEGED_FUNCTION;
910 
924 UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
925 
941 UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
942 
955 void vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
956 
1025 #define xQueueSendToFrontFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_FRONT )
1026 
1027 
1096 #define xQueueSendToBackFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
1097 
1183 #define xQueueOverwriteFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueOVERWRITE )
1184 
1257 #define xQueueSendFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
1258 
1335 BaseType_t xQueueGenericSendFromISR( QueueHandle_t xQueue, const void * const pvItemToQueue, BaseType_t * const pxHigherPriorityTaskWoken, const BaseType_t xCopyPosition ) PRIVILEGED_FUNCTION;
1336 
1424 BaseType_t xQueueReceiveFromISR( QueueHandle_t xQueue, void * const pvBuffer, BaseType_t * const pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
1425 
1426 /*
1427  * Utilities to query queues that are safe to use from an ISR. These utilities
1428  * should be used only from witin an ISR, or within a critical section.
1429  */
1430 BaseType_t xQueueIsQueueEmptyFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
1431 BaseType_t xQueueIsQueueFullFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
1432 UBaseType_t uxQueueMessagesWaitingFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
1433 
1434 
1435 /*
1436  * xQueueAltGenericSend() is an alternative version of xQueueGenericSend().
1437  * Likewise xQueueAltGenericReceive() is an alternative version of
1438  * xQueueGenericReceive().
1439  *
1440  * The source code that implements the alternative (Alt) API is much
1441  * simpler because it executes everything from within a critical section.
1442  * This is the approach taken by many other RTOSes, but FreeRTOS.org has the
1443  * preferred fully featured API too. The fully featured API has more
1444  * complex code that takes longer to execute, but makes much less use of
1445  * critical sections. Therefore the alternative API sacrifices interrupt
1446  * responsiveness to gain execution speed, whereas the fully featured API
1447  * sacrifices execution speed to ensure better interrupt responsiveness.
1448  */
1449 BaseType_t xQueueAltGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, BaseType_t xCopyPosition );
1450 BaseType_t xQueueAltGenericReceive( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait, BaseType_t xJustPeeking );
1451 #define xQueueAltSendToFront( xQueue, pvItemToQueue, xTicksToWait ) xQueueAltGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_FRONT )
1452 #define xQueueAltSendToBack( xQueue, pvItemToQueue, xTicksToWait ) xQueueAltGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )
1453 #define xQueueAltReceive( xQueue, pvBuffer, xTicksToWait ) xQueueAltGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdFALSE )
1454 #define xQueueAltPeek( xQueue, pvBuffer, xTicksToWait ) xQueueAltGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdTRUE )
1455 
1456 /*
1457  * The functions defined above are for passing data to and from tasks. The
1458  * functions below are the equivalents for passing data to and from
1459  * co-routines.
1460  *
1461  * These functions are called from the co-routine macro implementation and
1462  * should not be called directly from application code. Instead use the macro
1463  * wrappers defined within croutine.h.
1464  */
1465 BaseType_t xQueueCRSendFromISR( QueueHandle_t xQueue, const void *pvItemToQueue, BaseType_t xCoRoutinePreviouslyWoken );
1466 BaseType_t xQueueCRReceiveFromISR( QueueHandle_t xQueue, void *pvBuffer, BaseType_t *pxTaskWoken );
1467 BaseType_t xQueueCRSend( QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait );
1468 BaseType_t xQueueCRReceive( QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksToWait );
1469 
1470 /*
1471  * For internal use only. Use xSemaphoreCreateMutex(),
1472  * xSemaphoreCreateCounting() or xSemaphoreGetMutexHolder() instead of calling
1473  * these functions directly.
1474  */
1475 QueueHandle_t xQueueCreateMutex( const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;
1476 QueueHandle_t xQueueCreateCountingSemaphore( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount ) PRIVILEGED_FUNCTION;
1477 void* xQueueGetMutexHolder( QueueHandle_t xSemaphore ) PRIVILEGED_FUNCTION;
1478 
1479 /*
1480  * For internal use only. Use xSemaphoreTakeMutexRecursive() or
1481  * xSemaphoreGiveMutexRecursive() instead of calling these functions directly.
1482  */
1483 BaseType_t xQueueTakeMutexRecursive( QueueHandle_t xMutex, TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
1485 
1486 /*
1487  * Reset a queue back to its original empty state. pdPASS is returned if the
1488  * queue is successfully reset. pdFAIL is returned if the queue could not be
1489  * reset because there are tasks blocked on the queue waiting to either
1490  * receive from the queue or send to the queue.
1491  */
1492 #define xQueueReset( xQueue ) xQueueGenericReset( xQueue, pdFALSE )
1493 
1494 /*
1495  * The registry is provided as a means for kernel aware debuggers to
1496  * locate queues, semaphores and mutexes. Call vQueueAddToRegistry() add
1497  * a queue, semaphore or mutex handle to the registry if you want the handle
1498  * to be available to a kernel aware debugger. If you are not using a kernel
1499  * aware debugger then this function can be ignored.
1500  *
1501  * configQUEUE_REGISTRY_SIZE defines the maximum number of handles the
1502  * registry can hold. configQUEUE_REGISTRY_SIZE must be greater than 0
1503  * within FreeRTOSConfig.h for the registry to be available. Its value
1504  * does not effect the number of queues, semaphores and mutexes that can be
1505  * created - just the number that the registry can hold.
1506  *
1507  * @param xQueue The handle of the queue being added to the registry. This
1508  * is the handle returned by a call to xQueueCreate(). Semaphore and mutex
1509  * handles can also be passed in here.
1510  *
1511  * @param pcName The name to be associated with the handle. This is the
1512  * name that the kernel aware debugger will display. The queue registry only
1513  * stores a pointer to the string - so the string must be persistent (global or
1514  * preferably in ROM/Flash), not on the stack.
1515  */
1516 #if configQUEUE_REGISTRY_SIZE > 0
1517  void vQueueAddToRegistry( QueueHandle_t xQueue, const char *pcName ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
1518 #endif
1519 
1520 /*
1521  * The registry is provided as a means for kernel aware debuggers to
1522  * locate queues, semaphores and mutexes. Call vQueueAddToRegistry() add
1523  * a queue, semaphore or mutex handle to the registry if you want the handle
1524  * to be available to a kernel aware debugger, and vQueueUnregisterQueue() to
1525  * remove the queue, semaphore or mutex from the register. If you are not using
1526  * a kernel aware debugger then this function can be ignored.
1527  *
1528  * @param xQueue The handle of the queue being removed from the registry.
1529  */
1530 #if configQUEUE_REGISTRY_SIZE > 0
1531  void vQueueUnregisterQueue( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
1532 #endif
1533 
1534 /*
1535  * Generic version of the queue creation function, which is in turn called by
1536  * any queue, semaphore or mutex creation function or macro.
1537  */
1538 QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;
1539 
1540 /*
1541  * Queue sets provide a mechanism to allow a task to block (pend) on a read
1542  * operation from multiple queues or semaphores simultaneously.
1543  *
1544  * See FreeRTOS/Source/Demo/Common/Minimal/QueueSet.c for an example using this
1545  * function.
1546  *
1547  * A queue set must be explicitly created using a call to xQueueCreateSet()
1548  * before it can be used. Once created, standard FreeRTOS queues and semaphores
1549  * can be added to the set using calls to xQueueAddToSet().
1550  * xQueueSelectFromSet() is then used to determine which, if any, of the queues
1551  * or semaphores contained in the set is in a state where a queue read or
1552  * semaphore take operation would be successful.
1553  *
1554  * Note 1: See the documentation on http://wwwFreeRTOS.org/RTOS-queue-sets.html
1555  * for reasons why queue sets are very rarely needed in practice as there are
1556  * simpler methods of blocking on multiple objects.
1557  *
1558  * Note 2: Blocking on a queue set that contains a mutex will not cause the
1559  * mutex holder to inherit the priority of the blocked task.
1560  *
1561  * Note 3: An additional 4 bytes of RAM is required for each space in a every
1562  * queue added to a queue set. Therefore counting semaphores that have a high
1563  * maximum count value should not be added to a queue set.
1564  *
1565  * Note 4: A receive (in the case of a queue) or take (in the case of a
1566  * semaphore) operation must not be performed on a member of a queue set unless
1567  * a call to xQueueSelectFromSet() has first returned a handle to that set member.
1568  *
1569  * @param uxEventQueueLength Queue sets store events that occur on
1570  * the queues and semaphores contained in the set. uxEventQueueLength specifies
1571  * the maximum number of events that can be queued at once. To be absolutely
1572  * certain that events are not lost uxEventQueueLength should be set to the
1573  * total sum of the length of the queues added to the set, where binary
1574  * semaphores and mutexes have a length of 1, and counting semaphores have a
1575  * length set by their maximum count value. Examples:
1576  * + If a queue set is to hold a queue of length 5, another queue of length 12,
1577  * and a binary semaphore, then uxEventQueueLength should be set to
1578  * (5 + 12 + 1), or 18.
1579  * + If a queue set is to hold three binary semaphores then uxEventQueueLength
1580  * should be set to (1 + 1 + 1 ), or 3.
1581  * + If a queue set is to hold a counting semaphore that has a maximum count of
1582  * 5, and a counting semaphore that has a maximum count of 3, then
1583  * uxEventQueueLength should be set to (5 + 3), or 8.
1584  *
1585  * @return If the queue set is created successfully then a handle to the created
1586  * queue set is returned. Otherwise NULL is returned.
1587  */
1588 QueueSetHandle_t xQueueCreateSet( const UBaseType_t uxEventQueueLength ) PRIVILEGED_FUNCTION;
1589 
1590 /*
1591  * Adds a queue or semaphore to a queue set that was previously created by a
1592  * call to xQueueCreateSet().
1593  *
1594  * See FreeRTOS/Source/Demo/Common/Minimal/QueueSet.c for an example using this
1595  * function.
1596  *
1597  * Note 1: A receive (in the case of a queue) or take (in the case of a
1598  * semaphore) operation must not be performed on a member of a queue set unless
1599  * a call to xQueueSelectFromSet() has first returned a handle to that set member.
1600  *
1601  * @param xQueueOrSemaphore The handle of the queue or semaphore being added to
1602  * the queue set (cast to an QueueSetMemberHandle_t type).
1603  *
1604  * @param xQueueSet The handle of the queue set to which the queue or semaphore
1605  * is being added.
1606  *
1607  * @return If the queue or semaphore was successfully added to the queue set
1608  * then pdPASS is returned. If the queue could not be successfully added to the
1609  * queue set because it is already a member of a different queue set then pdFAIL
1610  * is returned.
1611  */
1612 BaseType_t xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet ) PRIVILEGED_FUNCTION;
1613 
1614 /*
1615  * Removes a queue or semaphore from a queue set. A queue or semaphore can only
1616  * be removed from a set if the queue or semaphore is empty.
1617  *
1618  * See FreeRTOS/Source/Demo/Common/Minimal/QueueSet.c for an example using this
1619  * function.
1620  *
1621  * @param xQueueOrSemaphore The handle of the queue or semaphore being removed
1622  * from the queue set (cast to an QueueSetMemberHandle_t type).
1623  *
1624  * @param xQueueSet The handle of the queue set in which the queue or semaphore
1625  * is included.
1626  *
1627  * @return If the queue or semaphore was successfully removed from the queue set
1628  * then pdPASS is returned. If the queue was not in the queue set, or the
1629  * queue (or semaphore) was not empty, then pdFAIL is returned.
1630  */
1631 BaseType_t xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet ) PRIVILEGED_FUNCTION;
1632 
1633 /*
1634  * xQueueSelectFromSet() selects from the members of a queue set a queue or
1635  * semaphore that either contains data (in the case of a queue) or is available
1636  * to take (in the case of a semaphore). xQueueSelectFromSet() effectively
1637  * allows a task to block (pend) on a read operation on all the queues and
1638  * semaphores in a queue set simultaneously.
1639  *
1640  * See FreeRTOS/Source/Demo/Common/Minimal/QueueSet.c for an example using this
1641  * function.
1642  *
1643  * Note 1: See the documentation on http://wwwFreeRTOS.org/RTOS-queue-sets.html
1644  * for reasons why queue sets are very rarely needed in practice as there are
1645  * simpler methods of blocking on multiple objects.
1646  *
1647  * Note 2: Blocking on a queue set that contains a mutex will not cause the
1648  * mutex holder to inherit the priority of the blocked task.
1649  *
1650  * Note 3: A receive (in the case of a queue) or take (in the case of a
1651  * semaphore) operation must not be performed on a member of a queue set unless
1652  * a call to xQueueSelectFromSet() has first returned a handle to that set member.
1653  *
1654  * @param xQueueSet The queue set on which the task will (potentially) block.
1655  *
1656  * @param xTicksToWait The maximum time, in ticks, that the calling task will
1657  * remain in the Blocked state (with other tasks executing) to wait for a member
1658  * of the queue set to be ready for a successful queue read or semaphore take
1659  * operation.
1660  *
1661  * @return xQueueSelectFromSet() will return the handle of a queue (cast to
1662  * a QueueSetMemberHandle_t type) contained in the queue set that contains data,
1663  * or the handle of a semaphore (cast to a QueueSetMemberHandle_t type) contained
1664  * in the queue set that is available, or NULL if no such queue or semaphore
1665  * exists before before the specified block time expires.
1666  */
1667 QueueSetMemberHandle_t xQueueSelectFromSet( QueueSetHandle_t xQueueSet, const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
1668 
1669 /*
1670  * A version of xQueueSelectFromSet() that can be used from an ISR.
1671  */
1672 QueueSetMemberHandle_t xQueueSelectFromSetFromISR( QueueSetHandle_t xQueueSet ) PRIVILEGED_FUNCTION;
1673 
1674 /* Not public API functions. */
1675 void vQueueWaitForMessageRestricted( QueueHandle_t xQueue, TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
1676 BaseType_t xQueueGenericReset( QueueHandle_t xQueue, BaseType_t xNewQueue ) PRIVILEGED_FUNCTION;
1677 void vQueueSetQueueNumber( QueueHandle_t xQueue, UBaseType_t uxQueueNumber ) PRIVILEGED_FUNCTION;
1678 UBaseType_t uxQueueGetQueueNumber( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
1679 uint8_t ucQueueGetQueueType( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
1680 
1681 
1682 #ifdef __cplusplus
1683 }
1684 #endif
1685 
1686 #endif /* QUEUE_H */
1687 
BaseType_t xQueueAddToSet(QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet) PRIVILEGED_FUNCTION
BaseType_t xQueueTakeMutexRecursive(QueueHandle_t xMutex, TickType_t xTicksToWait) PRIVILEGED_FUNCTION
BaseType_t xQueueCRSendFromISR(QueueHandle_t xQueue, const void *pvItemToQueue, BaseType_t xCoRoutinePreviouslyWoken)
void vQueueDelete(QueueHandle_t xQueue) PRIVILEGED_FUNCTION
Definition: queue.c:1544
void * QueueSetMemberHandle_t
Definition: queue.h:98
void vQueueSetQueueNumber(QueueHandle_t xQueue, UBaseType_t uxQueueNumber) PRIVILEGED_FUNCTION
#define vQueueAddToRegistry(xQueue, pcName)
Definition: FreeRTOS.h:314
BaseType_t xQueueIsQueueEmptyFromISR(const QueueHandle_t xQueue) PRIVILEGED_FUNCTION
Definition: queue.c:1822
BaseType_t xQueueGenericSend(QueueHandle_t xQueue, const void *const pvItemToQueue, TickType_t xTicksToWait, const BaseType_t xCopyPosition) PRIVILEGED_FUNCTION
Definition: queue.c:593
BaseType_t xQueueGenericReset(QueueHandle_t xQueue, BaseType_t xNewQueue) PRIVILEGED_FUNCTION
Definition: queue.c:255
void * xQueueGetMutexHolder(QueueHandle_t xSemaphore) PRIVILEGED_FUNCTION
QueueSetHandle_t xQueueCreateSet(const UBaseType_t uxEventQueueLength) PRIVILEGED_FUNCTION
void * QueueSetHandle_t
Definition: queue.h:91
unsigned long UBaseType_t
Definition: portmacro.h:95
uint32_t TickType_t
Definition: portmacro.h:101
QueueSetMemberHandle_t xQueueSelectFromSet(QueueSetHandle_t xQueueSet, const TickType_t xTicksToWait) PRIVILEGED_FUNCTION
#define vQueueUnregisterQueue(xQueue)
Definition: FreeRTOS.h:315
QueueSetMemberHandle_t xQueueSelectFromSetFromISR(QueueSetHandle_t xQueueSet) PRIVILEGED_FUNCTION
BaseType_t xQueueAltGenericReceive(QueueHandle_t xQueue, void *const pvBuffer, TickType_t xTicksToWait, BaseType_t xJustPeeking)
BaseType_t xQueueGenericSendFromISR(QueueHandle_t xQueue, const void *const pvItemToQueue, BaseType_t *const pxHigherPriorityTaskWoken, const BaseType_t xCopyPosition) PRIVILEGED_FUNCTION
Definition: queue.c:1025
long BaseType_t
Definition: portmacro.h:94
BaseType_t xQueueGiveMutexRecursive(QueueHandle_t pxMutex) PRIVILEGED_FUNCTION
UBaseType_t uxQueueGetQueueNumber(QueueHandle_t xQueue) PRIVILEGED_FUNCTION
BaseType_t xQueueCRReceiveFromISR(QueueHandle_t xQueue, void *pvBuffer, BaseType_t *pxTaskWoken)
uint8_t ucQueueGetQueueType(QueueHandle_t xQueue) PRIVILEGED_FUNCTION
void * QueueHandle_t
Definition: queue.h:84
void vQueueWaitForMessageRestricted(QueueHandle_t xQueue, TickType_t xTicksToWait) PRIVILEGED_FUNCTION
BaseType_t xQueueIsQueueFullFromISR(const QueueHandle_t xQueue) PRIVILEGED_FUNCTION
Definition: queue.c:1861
UBaseType_t uxQueueSpacesAvailable(const QueueHandle_t xQueue) PRIVILEGED_FUNCTION
Definition: queue.c:1514
BaseType_t xQueueAltGenericSend(QueueHandle_t xQueue, const void *const pvItemToQueue, TickType_t xTicksToWait, BaseType_t xCopyPosition)
UBaseType_t uxQueueMessagesWaitingFromISR(const QueueHandle_t xQueue) PRIVILEGED_FUNCTION
Definition: queue.c:1532
BaseType_t xQueueReceiveFromISR(QueueHandle_t xQueue, void *const pvBuffer, BaseType_t *const pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION
Definition: queue.c:1358
BaseType_t xQueuePeekFromISR(QueueHandle_t xQueue, void *const pvBuffer) PRIVILEGED_FUNCTION
Definition: queue.c:1445
UBaseType_t uxQueueMessagesWaiting(const QueueHandle_t xQueue) PRIVILEGED_FUNCTION
Definition: queue.c:1498
BaseType_t xQueueCRSend(QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait)
QueueHandle_t xQueueCreateMutex(const uint8_t ucQueueType) PRIVILEGED_FUNCTION
BaseType_t xQueueRemoveFromSet(QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet) PRIVILEGED_FUNCTION
#define PRIVILEGED_FUNCTION
Definition: mpu_wrappers.h:145
BaseType_t xQueueGenericReceive(QueueHandle_t xQueue, void *const pvBuffer, TickType_t xTicksToWait, const BaseType_t xJustPeek) PRIVILEGED_FUNCTION
Definition: queue.c:1169
BaseType_t xQueueCRReceive(QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksToWait)
QueueHandle_t xQueueCreateCountingSemaphore(const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount) PRIVILEGED_FUNCTION
QueueHandle_t xQueueGenericCreate(const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, const uint8_t ucQueueType) PRIVILEGED_FUNCTION
Definition: queue.c:308