len0rd/FreeRTOS-Kernel
1
0
Fork 0
mirror of https://github.com/FreeRTOS/FreeRTOS-Kernel.git synced 2025-04-19 21:11:57 -04:00
Code Issues Packages Projects Releases Wiki Activity

Update some standard demo task implementations so they can be used with the cooperative scheduler.

Browse source
This commit is contained in:
Richard Barry 2013-11-07 14:04:05 +00:00
parent 5aabe4f8fb
commit 40d2e74417
7 changed files with 105 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

37
FreeRTOS/Demo/Common/Minimal/BlockQ.c
View file

@ -1,5 +1,5 @@
/* /*
FreeRTOS V7.5.3 - Copyright (C) 2013 Real Time Engineers Ltd. FreeRTOS V7.5.3 - Copyright (C) 2013 Real Time Engineers Ltd.
All rights reserved All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION. VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
@ -136,7 +136,7 @@ const portTickType xBlockTime = ( portTickType ) 1000 / portTICK_RATE_MS;
const portTickType xDontBlock = ( portTickType ) 0; const portTickType xDontBlock = ( portTickType ) 0;
/* Create the first two tasks as described at the top of the file. */ /* Create the first two tasks as described at the top of the file. */
/* First create the structure used to pass parameters to the consumer tasks. */ /* First create the structure used to pass parameters to the consumer tasks. */
pxQueueParameters1 = ( xBlockingQueueParameters * ) pvPortMalloc( sizeof( xBlockingQueueParameters ) ); pxQueueParameters1 = ( xBlockingQueueParameters * ) pvPortMalloc( sizeof( xBlockingQueueParameters ) );
@ -150,7 +150,7 @@ const portTickType xDontBlock = ( portTickType ) 0;
/* Pass in the variable that this task is going to increment so we can check it /* Pass in the variable that this task is going to increment so we can check it
is still running. */ is still running. */
pxQueueParameters1->psCheckVariable = &( sBlockingConsumerCount[ 0 ] ); pxQueueParameters1->psCheckVariable = &( sBlockingConsumerCount[ 0 ] );
/* Create the structure used to pass parameters to the producer task. */ /* Create the structure used to pass parameters to the producer task. */
pxQueueParameters2 = ( xBlockingQueueParameters * ) pvPortMalloc( sizeof( xBlockingQueueParameters ) ); pxQueueParameters2 = ( xBlockingQueueParameters * ) pvPortMalloc( sizeof( xBlockingQueueParameters ) );
@ -171,7 +171,7 @@ const portTickType xDontBlock = ( portTickType ) 0;
xTaskCreate( vBlockingQueueConsumer, ( signed char * ) "QConsB1", blckqSTACK_SIZE, ( void * ) pxQueueParameters1, uxPriority, NULL ); xTaskCreate( vBlockingQueueConsumer, ( signed char * ) "QConsB1", blckqSTACK_SIZE, ( void * ) pxQueueParameters1, uxPriority, NULL );
xTaskCreate( vBlockingQueueProducer, ( signed char * ) "QProdB2", blckqSTACK_SIZE, ( void * ) pxQueueParameters2, tskIDLE_PRIORITY, NULL ); xTaskCreate( vBlockingQueueProducer, ( signed char * ) "QProdB2", blckqSTACK_SIZE, ( void * ) pxQueueParameters2, tskIDLE_PRIORITY, NULL );
/* Create the second two tasks as described at the top of the file. This uses /* Create the second two tasks as described at the top of the file. This uses
the same mechanism but reverses the task priorities. */ the same mechanism but reverses the task priorities. */
@ -201,7 +201,7 @@ const portTickType xDontBlock = ( portTickType ) 0;
pxQueueParameters6 = ( xBlockingQueueParameters * ) pvPortMalloc( sizeof( xBlockingQueueParameters ) ); pxQueueParameters6 = ( xBlockingQueueParameters * ) pvPortMalloc( sizeof( xBlockingQueueParameters ) );
pxQueueParameters6->xQueue = pxQueueParameters5->xQueue; pxQueueParameters6->xQueue = pxQueueParameters5->xQueue;
pxQueueParameters6->xBlockTime = xBlockTime; pxQueueParameters6->xBlockTime = xBlockTime;
pxQueueParameters6->psCheckVariable = &( sBlockingConsumerCount[ 2 ] ); pxQueueParameters6->psCheckVariable = &( sBlockingConsumerCount[ 2 ] );
xTaskCreate( vBlockingQueueProducer, ( signed char * ) "QProdB5", blckqSTACK_SIZE, ( void * ) pxQueueParameters5, tskIDLE_PRIORITY, NULL ); xTaskCreate( vBlockingQueueProducer, ( signed char * ) "QProdB5", blckqSTACK_SIZE, ( void * ) pxQueueParameters5, tskIDLE_PRIORITY, NULL );
xTaskCreate( vBlockingQueueConsumer, ( signed char * ) "QConsB6", blckqSTACK_SIZE, ( void * ) pxQueueParameters6, tskIDLE_PRIORITY, NULL ); xTaskCreate( vBlockingQueueConsumer, ( signed char * ) "QConsB6", blckqSTACK_SIZE, ( void * ) pxQueueParameters6, tskIDLE_PRIORITY, NULL );
@ -217,7 +217,7 @@ short sErrorEverOccurred = pdFALSE;
pxQueueParameters = ( xBlockingQueueParameters * ) pvParameters; pxQueueParameters = ( xBlockingQueueParameters * ) pvParameters;
for( ;; ) for( ;; )
{ {
if( xQueueSend( pxQueueParameters->xQueue, ( void * ) &usValue, pxQueueParameters->xBlockTime ) != pdPASS ) if( xQueueSend( pxQueueParameters->xQueue, ( void * ) &usValue, pxQueueParameters->xBlockTime ) != pdPASS )
{ {
sErrorEverOccurred = pdTRUE; sErrorEverOccurred = pdTRUE;
@ -234,6 +234,10 @@ short sErrorEverOccurred = pdFALSE;
/* Increment the variable we are going to post next time round. The /* Increment the variable we are going to post next time round. The
consumer will expect the numbers to follow in numerical order. */ consumer will expect the numbers to follow in numerical order. */
++usValue; ++usValue;
#if configUSE_PREEMPTION == 0
taskYIELD();
#endif
} }
} }
} }
@ -248,7 +252,7 @@ short sErrorEverOccurred = pdFALSE;
pxQueueParameters = ( xBlockingQueueParameters * ) pvParameters; pxQueueParameters = ( xBlockingQueueParameters * ) pvParameters;
for( ;; ) for( ;; )
{ {
if( xQueueReceive( pxQueueParameters->xQueue, &usData, pxQueueParameters->xBlockTime ) == pdPASS ) if( xQueueReceive( pxQueueParameters->xQueue, &usData, pxQueueParameters->xBlockTime ) == pdPASS )
{ {
if( usData != usExpectedValue ) if( usData != usExpectedValue )
@ -261,17 +265,26 @@ short sErrorEverOccurred = pdFALSE;
else else
{ {
/* We have successfully received a message, so increment the /* We have successfully received a message, so increment the
variable used to check we are still running. */ variable used to check we are still running. */
if( sErrorEverOccurred == pdFALSE ) if( sErrorEverOccurred == pdFALSE )
{ {
( *pxQueueParameters->psCheckVariable )++; ( *pxQueueParameters->psCheckVariable )++;
} }
/* Increment the value we expect to remove from the queue next time /* Increment the value we expect to remove from the queue next time
round. */ round. */
++usExpectedValue; ++usExpectedValue;
} }
}
#if configUSE_PREEMPTION == 0
{
if( pxQueueParameters->xBlockTime == 0 )
{
taskYIELD();
}
}
#endif
}
} }
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -286,7 +299,7 @@ portBASE_TYPE xReturn = pdPASS, xTasks;
/* Not too worried about mutual exclusion on these variables as they are 16 /* Not too worried about mutual exclusion on these variables as they are 16
bits and we are only reading them. We also only care to see if they have bits and we are only reading them. We also only care to see if they have
changed or not. changed or not.
Loop through each check variable to and return pdFALSE if any are found not Loop through each check variable to and return pdFALSE if any are found not
to have changed since the last call. */ to have changed since the last call. */

