static portTASK_FUNCTION( vPolledQueueConsumer, pvParameters ) { unsigned portSHORT usData, usExpectedValue = ( unsigned portSHORT ) 0; signed portBASE_TYPE xError = pdFALSE; #ifdef USE_STDIO void vPrintDisplayMessage( const portCHAR * const * ppcMessageToSend ); const portCHAR * const pcTaskStartMsg = "Alt blocking queue consumer task started.\r\n"; /* Queue a message for printing to say the task has started. */ vPrintDisplayMessage( &pcTaskStartMsg ); #endif for( ;; ) { /* Loop until the queue is empty. */ while( uxQueueMessagesWaiting( *( ( xQueueHandle * ) pvParameters ) ) ) { if( xQueueAltReceive( *( ( xQueueHandle * ) pvParameters ), &usData, pollqNO_DELAY ) == pdPASS ) { if( usData != usExpectedValue ) { /* This is not what we expected to receive so an error has occurred. */ xError = pdTRUE; /* Catch-up to the value we received so our next expected value should again be correct. */ usExpectedValue = usData; } else { if( xError == pdFALSE ) { /* Only increment the check variable if no errors have occurred. */ portENTER_CRITICAL(); xPollingConsumerCount++; portEXIT_CRITICAL(); } } /* Next time round we would expect the number to be one higher. */ usExpectedValue++; } } /* Now the queue is empty we block, allowing the producer to place more items in the queue. */ vTaskDelay( pollqCONSUMER_DELAY ); } } /*lint !e818 Function prototype must conform to API. */
static portTASK_FUNCTION( vBlockingQueueConsumer, pvParameters ) { unsigned portSHORT usData, usExpectedValue = 0; xBlockingQueueParameters *pxQueueParameters; portSHORT sErrorEverOccurred = pdFALSE; #ifdef USE_STDIO void vPrintDisplayMessage( const portCHAR * const * ppcMessageToSend ); const portCHAR * const pcTaskStartMsg = "Alt blocking queue consumer task started.\r\n"; /* Queue a message for printing to say the task has started. */ vPrintDisplayMessage( &pcTaskStartMsg ); #endif pxQueueParameters = ( xBlockingQueueParameters * ) pvParameters; for( ;; ) { if( xQueueAltReceive( pxQueueParameters->xQueue, &usData, pxQueueParameters->xBlockTime ) == pdPASS ) { if( usData != usExpectedValue ) { /* Catch-up. */ usExpectedValue = usData; sErrorEverOccurred = pdTRUE; } else { /* We have successfully received a message, so increment the variable used to check we are still running. */ if( sErrorEverOccurred == pdFALSE ) { ( *pxQueueParameters->psCheckVariable )++; } /* Increment the value we expect to remove from the queue next time round. */ ++usExpectedValue; } } } }
static void vPrimaryBlockTimeTestTask( void *pvParameters ) { portBASE_TYPE xItem, xData; portTickType xTimeWhenBlocking; portTickType xTimeToBlock, xBlockedTime; #ifdef USE_STDIO void vPrintDisplayMessage( const portCHAR * const * ppcMessageToSend ); const portCHAR * const pcTaskStartMsg = "Alt primary block time test started.\r\n"; /* Queue a message for printing to say the task has started. */ vPrintDisplayMessage( &pcTaskStartMsg ); #endif ( void ) pvParameters; for( ;; ) { /********************************************************************* Test 1 Simple block time wakeup test on queue receives. */ for( xItem = 0; xItem < bktQUEUE_LENGTH; xItem++ ) { /* The queue is empty. Attempt to read from the queue using a block time. When we wake, ensure the delta in time is as expected. */ xTimeToBlock = bktPRIMARY_BLOCK_TIME << xItem; /* A critical section is used to minimise the jitter in the time measurements. */ portENTER_CRITICAL(); { xTimeWhenBlocking = xTaskGetTickCount(); /* We should unblock after xTimeToBlock having not received anything on the queue. */ if( xQueueAltReceive( xTestQueue, &xData, xTimeToBlock ) != errQUEUE_EMPTY ) { xErrorOccurred = pdTRUE; } /* How long were we blocked for? */ xBlockedTime = xTaskGetTickCount() - xTimeWhenBlocking; } portEXIT_CRITICAL(); if( xBlockedTime < xTimeToBlock ) { /* Should not have blocked for less than we requested. */ xErrorOccurred = pdTRUE; } if( xBlockedTime > ( xTimeToBlock + bktALLOWABLE_MARGIN ) ) { /* Should not have blocked for longer than we requested, although we would not necessarily run as soon as we were unblocked so a margin is allowed. */ xErrorOccurred = pdTRUE; } } #if configUSE_PREEMPTION == 0 taskYIELD(); #endif /********************************************************************* Test 2 Simple block time wakeup test on queue sends. First fill the queue. It should be empty so all sends should pass. */ for( xItem = 0; xItem < bktQUEUE_LENGTH; xItem++ ) { if( xQueueAltSendToBack( xTestQueue, &xItem, bktDONT_BLOCK ) != pdPASS ) { xErrorOccurred = pdTRUE; } } for( xItem = 0; xItem < bktQUEUE_LENGTH; xItem++ ) { /* The queue is full. Attempt to write to the queue using a block time. When we wake, ensure the delta in time is as expected. */ xTimeToBlock = bktPRIMARY_BLOCK_TIME << xItem; portENTER_CRITICAL(); { xTimeWhenBlocking = xTaskGetTickCount(); /* We should unblock after xTimeToBlock having not received anything on the queue. */ if( xQueueAltSendToBack( xTestQueue, &xItem, xTimeToBlock ) != errQUEUE_FULL ) { xErrorOccurred = pdTRUE; } /* How long were we blocked for? */ xBlockedTime = xTaskGetTickCount() - xTimeWhenBlocking; } portEXIT_CRITICAL(); if( xBlockedTime < xTimeToBlock ) { /* Should not have blocked for less than we requested. */ xErrorOccurred = pdTRUE; } if( xBlockedTime > ( xTimeToBlock + bktALLOWABLE_MARGIN ) ) { /* Should not have blocked for longer than we requested, although we would not necessarily run as soon as we were unblocked so a margin is allowed. */ xErrorOccurred = pdTRUE; } } #if configUSE_PREEMPTION == 0 taskYIELD(); #endif /********************************************************************* Test 3 Wake the other task, it will block attempting to post to the queue. When we read from the queue the other task will wake, but before it can run we will post to the queue again. When the other task runs it will find the queue still full, even though it was woken. It should recognise that its block time has not expired and return to block for the remains of its block time. Wake the other task so it blocks attempting to post to the already full queue. */ xRunIndicator = 0; vTaskResume( xSecondary ); /* We need to wait a little to ensure the other task executes. */ while( xRunIndicator != bktRUN_INDICATOR ) { /* The other task has not yet executed. */ vTaskDelay( bktSHORT_WAIT ); } /* Make sure the other task is blocked on the queue. */ vTaskDelay( bktSHORT_WAIT ); xRunIndicator = 0; for( xItem = 0; xItem < bktQUEUE_LENGTH; xItem++ ) { /* Now when we make space on the queue the other task should wake but not execute as this task has higher priority. */ if( xQueueAltReceive( xTestQueue, &xData, bktDONT_BLOCK ) != pdPASS ) { xErrorOccurred = pdTRUE; } /* Now fill the queue again before the other task gets a chance to execute. If the other task had executed we would find the queue full ourselves, and the other task have set xRunIndicator. */ if( xQueueAltSendToBack( xTestQueue, &xItem, bktDONT_BLOCK ) != pdPASS ) { xErrorOccurred = pdTRUE; } if( xRunIndicator == bktRUN_INDICATOR ) { /* The other task should not have executed. */ xErrorOccurred = pdTRUE; } /* Raise the priority of the other task so it executes and blocks on the queue again. */ vTaskPrioritySet( xSecondary, bktPRIMARY_PRIORITY + 2 ); /* The other task should now have re-blocked without exiting the queue function. */ if( xRunIndicator == bktRUN_INDICATOR ) { /* The other task should not have executed outside of the queue function. */ xErrorOccurred = pdTRUE; } /* Set the priority back down. */ vTaskPrioritySet( xSecondary, bktSECONDARY_PRIORITY ); } /* Let the other task timeout. When it unblockes it will check that it unblocked at the correct time, then suspend itself. */ while( xRunIndicator != bktRUN_INDICATOR ) { vTaskDelay( bktSHORT_WAIT ); } vTaskDelay( bktSHORT_WAIT ); xRunIndicator = 0; #if configUSE_PREEMPTION == 0 taskYIELD(); #endif /********************************************************************* Test 4 As per test 3 - but with the send and receive the other way around. The other task blocks attempting to read from the queue. Empty the queue. We should find that it is full. */ for( xItem = 0; xItem < bktQUEUE_LENGTH; xItem++ ) { if( xQueueAltReceive( xTestQueue, &xData, bktDONT_BLOCK ) != pdPASS ) { xErrorOccurred = pdTRUE; } } /* Wake the other task so it blocks attempting to read from the already empty queue. */ vTaskResume( xSecondary ); /* We need to wait a little to ensure the other task executes. */ while( xRunIndicator != bktRUN_INDICATOR ) { vTaskDelay( bktSHORT_WAIT ); } vTaskDelay( bktSHORT_WAIT ); xRunIndicator = 0; for( xItem = 0; xItem < bktQUEUE_LENGTH; xItem++ ) { /* Now when we place an item on the queue the other task should wake but not execute as this task has higher priority. */ if( xQueueAltSendToBack( xTestQueue, &xItem, bktDONT_BLOCK ) != pdPASS ) { xErrorOccurred = pdTRUE; } /* Now empty the queue again before the other task gets a chance to execute. If the other task had executed we would find the queue empty ourselves, and the other task would be suspended. */ if( xQueueAltReceive( xTestQueue, &xData, bktDONT_BLOCK ) != pdPASS ) { xErrorOccurred = pdTRUE; } if( xRunIndicator == bktRUN_INDICATOR ) { /* The other task should not have executed. */ xErrorOccurred = pdTRUE; } /* Raise the priority of the other task so it executes and blocks on the queue again. */ vTaskPrioritySet( xSecondary, bktPRIMARY_PRIORITY + 2 ); /* The other task should now have re-blocked without exiting the queue function. */ if( xRunIndicator == bktRUN_INDICATOR ) { /* The other task should not have executed outside of the queue function. */ xErrorOccurred = pdTRUE; } vTaskPrioritySet( xSecondary, bktSECONDARY_PRIORITY ); } /* Let the other task timeout. When it unblockes it will check that it unblocked at the correct time, then suspend itself. */ while( xRunIndicator != bktRUN_INDICATOR ) { vTaskDelay( bktSHORT_WAIT ); } vTaskDelay( bktSHORT_WAIT ); xPrimaryCycles++; } }
static void vSecondaryBlockTimeTestTask( void *pvParameters ) { portTickType xTimeWhenBlocking, xBlockedTime; portBASE_TYPE xData; #ifdef USE_STDIO void vPrintDisplayMessage( const portCHAR * const * ppcMessageToSend ); const portCHAR * const pcTaskStartMsg = "Alt secondary block time test started.\r\n"; /* Queue a message for printing to say the task has started. */ vPrintDisplayMessage( &pcTaskStartMsg ); #endif ( void ) pvParameters; for( ;; ) { /********************************************************************* Test 1 and 2 This task does does not participate in these tests. */ vTaskSuspend( NULL ); /********************************************************************* Test 3 The first thing we do is attempt to read from the queue. It should be full so we block. Note the time before we block so we can check the wake time is as per that expected. */ portENTER_CRITICAL(); { xTimeWhenBlocking = xTaskGetTickCount(); /* We should unblock after bktTIME_TO_BLOCK having not received anything on the queue. */ xData = 0; xRunIndicator = bktRUN_INDICATOR; if( xQueueAltSendToBack( xTestQueue, &xData, bktTIME_TO_BLOCK ) != errQUEUE_FULL ) { xErrorOccurred = pdTRUE; } /* How long were we inside the send function? */ xBlockedTime = xTaskGetTickCount() - xTimeWhenBlocking; } portEXIT_CRITICAL(); /* We should not have blocked for less time than bktTIME_TO_BLOCK. */ if( xBlockedTime < bktTIME_TO_BLOCK ) { xErrorOccurred = pdTRUE; } /* We should of not blocked for much longer than bktALLOWABLE_MARGIN either. A margin is permitted as we would not necessarily run as soon as we unblocked. */ if( xBlockedTime > ( bktTIME_TO_BLOCK + bktALLOWABLE_MARGIN ) ) { xErrorOccurred = pdTRUE; } /* Suspend ready for test 3. */ xRunIndicator = bktRUN_INDICATOR; vTaskSuspend( NULL ); /********************************************************************* Test 4 As per test three, but with the send and receive reversed. */ portENTER_CRITICAL(); { xTimeWhenBlocking = xTaskGetTickCount(); /* We should unblock after bktTIME_TO_BLOCK having not received anything on the queue. */ xRunIndicator = bktRUN_INDICATOR; if( xQueueAltReceive( xTestQueue, &xData, bktTIME_TO_BLOCK ) != errQUEUE_EMPTY ) { xErrorOccurred = pdTRUE; } xBlockedTime = xTaskGetTickCount() - xTimeWhenBlocking; } portEXIT_CRITICAL(); /* We should not have blocked for less time than bktTIME_TO_BLOCK. */ if( xBlockedTime < bktTIME_TO_BLOCK ) { xErrorOccurred = pdTRUE; } /* We should of not blocked for much longer than bktALLOWABLE_MARGIN either. A margin is permitted as we would not necessarily run as soon as we unblocked. */ if( xBlockedTime > ( bktTIME_TO_BLOCK + bktALLOWABLE_MARGIN ) ) { xErrorOccurred = pdTRUE; } xRunIndicator = bktRUN_INDICATOR; xSecondaryCycles++; } }
static void prvSendFrontAndBackTest( void *pvParameters ) { unsigned portLONG ulData, ulData2; xQueueHandle xQueue; #ifdef USE_STDIO void vPrintDisplayMessage( const portCHAR * const * ppcMessageToSend ); const portCHAR * const pcTaskStartMsg = "Alt queue SendToFront/SendToBack/Peek test started.\r\n"; /* Queue a message for printing to say the task has started. */ vPrintDisplayMessage( &pcTaskStartMsg ); #endif xQueue = ( xQueueHandle ) pvParameters; for( ;; ) { /* The queue is empty, so sending an item to the back of the queue should have the same efect as sending it to the front of the queue. First send to the front and check everything is as expected. */ xQueueAltSendToFront( xQueue, ( void * ) &ulLoopCounter, genqNO_BLOCK ); if( uxQueueMessagesWaiting( xQueue ) != 1 ) { xErrorDetected = pdTRUE; } if( xQueueAltReceive( xQueue, ( void * ) &ulData, genqNO_BLOCK ) != pdPASS ) { xErrorDetected = pdTRUE; } /* The data we sent to the queue should equal the data we just received from the queue. */ if( ulLoopCounter != ulData ) { xErrorDetected = pdTRUE; } /* Then do the same, sending the data to the back, checking everything is as expected. */ if( uxQueueMessagesWaiting( xQueue ) != 0 ) { xErrorDetected = pdTRUE; } xQueueAltSendToBack( xQueue, ( void * ) &ulLoopCounter, genqNO_BLOCK ); if( uxQueueMessagesWaiting( xQueue ) != 1 ) { xErrorDetected = pdTRUE; } if( xQueueAltReceive( xQueue, ( void * ) &ulData, genqNO_BLOCK ) != pdPASS ) { xErrorDetected = pdTRUE; } if( uxQueueMessagesWaiting( xQueue ) != 0 ) { xErrorDetected = pdTRUE; } /* The data we sent to the queue should equal the data we just received from the queue. */ if( ulLoopCounter != ulData ) { xErrorDetected = pdTRUE; } #if configUSE_PREEMPTION == 0 taskYIELD(); #endif /* Place 2, 3, 4 into the queue, adding items to the back of the queue. */ for( ulData = 2; ulData < 5; ulData++ ) { xQueueAltSendToBack( xQueue, ( void * ) &ulData, genqNO_BLOCK ); } /* Now the order in the queue should be 2, 3, 4, with 2 being the first thing to be read out. Now add 1 then 0 to the front of the queue. */ if( uxQueueMessagesWaiting( xQueue ) != 3 ) { xErrorDetected = pdTRUE; } ulData = 1; xQueueAltSendToFront( xQueue, ( void * ) &ulData, genqNO_BLOCK ); ulData = 0; xQueueAltSendToFront( xQueue, ( void * ) &ulData, genqNO_BLOCK ); /* Now the queue should be full, and when we read the data out we should receive 0, 1, 2, 3, 4. */ if( uxQueueMessagesWaiting( xQueue ) != 5 ) { xErrorDetected = pdTRUE; } if( xQueueAltSendToFront( xQueue, ( void * ) &ulData, genqNO_BLOCK ) != errQUEUE_FULL ) { xErrorDetected = pdTRUE; } if( xQueueAltSendToBack( xQueue, ( void * ) &ulData, genqNO_BLOCK ) != errQUEUE_FULL ) { xErrorDetected = pdTRUE; } #if configUSE_PREEMPTION == 0 taskYIELD(); #endif /* Check the data we read out is in the expected order. */ for( ulData = 0; ulData < genqQUEUE_LENGTH; ulData++ ) { /* Try peeking the data first. */ if( xQueueAltPeek( xQueue, &ulData2, genqNO_BLOCK ) != pdPASS ) { xErrorDetected = pdTRUE; } if( ulData != ulData2 ) { xErrorDetected = pdTRUE; } /* Now try receiving the data for real. The value should be the same. Clobber the value first so we know we really received it. */ ulData2 = ~ulData2; if( xQueueAltReceive( xQueue, &ulData2, genqNO_BLOCK ) != pdPASS ) { xErrorDetected = pdTRUE; } if( ulData != ulData2 ) { xErrorDetected = pdTRUE; } } /* The queue should now be empty again. */ if( uxQueueMessagesWaiting( xQueue ) != 0 ) { xErrorDetected = pdTRUE; } #if configUSE_PREEMPTION == 0 taskYIELD(); #endif /* Our queue is empty once more, add 10, 11 to the back. */ ulData = 10; if( xQueueAltSendToBack( xQueue, &ulData, genqNO_BLOCK ) != pdPASS ) { xErrorDetected = pdTRUE; } ulData = 11; if( xQueueAltSendToBack( xQueue, &ulData, genqNO_BLOCK ) != pdPASS ) { xErrorDetected = pdTRUE; } if( uxQueueMessagesWaiting( xQueue ) != 2 ) { xErrorDetected = pdTRUE; } /* Now we should have 10, 11 in the queue. Add 7, 8, 9 to the front. */ for( ulData = 9; ulData >= 7; ulData-- ) { if( xQueueAltSendToFront( xQueue, ( void * ) &ulData, genqNO_BLOCK ) != pdPASS ) { xErrorDetected = pdTRUE; } } /* Now check that the queue is full, and that receiving data provides the expected sequence of 7, 8, 9, 10, 11. */ if( uxQueueMessagesWaiting( xQueue ) != 5 ) { xErrorDetected = pdTRUE; } if( xQueueAltSendToFront( xQueue, ( void * ) &ulData, genqNO_BLOCK ) != errQUEUE_FULL ) { xErrorDetected = pdTRUE; } if( xQueueAltSendToBack( xQueue, ( void * ) &ulData, genqNO_BLOCK ) != errQUEUE_FULL ) { xErrorDetected = pdTRUE; } #if configUSE_PREEMPTION == 0 taskYIELD(); #endif /* Check the data we read out is in the expected order. */ for( ulData = 7; ulData < ( 7 + genqQUEUE_LENGTH ); ulData++ ) { if( xQueueAltReceive( xQueue, &ulData2, genqNO_BLOCK ) != pdPASS ) { xErrorDetected = pdTRUE; } if( ulData != ulData2 ) { xErrorDetected = pdTRUE; } } if( uxQueueMessagesWaiting( xQueue ) != 0 ) { xErrorDetected = pdTRUE; } ulLoopCounter++; } }