/*\r
- FreeRTOS V8.2.0rc1 - Copyright (C) 2014 Real Time Engineers Ltd.\r
+ FreeRTOS V9.0.0rc2 - Copyright (C) 2016 Real Time Engineers Ltd.\r
All rights reserved\r
\r
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\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
+ ***************************************************************************\r
>>! NOTE: The modification to the GPL is included to allow you to !<<\r
>>! distribute a combined work that includes FreeRTOS without being !<<\r
>>! obliged to provide the source code for proprietary components !<<\r
>>! outside of the FreeRTOS kernel. !<<\r
+ ***************************************************************************\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. Full license text is available on the following\r
link: http://www.freertos.org/a00114.html\r
\r
- 1 tab == 4 spaces!\r
-\r
- ***************************************************************************\r
- * *\r
- * Having a problem? Start by reading the FAQ "My application does *\r
- * not run, what could be wrong?". Have you defined configASSERT()? *\r
- * *\r
- * http://www.FreeRTOS.org/FAQHelp.html *\r
- * *\r
- ***************************************************************************\r
-\r
***************************************************************************\r
* *\r
* FreeRTOS provides completely free yet professionally developed, *\r
* *\r
***************************************************************************\r
\r
- ***************************************************************************\r
- * *\r
- * Investing in training allows your team to be as productive as *\r
- * possible as early as possible, lowering your overall development *\r
- * cost, and enabling you to bring a more robust product to market *\r
- * earlier than would otherwise be possible. Richard Barry is both *\r
- * the architect and key author of FreeRTOS, and so also the world's *\r
- * leading authority on what is the world's most popular real time *\r
- * kernel for deeply embedded MCU designs. Obtaining your training *\r
- * from Richard ensures your team will gain directly from his in-depth *\r
- * product knowledge and years of usage experience. Contact Real Time *\r
- * Engineers Ltd to enquire about the FreeRTOS Masterclass, presented *\r
- * by Richard Barry: http://www.FreeRTOS.org/contact\r
- * *\r
- ***************************************************************************\r
+ http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading\r
+ the FAQ page "My application does not run, what could be wrong?". Have you\r
+ defined configASSERT()?\r
\r
- ***************************************************************************\r
- * *\r
- * You are receiving this top quality software for free. Please play *\r
- * fair and reciprocate by reporting any suspected issues and *\r
- * participating in the community forum: *\r
- * http://www.FreeRTOS.org/support *\r
- * *\r
- * Thank you! *\r
- * *\r
- ***************************************************************************\r
+ http://www.FreeRTOS.org/support - In return for receiving this top quality\r
+ embedded software for free we request you assist our global community by\r
+ participating in the support forum.\r
\r
- http://www.FreeRTOS.org - Documentation, books, training, latest versions,\r
- license and Real Time Engineers Ltd. contact details.\r
+ http://www.FreeRTOS.org/training - Investing in training allows your team to\r
+ be as productive as possible as early as possible. Now you can receive\r
+ FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers\r
+ Ltd, and the world's leading authority on the world's leading RTOS.\r
\r
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,\r
including FreeRTOS+Trace - an indispensable productivity tool, a DOS\r
http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.\r
Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.\r
\r
- http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High\r
+ http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High\r
Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS\r
licenses offer ticketed support, indemnification and commercial middleware.\r
\r
#define portMAX_INTERRUPTS ( ( uint32_t ) sizeof( uint32_t ) * 8UL ) /* The number of bits in an uint32_t. */\r
#define portNO_CRITICAL_NESTING ( ( uint32_t ) 0 )\r
\r
+/* The priorities at which the various components of the simulation execute.\r
+Priorities are higher when a soak test is performed to lessen the effect of\r
+Windows interfering with the timing. */\r
+#define portSOAK_TEST\r
+#ifndef portSOAK_TEST\r
+ #define portDELETE_SELF_THREAD_PRIORITY THREAD_PRIORITY_HIGHEST /* Must be highest. */\r
+ #define portSIMULATED_INTERRUPTS_THREAD_PRIORITY THREAD_PRIORITY_NORMAL\r
+ #define portSIMULATED_TIMER_THREAD_PRIORITY THREAD_PRIORITY_BELOW_NORMAL\r
+ #define portTASK_THREAD_PRIORITY THREAD_PRIORITY_IDLE\r
+#else\r
+ #define portDELETE_SELF_THREAD_PRIORITY THREAD_PRIORITY_TIME_CRITICAL /* Must be highest. */\r
+ #define portSIMULATED_INTERRUPTS_THREAD_PRIORITY THREAD_PRIORITY_HIGHEST\r
+ #define portSIMULATED_TIMER_THREAD_PRIORITY THREAD_PRIORITY_ABOVE_NORMAL\r
+ #define portTASK_THREAD_PRIORITY THREAD_PRIORITY_NORMAL\r
+#endif\r
/*\r
* Created as a high priority thread, this function uses a timer to simulate\r
* a tick interrupt being generated on an embedded target. In this Windows\r
xThreadState *pxThreadState = NULL;\r
int8_t *pcTopOfStack = ( int8_t * ) pxTopOfStack;\r
\r
+ #ifdef portSOAK_TEST\r
+ {\r
+ /* Ensure highest priority class is inherited. */\r
+ if( !SetPriorityClass( GetCurrentProcess(), REALTIME_PRIORITY_CLASS ) )\r
+ {\r
+ printf( "SetPriorityClass() failed\r\n" );\r
+ }\r
+ }\r
+ #endif\r
+\r
/* In this simulated case a stack is not initialised, but instead a thread\r
is created that will execute the task being created. The thread handles\r
the context switching itself. The xThreadState object is placed onto\r
configASSERT( pxThreadState->pvThread );\r
SetThreadAffinityMask( pxThreadState->pvThread, 0x01 );\r
SetThreadPriorityBoost( pxThreadState->pvThread, TRUE );\r
- SetThreadPriority( pxThreadState->pvThread, THREAD_PRIORITY_IDLE );\r
+ SetThreadPriority( pxThreadState->pvThread, portTASK_THREAD_PRIORITY );\r
\r
return ( StackType_t * ) pxThreadState;\r
}\r
\r
if( lSuccess == pdPASS )\r
{\r
- if( SetThreadPriority( pvHandle, THREAD_PRIORITY_NORMAL ) == 0 )\r
+ if( SetThreadPriority( pvHandle, portSIMULATED_INTERRUPTS_THREAD_PRIORITY ) == 0 )\r
{\r
lSuccess = pdFAIL;\r
}\r
tick interrupts. The priority is set below that of the simulated\r
interrupt handler so the interrupt event mutex is used for the\r
handshake / overrun protection. */\r
- pvHandle = CreateThread( NULL, 0, prvSimulatedPeripheralTimer, NULL, 0, NULL );\r
+ pvHandle = CreateThread( NULL, 0, prvSimulatedPeripheralTimer, NULL, CREATE_SUSPENDED, NULL );\r
if( pvHandle != NULL )\r
{\r
- SetThreadPriority( pvHandle, THREAD_PRIORITY_BELOW_NORMAL );\r
+ SetThreadPriority( pvHandle, portSIMULATED_TIMER_THREAD_PRIORITY );\r
SetThreadPriorityBoost( pvHandle, TRUE );\r
SetThreadAffinityMask( pvHandle, 0x01 );\r
+ ResumeThread( pvHandle );\r
}\r
\r
/* Start the highest priority task by obtaining its associated thread\r
state structure, in which is stored the thread handle. */\r
- pxThreadState = ( xThreadState * ) *( ( uint32_t * ) pxCurrentTCB );\r
+ pxThreadState = ( xThreadState * ) *( ( size_t * ) pxCurrentTCB );\r
ulCriticalNesting = portNO_CRITICAL_NESTING;\r
\r
/* Bump up the priority of the thread that is going to run, in the\r
uint32_t ulSwitchRequired, i;\r
xThreadState *pxThreadState;\r
void *pvObjectList[ 2 ];\r
+CONTEXT xContext;\r
\r
/* Going to block on the mutex that ensured exclusive access to the simulated\r
interrupt objects, and the event that signals that a simulated interrupt\r
if( pvOldCurrentTCB != pxCurrentTCB )\r
{\r
/* Suspend the old thread. */\r
- pxThreadState = ( xThreadState *) *( ( uint32_t * ) pvOldCurrentTCB );\r
+ pxThreadState = ( xThreadState *) *( ( size_t * ) pvOldCurrentTCB );\r
SuspendThread( pxThreadState->pvThread );\r
\r
+ /* Ensure the thread is actually suspended by performing a\r
+ synchronous operation that can only complete when the thread is\r
+ actually suspended. The below code asks for dummy register\r
+ data. */\r
+ xContext.ContextFlags = CONTEXT_INTEGER;\r
+ ( void ) GetThreadContext( pxThreadState->pvThread, &xContext );\r
+\r
/* Obtain the state of the task now selected to enter the\r
Running state. */\r
- pxThreadState = ( xThreadState * ) ( *( uint32_t *) pxCurrentTCB );\r
+ pxThreadState = ( xThreadState * ) ( *( size_t *) pxCurrentTCB );\r
ResumeThread( pxThreadState->pvThread );\r
}\r
}\r
( void ) ulErrorCode;\r
\r
/* Find the handle of the thread being deleted. */\r
- pxThreadState = ( xThreadState * ) ( *( uint32_t *) pvTaskToDelete );\r
+ pxThreadState = ( xThreadState * ) ( *( size_t *) pvTaskToDelete );\r
\r
/* Check that the thread is still valid, it might have been closed by\r
vPortCloseRunningThread() - which will be the case if the task associated\r
( void ) ulErrorCode;\r
\r
/* Find the handle of the thread being deleted. */\r
- pxThreadState = ( xThreadState * ) ( *( uint32_t *) pvTaskToDelete );\r
+ pxThreadState = ( xThreadState * ) ( *( size_t *) pvTaskToDelete );\r
pvThread = pxThreadState->pvThread;\r
\r
/* Raise the Windows priority of the thread to ensure the FreeRTOS scheduler\r
does not run and swap it out before it is closed. If that were to happen\r
the thread would never run again and effectively be a thread handle and\r
memory leak. */\r
- SetThreadPriority( pvThread, THREAD_PRIORITY_ABOVE_NORMAL );\r
+ SetThreadPriority( pvThread, portDELETE_SELF_THREAD_PRIORITY );\r
\r
/* This function will not return, therefore a yield is set as pending to\r
ensure a context switch occurs away from this thread on the next tick. */\r
\r
if( ( ulInterruptNumber < portMAX_INTERRUPTS ) && ( pvInterruptEventMutex != NULL ) )\r
{\r
- /* Yield interrupts are processed even when critical nesting is non-zero. */\r
+ /* Yield interrupts are processed even when critical nesting is\r
+ non-zero. */\r
WaitForSingleObject( pvInterruptEventMutex, INFINITE );\r
ulPendingInterrupts |= ( 1 << ulInterruptNumber );\r
\r
- /* The simulated interrupt is now held pending, but don't actually process it\r
- yet if this call is within a critical section. It is possible for this to\r
- be in a critical section as calls to wait for mutexes are accumulative. */\r
+ /* The simulated interrupt is now held pending, but don't actually\r
+ process it yet if this call is within a critical section. It is\r
+ possible for this to be in a critical section as calls to wait for\r
+ mutexes are accumulative. */\r
if( ulCriticalNesting == 0 )\r
{\r
SetEvent( pvInterruptEvent );\r
projects / freertos / blobdiff