40
FreeRTOS/Demo/Common/Minimal/GenQTest.c
View file

@ -1,5 +1,5 @@
/* /*
FreeRTOS V7.5.3 - Copyright (C) 2013 Real Time Engineers Ltd. FreeRTOS V7.5.3 - Copyright (C) 2013 Real Time Engineers Ltd.
All rights reserved All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION. VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
@ -64,12 +64,12 @@
*/ */
/* /*
* Tests the extra queue functionality introduced in FreeRTOS.org V4.5.0 - * Tests the extra queue functionality introduced in FreeRTOS.org V4.5.0 -
* including xQueueSendToFront(), xQueueSendToBack(), xQueuePeek() and * including xQueueSendToFront(), xQueueSendToBack(), xQueuePeek() and
* mutex behaviour. * mutex behaviour.
* *
* See the comments above the prvSendFrontAndBackTest() and * See the comments above the prvSendFrontAndBackTest() and
* prvLowPriorityMutexTask() prototypes below for more information. * prvLowPriorityMutexTask() prototypes below for more information.
*/ */
@ -151,10 +151,10 @@ xSemaphoreHandle xMutex;
xQueue = xQueueCreate( genqQUEUE_LENGTH, sizeof( unsigned portLONG ) ); xQueue = xQueueCreate( genqQUEUE_LENGTH, sizeof( unsigned portLONG ) );
/* vQueueAddToRegistry() adds the queue to the queue registry, if one is /* vQueueAddToRegistry() adds the queue to the queue registry, if one is
in use. The queue registry is provided as a means for kernel aware in use. The queue registry is provided as a means for kernel aware
debuggers to locate queues and has no purpose if a kernel aware debugger debuggers to locate queues and has no purpose if a kernel aware debugger
is not being used. The call to vQueueAddToRegistry() will be removed is not being used. The call to vQueueAddToRegistry() will be removed
by the pre-processor if configQUEUE_REGISTRY_SIZE is not defined or is by the pre-processor if configQUEUE_REGISTRY_SIZE is not defined or is
defined to be less than 1. */ defined to be less than 1. */
vQueueAddToRegistry( xQueue, ( signed portCHAR * ) "Gen_Queue_Test" ); vQueueAddToRegistry( xQueue, ( signed portCHAR * ) "Gen_Queue_Test" );
@ -167,10 +167,10 @@ xSemaphoreHandle xMutex;
xMutex = xSemaphoreCreateMutex(); xMutex = xSemaphoreCreateMutex();
/* vQueueAddToRegistry() adds the mutex to the registry, if one is /* vQueueAddToRegistry() adds the mutex to the registry, if one is
in use. The registry is provided as a means for kernel aware in use. The registry is provided as a means for kernel aware
debuggers to locate mutexes and has no purpose if a kernel aware debugger debuggers to locate mutexes and has no purpose if a kernel aware debugger
is not being used. The call to vQueueAddToRegistry() will be removed is not being used. The call to vQueueAddToRegistry() will be removed
by the pre-processor if configQUEUE_REGISTRY_SIZE is not defined or is by the pre-processor if configQUEUE_REGISTRY_SIZE is not defined or is
defined to be less than 1. */ defined to be less than 1. */
vQueueAddToRegistry( ( xQueueHandle ) xMutex, ( signed portCHAR * ) "Gen_Queue_Mutex" ); vQueueAddToRegistry( ( xQueueHandle ) xMutex, ( signed portCHAR * ) "Gen_Queue_Mutex" );
@ -190,7 +190,7 @@ xQueueHandle xQueue;
#ifdef USE_STDIO #ifdef USE_STDIO
void vPrintDisplayMessage( const portCHAR * const * ppcMessageToSend ); void vPrintDisplayMessage( const portCHAR * const * ppcMessageToSend );
const portCHAR * const pcTaskStartMsg = "Queue SendToFront/SendToBack/Peek test started.\r\n"; const portCHAR * const pcTaskStartMsg = "Queue SendToFront/SendToBack/Peek test started.\r\n";
/* Queue a message for printing to say the task has started. */ /* Queue a message for printing to say the task has started. */
@ -312,7 +312,7 @@ xQueueHandle xQueue;
{ {
xErrorDetected = pdTRUE; xErrorDetected = pdTRUE;
} }
/* Now try receiving the data for real. The value should be the /* Now try receiving the data for real. The value should be the
same. Clobber the value first so we know we really received it. */ same. Clobber the value first so we know we really received it. */
@ -417,7 +417,7 @@ xSemaphoreHandle xMutex = ( xSemaphoreHandle ) pvParameters;
#ifdef USE_STDIO #ifdef USE_STDIO
void vPrintDisplayMessage( const portCHAR * const * ppcMessageToSend ); void vPrintDisplayMessage( const portCHAR * const * ppcMessageToSend );
const portCHAR * const pcTaskStartMsg = "Mutex with priority inheritance test started.\r\n"; const portCHAR * const pcTaskStartMsg = "Mutex with priority inheritance test started.\r\n";
/* Queue a message for printing to say the task has started. */ /* Queue a message for printing to say the task has started. */
@ -446,6 +446,10 @@ xSemaphoreHandle xMutex = ( xSemaphoreHandle ) pvParameters;
mutex, and block when it finds it cannot obtain it. */ mutex, and block when it finds it cannot obtain it. */
vTaskResume( xHighPriorityMutexTask ); vTaskResume( xHighPriorityMutexTask );
#if configUSE_PREEMPTION == 0
taskYIELD();
#endif
/* Ensure the task is reporting it priority as blocked and not /* Ensure the task is reporting it priority as blocked and not
suspended (as it would have done in versions up to V7.5.3). */ suspended (as it would have done in versions up to V7.5.3). */
#if( INCLUDE_eTaskGetState == 1 ) #if( INCLUDE_eTaskGetState == 1 )
@ -490,6 +494,10 @@ xSemaphoreHandle xMutex = ( xSemaphoreHandle ) pvParameters;
xErrorDetected = pdTRUE; xErrorDetected = pdTRUE;
} }
#if configUSE_PREEMPTION == 0
taskYIELD();
#endif
/* Check that the guarded variable did indeed increment... */ /* Check that the guarded variable did indeed increment... */
if( ulGuardedVariable != 1 ) if( ulGuardedVariable != 1 )
{ {
@ -512,7 +520,7 @@ xSemaphoreHandle xMutex = ( xSemaphoreHandle ) pvParameters;
#if configUSE_PREEMPTION == 0 #if configUSE_PREEMPTION == 0
taskYIELD(); taskYIELD();
#endif #endif
} }
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -558,7 +566,7 @@ xSemaphoreHandle xMutex = ( xSemaphoreHandle ) pvParameters;
if( xSemaphoreGive( xMutex ) != pdPASS ) if( xSemaphoreGive( xMutex ) != pdPASS )
{ {
xErrorDetected = pdTRUE; xErrorDetected = pdTRUE;
} }
} }
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -581,7 +589,7 @@ static unsigned portLONG ulLastLoopCounter = 0, ulLastLoopCounter2 = 0;
} }
ulLastLoopCounter = ulLoopCounter; ulLastLoopCounter = ulLoopCounter;
ulLastLoopCounter2 = ulLoopCounter2; ulLastLoopCounter2 = ulLoopCounter2;
/* Errors detected in the task itself will have latched xErrorDetected /* Errors detected in the task itself will have latched xErrorDetected
to true. */ to true. */

