FreeRTOS Support Archive
The FreeRTOS support forum is used to obtain active support directly from Real
Time Engineers Ltd. In return for using our top quality software and services for
free, we request you play fair and do your bit to help others too! Sign up
to receive notifications of new support topics then help where you can.
This is a read only archive of threads posted to the FreeRTOS support forum.
The archive is updated every week, so will not always contain the very latest posts.
Use these archive pages to search previous posts. Use the Live FreeRTOS Forum
link to reply to a post, or start a new support thread.
[FreeRTOS Home] [Live FreeRTOS Forum] [FAQ] [Archive Top] [December 2006 Threads] peek a queuePosted by Nobody/Anonymous on December 20, 2006 Is there a way to peek a queue, i.e. not remove the message from the queue, just see if it is there ?
RE: peek a queuePosted by Nobody/Anonymous on December 20, 2006 uxQueueMessagesWaiting() will tell you if there is anything on the queue but not let you actually look at what is on the queue. Is this what you want?
RE: peek a queuePosted by Nobody/Anonymous on December 20, 2006 Thank you, but I need to look at what is on the queue.
RE: peek a queuePosted by Nobody/Anonymous on December 20, 2006 I would suggest the following: signed portBASE_TYPE xQueuePeak( xQueueHandle pxQueue, void *pvBuffer, portTickType xTicksToWait) { signed portBASE_TYPE xReturn; signed portCHAR *pMsg; xTimeOutType xTimeOut;
//Make sure other tasks do not access the queue. */ vTaskSuspendAll();
/* Capture the current time status for future reference. */ vTaskSetTimeOutState( &xTimeOut );
/* Make sure interrupts do not access the queue. */ prvLockQueue( pxQueue );
do { /* If there are no messages in the queue we may have to block. */ if( prvIsQueueEmpty( pxQueue ) ) { /* There are no messages in the queue, do we want to block or just leave with nothing? */ if( xTicksToWait > ( portTickType ) 0 ) { vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait ); taskENTER_CRITICAL(); { prvUnlockQueue( pxQueue ); if( !xTaskResumeAll() ) { taskYIELD(); }
vTaskSuspendAll(); prvLockQueue( pxQueue ); } taskEXIT_CRITICAL(); } }
taskENTER_CRITICAL(); { if( pxQueue->uxMessagesWaiting > ( unsigned portBASE_TYPE ) 0 ) { pMsg=pxQueue->pcReadFrom; pMsg += pxQueue->uxItemSize; if( pMsg >= pxQueue->pcTail ) { pMsg = pxQueue->pcHead; } memcpy( ( void * ) pvBuffer, ( void * ) pMsg, ( unsigned ) pxQueue->uxItemSize );
/* Increment the lock count so prvUnlockQueue knows to check for tasks waiting for space to become available on the queue. */ //++( pxQueue->xRxLock ); xReturn = pdPASS; } else { xReturn = errQUEUE_EMPTY; } } taskEXIT_CRITICAL();
if( xReturn == errQUEUE_EMPTY ) { if( xTicksToWait > 0 ) { if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE ) { xReturn = queueERRONEOUS_UNBLOCK; } } } } while( xReturn == queueERRONEOUS_UNBLOCK );
/* We no longer require exclusive access to the queue. */ prvUnlockQueue( pxQueue ); xTaskResumeAll();
return xReturn; }
RE: peek a queuePosted by Nobody/Anonymous on December 20, 2006 Add this to queue.c
signed portBASE_TYPE xQueuePeek( xQueueHandle pxQueue, void *pvBuffer ) { signed portBASE_TYPE xReturn; xTimeOutType xTimeOut; unsigned char *pcReadFrom;
taskENTER_CRITICAL(); { if( pxQueue->uxMessagesWaiting > ( unsigned portBASE_TYPE ) 0 ) { pcReadFrom = pxQueue->pcReadFrom; pcReadFrom += pxQueue->uxItemSize; if( pcReadFrom >= pxQueue->pcTail ) { pcReadFrom = pxQueue->pcHead; }
memcpy( ( void * ) pvBuffer, ( void * ) pcReadFrom, ( unsigned ) pxQueue->uxItemSize );
xReturn = pdPASS; } else { xReturn = errQUEUE_EMPTY; } } taskEXIT_CRITICAL();
return xReturn; }
RE: peek a queuePosted by Jeff Smith on December 26, 2006 To the Nobody who suggested xQueuePeak(), I doubt anyone would want the "peek" function to block. The point would simply be to see what is there at the modment, or indicate that nothing is there. I suppose it would still work since you can wait 0, but still it complicates and slows down excecution, I think unnecessarily. (But could it be useful for things I didn't think of?)
RE: peek a queuePosted by Nobody/Anonymous on January 9, 2007 Just think of the case where you are waiting for a message to arrive, but don't want to remove it from the queue as it arrives. In that case it is useful to wait and not eat processor time polling the queue.
peek a queue from ISR?Posted by Christer on May 6, 2008 How about adding possibility to peek from interrupt routine? I need to use it in my XON/XOFF handle. Here is what I added that works for me. Rgrds
if( xQueuePeekFromISR( xCrsTXDQueue, &cChar ) == pdTRUE ) { ... }
//************************************************************************************ // // xQueuePeekFromISR // // Get serial port flow control. // // Input: xQueueHandle pxQueue // const void * const pvBuffer // // Output: signed portBASE_TYPE pdFAIL if no character // pdPASS if character found // // Sets: pvBuffer value // //************************************************************************************ signed portBASE_TYPE xQueuePeekFromISR( xQueueHandle pxQueue, const void * const pvBuffer ) { signed portBASE_TYPE xReturn;
/* We cannot block from an ISR, so check there is data available. */ if( pxQueue->uxMessagesWaiting > ( unsigned portBASE_TYPE ) 0 ) { prvCopyPeekDataFromQueue( pxQueue, pvBuffer ); // --( pxQueue->uxMessagesWaiting ); // Don't update number of messages in queue! xReturn = pdPASS; } else { xReturn = pdFAIL; }
return xReturn; }
//************************************************************************************ // // prvCopyPeekDataFromQueue // // Get data from queue without destroying it. // // Input: xQUEUE * const pxQueue // const void *pvBuffer // // Output: - // // Sets: data that pvBuffer points to // //************************************************************************************ static void prvCopyPeekDataFromQueue( xQUEUE * const pxQueue, const void *pvBuffer ) { signed portCHAR *pcTempReadFrom;
if( pxQueue->uxQueueType != queueQUEUE_IS_MUTEX ) { pcTempReadFrom = pxQueue->pcReadFrom + pxQueue->uxItemSize; // Point to new location if( pcTempReadFrom >= pxQueue->pcTail ) { pcTempReadFrom = pxQueue->pcHead; // Point to start of buffer } memcpy( ( void * ) pvBuffer, ( void * ) pcTempReadFrom, ( unsigned ) pxQueue->uxItemSize ); } }
Copyright (C) Amazon Web Services, Inc. or its affiliates. All rights reserved.
|