/*\r
- FreeRTOS V7.4.2 - Copyright (C) 2013 Real Time Engineers Ltd.\r
+ FreeRTOS V8.0.0 - Copyright (C) 2014 Real Time Engineers Ltd.\r
+ All rights reserved\r
\r
- FEATURES AND PORTS ARE ADDED TO FREERTOS ALL THE TIME. PLEASE VISIT\r
- http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
+ VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
\r
***************************************************************************\r
* *\r
- * FreeRTOS tutorial books are available in pdf and paperback. *\r
- * Complete, revised, and edited pdf reference manuals are also *\r
- * available. *\r
+ * FreeRTOS provides completely free yet professionally developed, *\r
+ * robust, strictly quality controlled, supported, and cross *\r
+ * platform software that has become a de facto standard. *\r
* *\r
- * Purchasing FreeRTOS documentation will not only help you, by *\r
- * ensuring you get running as quickly as possible and with an *\r
- * in-depth knowledge of how to use FreeRTOS, it will also help *\r
- * the FreeRTOS project to continue with its mission of providing *\r
- * professional grade, cross platform, de facto standard solutions *\r
- * for microcontrollers - completely free of charge! *\r
+ * Help yourself get started quickly and support the FreeRTOS *\r
+ * project by purchasing a FreeRTOS tutorial book, reference *\r
+ * manual, or both from: http://www.FreeRTOS.org/Documentation *\r
* *\r
- * >>> See http://www.FreeRTOS.org/Documentation for details. <<< *\r
- * *\r
- * Thank you for using FreeRTOS, and thank you for your support! *\r
+ * Thank you! *\r
* *\r
***************************************************************************\r
\r
-\r
This file is part of the FreeRTOS distribution.\r
\r
FreeRTOS is free software; you can redistribute it and/or modify it under\r
the terms of the GNU General Public License (version 2) as published by the\r
- Free Software Foundation AND MODIFIED BY the FreeRTOS exception.\r
+ Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.\r
\r
- >>>>>>NOTE<<<<<< The modification to the GPL is included to allow you to\r
- distribute a combined work that includes FreeRTOS without being obliged to\r
- provide the source code for proprietary components outside of the FreeRTOS\r
- kernel.\r
+ >>! NOTE: The modification to the GPL is included to allow you to distribute\r
+ >>! a combined work that includes FreeRTOS without being obliged to provide\r
+ >>! the source code for proprietary components outside of the FreeRTOS\r
+ >>! kernel.\r
\r
FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY\r
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\r
- FOR A PARTICULAR PURPOSE. See the GNU General Public License for more\r
- details. You should have received a copy of the GNU General Public License\r
- and the FreeRTOS license exception along with FreeRTOS; if not it can be\r
- viewed here: http://www.freertos.org/a00114.html and also obtained by\r
- writing to Real Time Engineers Ltd., contact details for whom are available\r
- on the FreeRTOS WEB site.\r
+ FOR A PARTICULAR PURPOSE. Full license text is available from the following\r
+ link: http://www.freertos.org/a00114.html\r
\r
1 tab == 4 spaces!\r
\r
* *\r
***************************************************************************\r
\r
-\r
http://www.FreeRTOS.org - Documentation, books, training, latest versions,\r
license and Real Time Engineers Ltd. contact details.\r
\r
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,\r
- including FreeRTOS+Trace - an indispensable productivity tool, and our new\r
- fully thread aware and reentrant UDP/IP stack.\r
+ including FreeRTOS+Trace - an indispensable productivity tool, a DOS\r
+ compatible FAT file system, and our tiny thread aware UDP/IP stack.\r
\r
http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High\r
- Integrity Systems, who sell the code with commercial support,\r
- indemnification and middleware, under the OpenRTOS brand.\r
+ Integrity Systems to sell under the OpenRTOS brand. Low cost OpenRTOS\r
+ licenses offer ticketed support, indemnification and middleware.\r
\r
http://www.SafeRTOS.com - High Integrity Systems also provide a safety\r
engineered and independently SIL3 certified version for use in safety and\r
mission critical applications that require provable dependability.\r
+\r
+ 1 tab == 4 spaces!\r
*/\r
\r
/*\r
*\r
* One counter task loops indefinitely, incrementing the shared count variable\r
* on each iteration. To ensure it has exclusive access to the variable it\r
- * raises it's priority above that of the controller task before each\r
- * increment, lowering it again to it's original priority before starting the\r
+ * raises its priority above that of the controller task before each\r
+ * increment, lowering it again to its original priority before starting the\r
* next iteration.\r
*\r
* The other counter task increments the shared count variable on each\r
- * iteration of it's loop until the count has reached a limit of 0xff - at\r
+ * iteration of its loop until the count has reached a limit of 0xff - at\r
* which point it suspends itself. It will not start a new loop until the\r
- * controller task has made it "ready" again by calling vTaskResume ().\r
+ * controller task has made it "ready" again by calling vTaskResume().\r
* This second counter task operates at a higher priority than controller\r
* task so does not need to worry about mutual exclusion of the counter\r
* variable.\r
* continuous count task, and moves on to its second section.\r
*\r
* At the start of the second section the shared variable is cleared to zero.\r
- * The limited count task is then woken from it's suspension by a call to\r
+ * The limited count task is then woken from its suspension by a call to\r
* vTaskResume (). As this counter task operates at a higher priority than\r
* the controller task the controller task should not run again until the\r
* shared variable has been counted up to the limited value causing the counter\r
\r
/* Demo task specific constants. */\r
#define priSTACK_SIZE ( configMINIMAL_STACK_SIZE )\r
-#define priSLEEP_TIME ( ( portTickType ) 128 / portTICK_RATE_MS )\r
+#define priSLEEP_TIME ( ( TickType_t ) 128 / portTICK_PERIOD_MS )\r
#define priLOOPS ( 5 )\r
#define priMAX_COUNT ( ( unsigned long ) 0xff )\r
-#define priNO_BLOCK ( ( portTickType ) 0 )\r
+#define priNO_BLOCK ( ( TickType_t ) 0 )\r
#define priSUSPENDED_QUEUE_LENGTH ( 1 )\r
\r
/*-----------------------------------------------------------*/\r
\r
/* Handles to the two counter tasks. These could be passed in as parameters\r
to the controller task to prevent them having to be file scope. */\r
-static xTaskHandle xContinousIncrementHandle, xLimitedIncrementHandle;\r
+static TaskHandle_t xContinuousIncrementHandle, xLimitedIncrementHandle;\r
\r
/* The shared counter variable. This is passed in as a parameter to the two\r
counter variables for demonstration purposes. */\r
-static unsigned long ulCounter;\r
+static volatile unsigned long ulCounter;\r
\r
/* Variables used to check that the tasks are still operating without error.\r
Each complete iteration of the controller task increments this variable\r
static volatile portBASE_TYPE xSuspendedQueueReceiveError = pdFALSE;\r
\r
/* Queue used by the second test. */\r
-xQueueHandle xSuspendedTestQueue;\r
+QueueHandle_t xSuspendedTestQueue;\r
\r
/* The value the queue receive task expects to receive next. This is file\r
scope so xAreDynamicPriorityTasksStillRunning() can ensure it is still\r
is not being used. The call to vQueueAddToRegistry() will be removed\r
by the pre-processor if configQUEUE_REGISTRY_SIZE is not defined or is\r
defined to be less than 1. */\r
- vQueueAddToRegistry( xSuspendedTestQueue, ( signed char * ) "Suspended_Test_Queue" );\r
+ vQueueAddToRegistry( xSuspendedTestQueue, "Suspended_Test_Queue" );\r
\r
- xTaskCreate( vContinuousIncrementTask, ( signed char * ) "CNT_INC", priSTACK_SIZE, ( void * ) &ulCounter, tskIDLE_PRIORITY, &xContinousIncrementHandle );\r
- xTaskCreate( vLimitedIncrementTask, ( signed char * ) "LIM_INC", priSTACK_SIZE, ( void * ) &ulCounter, tskIDLE_PRIORITY + 1, &xLimitedIncrementHandle );\r
- xTaskCreate( vCounterControlTask, ( signed char * ) "C_CTRL", priSTACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );\r
- xTaskCreate( vQueueSendWhenSuspendedTask, ( signed char * ) "SUSP_TX", priSTACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );\r
- xTaskCreate( vQueueReceiveWhenSuspendedTask, ( signed char * ) "SUSP_RX", priSTACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );\r
+ xTaskCreate( vContinuousIncrementTask, "CNT_INC", priSTACK_SIZE, ( void * ) &ulCounter, tskIDLE_PRIORITY, &xContinuousIncrementHandle );\r
+ xTaskCreate( vLimitedIncrementTask, "LIM_INC", priSTACK_SIZE, ( void * ) &ulCounter, tskIDLE_PRIORITY + 1, &xLimitedIncrementHandle );\r
+ xTaskCreate( vCounterControlTask, "C_CTRL", priSTACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );\r
+ xTaskCreate( vQueueSendWhenSuspendedTask, "SUSP_TX", priSTACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );\r
+ xTaskCreate( vQueueReceiveWhenSuspendedTask, "SUSP_RX", priSTACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );\r
}\r
/*-----------------------------------------------------------*/\r
\r
*/\r
static portTASK_FUNCTION( vContinuousIncrementTask, pvParameters )\r
{\r
-unsigned long *pulCounter;\r
+volatile unsigned long *pulCounter;\r
unsigned portBASE_TYPE uxOurPriority;\r
\r
/* Take a pointer to the shared variable from the parameters passed into\r
\r
for( ;; )\r
{\r
- /* Raise our priority above the controller task to ensure a context\r
- switch does not occur while we are accessing this variable. */\r
+ /* Raise the priority above the controller task to ensure a context\r
+ switch does not occur while the variable is being accessed. */\r
vTaskPrioritySet( NULL, uxOurPriority + 1 );\r
+ {\r
+ configASSERT( ( uxTaskPriorityGet( NULL ) == ( uxOurPriority + 1 ) ) );\r
( *pulCounter )++;\r
+ }\r
vTaskPrioritySet( NULL, uxOurPriority );\r
+\r
+ #if( configUSE_PREEMPTION == 0 )\r
+ taskYIELD();\r
+ #endif\r
+\r
+ configASSERT( ( uxTaskPriorityGet( NULL ) == uxOurPriority ) );\r
}\r
}\r
/*-----------------------------------------------------------*/\r
for( sLoops = 0; sLoops < priLOOPS; sLoops++ )\r
{\r
/* Suspend the continuous count task so we can take a mirror of the\r
- shared variable without risk of corruption. */\r
- vTaskSuspend( xContinousIncrementHandle );\r
+ shared variable without risk of corruption. This is not really\r
+ needed as the other task raises its priority above this task's\r
+ priority. */\r
+ vTaskSuspend( xContinuousIncrementHandle );\r
+ {\r
+ #if( INCLUDE_eTaskGetState == 1 )\r
+ {\r
+ configASSERT( eTaskGetState( xContinuousIncrementHandle ) == eSuspended );\r
+ }\r
+ #endif /* INCLUDE_eTaskGetState */\r
+\r
ulLastCounter = ulCounter;\r
- vTaskResume( xContinousIncrementHandle );\r
+ }\r
+ vTaskResume( xContinuousIncrementHandle );\r
+\r
+ #if( configUSE_PREEMPTION == 0 )\r
+ taskYIELD();\r
+ #endif\r
+\r
+ #if( INCLUDE_eTaskGetState == 1 )\r
+ {\r
+ configASSERT( eTaskGetState( xContinuousIncrementHandle ) == eReady );\r
+ }\r
+ #endif /* INCLUDE_eTaskGetState */\r
\r
/* Now delay to ensure the other task has processor time. */\r
vTaskDelay( priSLEEP_TIME );\r
xTaskResumeAll();\r
}\r
\r
-\r
/* Second section: */\r
\r
- /* Suspend the continuous counter task so it stops accessing the shared variable. */\r
- vTaskSuspend( xContinousIncrementHandle );\r
+ /* Suspend the continuous counter task so it stops accessing the shared\r
+ variable. */\r
+ vTaskSuspend( xContinuousIncrementHandle );\r
\r
/* Reset the variable. */\r
ulCounter = ( unsigned long ) 0;\r
\r
+ #if( INCLUDE_eTaskGetState == 1 )\r
+ {\r
+ configASSERT( eTaskGetState( xLimitedIncrementHandle ) == eSuspended );\r
+ }\r
+ #endif /* INCLUDE_eTaskGetState */\r
+\r
/* Resume the limited count task which has a higher priority than us.\r
We should therefore not return from this call until the limited count\r
task has suspended itself with a known value in the counter variable. */\r
vTaskResume( xLimitedIncrementHandle );\r
\r
+ #if( configUSE_PREEMPTION == 0 )\r
+ taskYIELD();\r
+ #endif\r
+\r
+ /* This task should not run again until xLimitedIncrementHandle has\r
+ suspended itself. */\r
+ #if( INCLUDE_eTaskGetState == 1 )\r
+ {\r
+ configASSERT( eTaskGetState( xLimitedIncrementHandle ) == eSuspended );\r
+ }\r
+ #endif /* INCLUDE_eTaskGetState */\r
+\r
/* Does the counter variable have the expected value? */\r
if( ulCounter != priMAX_COUNT )\r
{\r
}\r
\r
/* Resume the continuous count task and do it all again. */\r
- vTaskResume( xContinousIncrementHandle );\r
+ vTaskResume( xContinuousIncrementHandle );\r
+\r
+ #if( configUSE_PREEMPTION == 0 )\r
+ taskYIELD();\r
+ #endif\r
}\r
}\r
/*-----------------------------------------------------------*/\r
projects / freertos / blobdiff