38
FreeRTOS/Demo/Common/Minimal/QPeek.c
View file

@ -1,5 +1,5 @@
/* /*
FreeRTOS V7.5.3 - Copyright (C) 2013 Real Time Engineers Ltd. FreeRTOS V7.5.3 - Copyright (C) 2013 Real Time Engineers Ltd.
All rights reserved All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION. VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
@ -64,7 +64,7 @@
*/ */
/* /*
* Tests the behaviour when data is peeked from a queue when there are * Tests the behaviour when data is peeked from a queue when there are
* multiple tasks blocked on the queue. * multiple tasks blocked on the queue.
*/ */
@ -124,10 +124,10 @@ xQueueHandle xQueue;
xQueue = xQueueCreate( qpeekQUEUE_LENGTH, sizeof( unsigned portLONG ) ); xQueue = xQueueCreate( qpeekQUEUE_LENGTH, sizeof( unsigned portLONG ) );
/* vQueueAddToRegistry() adds the queue to the queue registry, if one is /* vQueueAddToRegistry() adds the queue to the queue registry, if one is
in use. The queue registry is provided as a means for kernel aware in use. The queue registry is provided as a means for kernel aware
debuggers to locate queues and has no purpose if a kernel aware debugger debuggers to locate queues and has no purpose if a kernel aware debugger
is not being used. The call to vQueueAddToRegistry() will be removed is not being used. The call to vQueueAddToRegistry() will be removed
by the pre-processor if configQUEUE_REGISTRY_SIZE is not defined or is by the pre-processor if configQUEUE_REGISTRY_SIZE is not defined or is
defined to be less than 1. */ defined to be less than 1. */
vQueueAddToRegistry( xQueue, ( signed portCHAR * ) "QPeek_Test_Queue" ); vQueueAddToRegistry( xQueue, ( signed portCHAR * ) "QPeek_Test_Queue" );
@ -149,7 +149,7 @@ unsigned portLONG ulValue;
#ifdef USE_STDIO #ifdef USE_STDIO
{ {
void vPrintDisplayMessage( const portCHAR * const * ppcMessageToSend ); void vPrintDisplayMessage( const portCHAR * const * ppcMessageToSend );
const portCHAR * const pcTaskStartMsg = "Queue peek test started.\r\n"; const portCHAR * const pcTaskStartMsg = "Queue peek test started.\r\n";
/* Queue a message for printing to say the task has started. */ /* Queue a message for printing to say the task has started. */
@ -202,7 +202,7 @@ unsigned portLONG ulValue;
xErrorDetected = pdTRUE; xErrorDetected = pdTRUE;
} }
/* Now we will block again as the queue is once more empty. The low /* Now we will block again as the queue is once more empty. The low
priority task can then execute again. */ priority task can then execute again. */
if( xQueuePeek( xQueue, &ulValue, portMAX_DELAY ) != pdPASS ) if( xQueuePeek( xQueue, &ulValue, portMAX_DELAY ) != pdPASS )
{ {
@ -245,7 +245,7 @@ unsigned portLONG ulValue;
xErrorDetected = pdTRUE; xErrorDetected = pdTRUE;
} }
vTaskSuspend( NULL ); vTaskSuspend( NULL );
} }
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -300,7 +300,7 @@ unsigned portLONG ulValue;
xErrorDetected = pdTRUE; xErrorDetected = pdTRUE;
} }
vTaskSuspend( NULL ); vTaskSuspend( NULL );
} }
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -353,7 +353,7 @@ unsigned portLONG ulValue;
for( ;; ) for( ;; )
{ {
/* Write some data to the queue. This should unblock the highest /* Write some data to the queue. This should unblock the highest
priority task that is waiting to peek data from the queue. */ priority task that is waiting to peek data from the queue. */
ulValue = 0x11223344; ulValue = 0x11223344;
if( xQueueSendToBack( xQueue, &ulValue, qpeekNO_BLOCK ) != pdPASS ) if( xQueueSendToBack( xQueue, &ulValue, qpeekNO_BLOCK ) != pdPASS )
@ -363,6 +363,10 @@ unsigned portLONG ulValue;
xErrorDetected = pdTRUE; xErrorDetected = pdTRUE;
} }
#if configUSE_PREEMPTION == 0
taskYIELD();
#endif
/* By the time we get here the data should have been removed from /* By the time we get here the data should have been removed from
the queue. */ the queue. */
if( uxQueueMessagesWaiting( xQueue ) != 0 ) if( uxQueueMessagesWaiting( xQueue ) != 0 )
@ -380,6 +384,10 @@ unsigned portLONG ulValue;
xErrorDetected = pdTRUE; xErrorDetected = pdTRUE;
} }
#if configUSE_PREEMPTION == 0
taskYIELD();
#endif
/* All the other tasks should now have successfully peeked the data. /* All the other tasks should now have successfully peeked the data.
The data is still in the queue so we should be able to receive it. */ The data is still in the queue so we should be able to receive it. */
ulValue = 0; ulValue = 0;
@ -393,7 +401,7 @@ unsigned portLONG ulValue;
{ {
/* We did not receive the expected value. */ /* We did not receive the expected value. */
} }
/* Lets just delay a while as this is an intensive test as we don't /* Lets just delay a while as this is an intensive test as we don't
want to starve other tests of processing time. */ want to starve other tests of processing time. */
vTaskDelay( qpeekSHORT_DELAY ); vTaskDelay( qpeekSHORT_DELAY );
@ -407,6 +415,10 @@ unsigned portLONG ulValue;
vTaskResume( xHighPriorityTask ); vTaskResume( xHighPriorityTask );
vTaskResume( xHighestPriorityTask ); vTaskResume( xHighestPriorityTask );
#if( configUSE_PREEMPTION == 0 )
taskYIELD();
#endif
ulValue = 0xaabbaabb; ulValue = 0xaabbaabb;
if( xQueueSendToFront( xQueue, &ulValue, qpeekNO_BLOCK ) != pdPASS ) if( xQueueSendToFront( xQueue, &ulValue, qpeekNO_BLOCK ) != pdPASS )
{ {
@ -415,6 +427,10 @@ unsigned portLONG ulValue;
xErrorDetected = pdTRUE; xErrorDetected = pdTRUE;
} }
#if configUSE_PREEMPTION == 0
taskYIELD();
#endif
/* This time we should find that the queue is empty. The high priority /* This time we should find that the queue is empty. The high priority
task actually removed the data rather than just peeking it. */ task actually removed the data rather than just peeking it. */
if( xQueuePeek( xQueue, &ulValue, qpeekNO_BLOCK ) != errQUEUE_EMPTY ) if( xQueuePeek( xQueue, &ulValue, qpeekNO_BLOCK ) != errQUEUE_EMPTY )
@ -427,7 +443,7 @@ unsigned portLONG ulValue;
and repeat the whole thing. The medium priority task should not be and repeat the whole thing. The medium priority task should not be
suspended as it was not able to peek the data in this last case. */ suspended as it was not able to peek the data in this last case. */
vTaskResume( xHighPriorityTask ); vTaskResume( xHighPriorityTask );
vTaskResume( xHighestPriorityTask ); vTaskResume( xHighestPriorityTask );
/* Lets just delay a while as this is an intensive test as we don't /* Lets just delay a while as this is an intensive test as we don't
want to starve other tests of processing time. */ want to starve other tests of processing time. */

8
FreeRTOS/Demo/Common/Minimal/QueueOverwrite.c
View file

@ -1,5 +1,5 @@
/* /*
FreeRTOS V7.5.3 - Copyright (C) 2013 Real Time Engineers Ltd. FreeRTOS V7.5.3 - Copyright (C) 2013 Real Time Engineers Ltd.
All rights reserved All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION. VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
@ -178,6 +178,10 @@ unsigned long ulValue, ulStatus = pdPASS, x;
error. */ error. */
ulLoopCounter++; ulLoopCounter++;
} }
#if( configUSE_PREEMPTION == 0 )
taskYIELD();
#endif
} }
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -236,7 +240,7 @@ unsigned long ulRx;
case 1: case 1:
/* The queue already holds ulTx1. Overwrite the value in the queue /* The queue already holds ulTx1. Overwrite the value in the queue
with ulTx2. */ with ulTx2. */
xQueueOverwriteFromISR( xISRQueue, &ulTx2, NULL ); xQueueOverwriteFromISR( xISRQueue, &ulTx2, NULL );
break; break;
case 2: case 2:

4
FreeRTOS/Demo/Common/Minimal/QueueSet.c
View file

@ -319,6 +319,10 @@ xQueueHandle xQueueInUse;
xQueueSetTasksStatus = pdFAIL; xQueueSetTasksStatus = pdFAIL;
} }
#if( configUSE_PREEMPTION == 0 )
taskYIELD();
#endif
ulTaskTxValue++; ulTaskTxValue++;
/* If the Tx value has reached the range used by the ISR then set it /* If the Tx value has reached the range used by the ISR then set it

19
FreeRTOS/Demo/Common/Minimal/dynamic.c
View file

@ -1,5 +1,5 @@
/* /*
FreeRTOS V7.5.3 - Copyright (C) 2013 Real Time Engineers Ltd. FreeRTOS V7.5.3 - Copyright (C) 2013 Real Time Engineers Ltd.
All rights reserved All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION. VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
@ -257,6 +257,11 @@ unsigned portBASE_TYPE uxOurPriority;
( *pulCounter )++; ( *pulCounter )++;
} }
vTaskPrioritySet( NULL, uxOurPriority ); vTaskPrioritySet( NULL, uxOurPriority );
#if( configUSE_PREEMPTION == 0 )
taskYIELD();
#endif
configASSERT( ( uxTaskPriorityGet( NULL ) == uxOurPriority ) ); configASSERT( ( uxTaskPriorityGet( NULL ) == uxOurPriority ) );
} }
} }
@ -300,6 +305,10 @@ short sError = pdFALSE;
} }
vTaskResume( xContinuousIncrementHandle ); vTaskResume( xContinuousIncrementHandle );
#if( configUSE_PREEMPTION == 0 )
taskYIELD();
#endif
#if( INCLUDE_eTaskGetState == 1 ) #if( INCLUDE_eTaskGetState == 1 )
{ {
configASSERT( eTaskGetState( xContinuousIncrementHandle ) == eReady ); configASSERT( eTaskGetState( xContinuousIncrementHandle ) == eReady );
@ -344,6 +353,10 @@ short sError = pdFALSE;
task has suspended itself with a known value in the counter variable. */ task has suspended itself with a known value in the counter variable. */
vTaskResume( xLimitedIncrementHandle ); vTaskResume( xLimitedIncrementHandle );
#if( configUSE_PREEMPTION == 0 )
taskYIELD();
#endif
/* This task should not run again until xLimitedIncrementHandle has /* This task should not run again until xLimitedIncrementHandle has
suspended itself. */ suspended itself. */
#if( INCLUDE_eTaskGetState == 1 ) #if( INCLUDE_eTaskGetState == 1 )
@ -368,6 +381,10 @@ short sError = pdFALSE;
/* Resume the continuous count task and do it all again. */ /* Resume the continuous count task and do it all again. */
vTaskResume( xContinuousIncrementHandle ); vTaskResume( xContinuousIncrementHandle );
#if( configUSE_PREEMPTION == 0 )
taskYIELD();
#endif
} }
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/

2
FreeRTOS/Demo/Common/Minimal/recmutex.c
View file

@ -1,5 +1,5 @@
/* /*
FreeRTOS V7.5.3 - Copyright (C) 2013 Real Time Engineers Ltd. FreeRTOS V7.5.3 - Copyright (C) 2013 Real Time Engineers Ltd.
All rights reserved All rights reserved
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION. VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.