len0rd/FreeRTOS-Kernel
1
0
Fork 0
mirror of https://github.com/FreeRTOS/FreeRTOS-Kernel.git synced 2025-10-14 08:47:45 -04:00
Code Issues Projects Releases Packages Wiki Activity

Create GitHub Workflows that execute the p3 FreeRTOS Kernel Demos (#1018)

Browse source 
* test full demo

* Revert "test full demo"

This reverts commit 09efa00ec0a3f021f190112fa11bc0f4c6c058bb.

revert back to origin

* pre-define user demo to blinky demo

* pre-define user demo to blinky demo with -j

* test run win32-msvc demo

* test run win32-msvc demo

* test run win32-msvc demo

* update git workflow to run WIN32-MSVC demo

* update git workflow to run WIN32-MSVC demo

* update git workflow to run WIN32-MSVC demo

* update git workflow to run WIN32-MSVC demo

* update git workflow to run WIN32-MSVC demo

* update git workflow to run WIN32-MSVC demo

* update git workflow to run WIN32-MSVC demo

* update trigger action

* build and run WIN32-MSVC blinky demo

* build and run WIN32-MSVC blinky demo

* build and run WIN32-MSVC blinky demo

* update WIN32-MSVC workflow

* update WIN32-MSVC Demo main.c file to remove buffer

* Update main.c files to remove buffer when running executable_monitor file for Git Action

* update formatting for WIN32-MSVC demos

* update formatting for Posix demo

* update comment for setvbuf function used in main.c

* add git build and run action for WIN32-MingW Full and Blinky demos; update main.c file to set buffer size as 0

* add git build and run action for WIN32-MingW Full and Blinky demos; update main.c file to set buffer size as 0

* remove whitespace for freertos_demos.yml file

* add function to Force stdout to write immediately by setting the buffer size for it to 0 in demo main.c file when running git Run Action; Correct formatting error for WIN32-MingW main.c file

* add function to Force stdout to write immediately by setting the buffer size for it to 0 in demo main.c file when running git Run Action

* update git run action commands for Posix_GCC demo

* update git run action commands for Posix_GCC demo

* update git run action commands for Posix_GCC demo

* reduce timeout and correct formatting issue

* reduce timeout

---------

Co-authored-by: Xiaodong Li <xiaodonn@amazon.com>
This commit is contained in:
Xiaodong Li 2023-06-09 10:01:35 -07:00 • committed by GitHub
parent d60b34c8e2
commit 9ccae851e7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
5 changed files with 478 additions and 375 deletions
Download patch file Download diff file Expand all files Collapse all files

128
.github/workflows/freertos_demos.yml vendored
View file

@ -2,6 +2,7 @@ name: FreeRTOS Demos
on: on:
push: push:
pull_request: pull_request:
workflow_dispatch:
jobs: jobs:
WIN32-MSVC: WIN32-MSVC:
@ -19,13 +20,60 @@ jobs:
- name: Add msbuild to PATH - name: Add msbuild to PATH
uses: microsoft/setup-msbuild@v1.1 uses: microsoft/setup-msbuild@v1.1
- name: Build WIN32-MSVC Demo - name: Build WIN32-MSVC Full Demo
id: build-win32-msvs-full-demo
working-directory: FreeRTOS/Demo/WIN32-MSVC working-directory: FreeRTOS/Demo/WIN32-MSVC
run: msbuild WIN32.sln -t:rebuild run: |
$content = Get-Content -Path 'main.c' -Raw
$newContent = $content -replace 'int\s+main(.*?)void(.*?)\r?\n\s*{', 'int main( void ){setvbuf( stdout, NULL, _IONBF, 0 );'
$newContent | Set-Content -Path 'main.c'
msbuild WIN32.sln -t:rebuild
- name: Run and monitor WIN32-MSVC Full Demo
if: success() || failure() && steps.build-win32-msvs-full-demo.outcome == 'success'
uses: FreeRTOS/CI-CD-GitHub-Actions/executable-monitor@main
with:
exe-path: FreeRTOS/Demo/WIN32-MSVC/Debug/RTOSDemo.exe
log-dir: demo_run_logs
timeout-seconds: 60
success-line: "No errors - tick count"
- name: Build WIN32-MSVC Blinky Demo
id: build-win32-msvs-blinky-demo
working-directory: FreeRTOS/Demo/WIN32-MSVC
run: |
$content = Get-Content -Path 'main.c' -Raw
$newContent = $content -replace '#define\s+mainCREATE_SIMPLE_BLINKY_DEMO_ONLY\s+0', '#define mainCREATE_SIMPLE_BLINKY_DEMO_ONLY 1'
$newContent = $newContent -replace 'int\s+main(.*?)void(.*?)\r?\n\s*{', 'int main( void ){setvbuf( stdout, NULL, _IONBF, 0 );'
$newContent | Set-Content -Path 'main.c'
msbuild WIN32.sln -t:rebuild
- name: Run and monitor WIN32-MSVC Blinky Demo
if: success() || failure() && steps.build-win32-msvs-blinky-demo.outcome == 'success'
uses: FreeRTOS/CI-CD-GitHub-Actions/executable-monitor@main
with:
exe-path: FreeRTOS/Demo/WIN32-MSVC/Debug/RTOSDemo.exe
log-dir: demo_run_logs
timeout-seconds: 60
success-line: "Message received from software timer"
- name: Build WIN32-MSVC-Static-Allocation-Only Demo - name: Build WIN32-MSVC-Static-Allocation-Only Demo
id: build-win32-msvs-static-allocation-only-demo
working-directory: FreeRTOS/Demo/WIN32-MSVC-Static-Allocation-Only working-directory: FreeRTOS/Demo/WIN32-MSVC-Static-Allocation-Only
run: msbuild WIN32.sln -t:rebuild run: |
$content = Get-Content -Path 'main.c' -Raw
$newContent = $content -replace 'int\s+main(.*?)void(.*?)\r?\n\s*{', 'int main( void ){setvbuf( stdout, NULL, _IONBF, 0 );'
$newContent | Set-Content -Path 'main.c'
msbuild WIN32.sln -t:rebuild
- name: Run and monitor WIN32-MSVC-Static-Allocation-Only Demo
if: success() || failure() && steps.build-win32-msvs-static-allocation-only-demo.outcome == 'success'
uses: FreeRTOS/CI-CD-GitHub-Actions/executable-monitor@main
with:
exe-path: FreeRTOS/Demo/WIN32-MSVC-Static-Allocation-Only/Debug/RTOSDemo.exe
log-dir: demo_run_logs
timeout-seconds: 60
success-line: "No errors - tick count"
WIN32-MingW: WIN32-MingW:
name: WIN32 MingW name: WIN32 MingW
@ -44,15 +92,49 @@ jobs:
run: | run: |
git submodule update --checkout --init --depth 1 FreeRTOS/Source git submodule update --checkout --init --depth 1 FreeRTOS/Source
- name: Build WIN32-MingW Demo - name: Build WIN32-MingW Full Demo
id: build-win32-mingw-full-demo
working-directory: FreeRTOS/Demo/WIN32-MingW working-directory: FreeRTOS/Demo/WIN32-MingW
run: | run: |
$content = Get-Content -Path 'main.c' -Raw
$newContent = $content -replace 'int\s+main(.*?)void(.*?)\r?\n\s*{', 'int main( void ){setvbuf( stdout, NULL, _IONBF, 0 );'
$newContent | Set-Content -Path 'main.c'
gcc --version gcc --version
make --version make --version
make make
- name: Run and monitor WIN32-MingW Full Demo
if: success() || failure() && steps.build-win32-mingw-full-demo.outcome == 'success'
uses: FreeRTOS/CI-CD-GitHub-Actions/executable-monitor@main
with:
exe-path: FreeRTOS/Demo/WIN32-MingW/build/RTOSDemo.exe
log-dir: demo_run_logs
timeout-seconds: 60
success-line: "No errors - tick count"
- name: Build WIN32-MingW Blinky Demo
id: build-win32-mingw-blinky-demo
working-directory: FreeRTOS/Demo/WIN32-MingW
run: |
$content = Get-Content -Path 'main.c' -Raw
$newContent = $content -replace '#define\s+mainCREATE_SIMPLE_BLINKY_DEMO_ONLY\s+0', '#define mainCREATE_SIMPLE_BLINKY_DEMO_ONLY 1'
$newContent = $newContent -replace 'int\s+main(.*?)void(.*?)\r?\n\s*{', 'int main( void ){setvbuf( stdout, NULL, _IONBF, 0 );'
$newContent | Set-Content -Path 'main.c'
gcc --version
make --version
make
- name: Run and monitor WIN32-MingW Blinky Demo
if: success() || failure() && steps.build-win32-mingw-blinky-demo.outcome == 'success'
uses: FreeRTOS/CI-CD-GitHub-Actions/executable-monitor@main
with:
exe-path: FreeRTOS/Demo/WIN32-MingW/build/RTOSDemo.exe
log-dir: demo_run_logs
timeout-seconds: 60
success-line: "Message received from software timer"
POSIX-GCC: POSIX-GCC:
name: Native GCC name: Posix GCC
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- name: Checkout Repository - name: Checkout Repository
@ -73,19 +155,17 @@ jobs:
shell: bash shell: bash
working-directory: FreeRTOS/Demo/Posix_GCC working-directory: FreeRTOS/Demo/Posix_GCC
run: | run: |
sed -i -z "s/int[[:space:]]*main[[:space:]]*([[:space:]]*void[[:space:]]*)\n{/int main( void ){setvbuf( stdout, NULL, _IONBF, 0 );/g" main.c
make -j make -j
- name: Run and monitor Posix_GCC Full Demo - name: Run and monitor Posix_GCC Full Demo
if: success() || failure() && steps.build-posix-gcc-full-demo.outcome == 'success' if: success() || failure() && steps.build-posix-gcc-full-demo.outcome == 'success'
working-directory: FreeRTOS/Demo/Posix_GCC uses: FreeRTOS/CI-CD-GitHub-Actions/executable-monitor@main
run: | with:
timeout 5m build/posix_demo | tee output.txt exe-path: FreeRTOS/Demo/Posix_GCC/build/posix_demo
if grep -q "OK: No errors" output.txt; then log-dir: demo_run_logs
echo -e "\nSUCCESS - Found SUCCESS string in output." timeout-seconds: 60
else success-line: "OK: No errors"
echo -e "\nFAILURE - SUCCESS string not found in output."
exit 1
fi
- name: Build Posix_GCC Blinky Demo - name: Build Posix_GCC Blinky Demo
id: build-posix-gcc-blinky-demo id: build-posix-gcc-blinky-demo
@ -93,20 +173,18 @@ jobs:
shell: bash shell: bash
working-directory: FreeRTOS/Demo/Posix_GCC working-directory: FreeRTOS/Demo/Posix_GCC
run: | run: |
sed -i "s/#define[[:space:]]\+mainSELECTED_APPLICATION[[:space:]]\+FULL_DEMO/#define mainSELECTED_APPLICATION BLINKY_DEMO/g" main.c sed -i -z "s/int[[:space:]]*main[[:space:]]*([[:space:]]*void[[:space:]]*)\n{/int main( void ){setvbuf( stdout, NULL, _IONBF, 0 );/g" main.c
make -j rm -rf build
make -j USER_DEMO=BLINKY_DEMO
- name: Run and monitor Posix_GCC Blinky Demo - name: Run and monitor Posix_GCC Blinky Demo
if: success() || failure() && steps.build-posix-gcc-blinky-demo.outcome == 'success' if: success() || failure() && steps.build-posix-gcc-blinky-demo.outcome == 'success'
working-directory: FreeRTOS/Demo/Posix_GCC uses: FreeRTOS/CI-CD-GitHub-Actions/executable-monitor@main
run: | with:
timeout 30s build/posix_demo | tee output.txt exe-path: FreeRTOS/Demo/Posix_GCC/build/posix_demo
if grep -q "Message received from software timer" output.txt; then log-dir: demo_run_logs
echo -e "\nSUCCESS - Found SUCCESS string in output." timeout-seconds: 60
else success-line: "Message received from software timer"
echo -e "\nFAILURE - SUCCESS string not found in output."
exit 1
fi
MSP430-GCC: MSP430-GCC:
name: GNU MSP430 Toolchain name: GNU MSP430 Toolchain

3
FreeRTOS/Demo/Posix_GCC/main.c
View file

@ -459,6 +459,5 @@ uint32_t uiTraceTimerGetFrequency( void )
uint32_t uiTraceTimerGetValue( void ) uint32_t uiTraceTimerGetValue( void )
{ {
return ( xTaskGetTickCount() - ulEntryTime ); return( xTaskGetTickCount() - ulEntryTime );
} }

142
FreeRTOS/Demo/WIN32-MSVC-Static-Allocation-Only/main.c
View file

@ -59,53 +59,58 @@
* Prototypes for the standard FreeRTOS stack overflow hook (callback) * Prototypes for the standard FreeRTOS stack overflow hook (callback)
* function. http://www.freertos.org/Stacks-and-stack-overflow-checking.html * function. http://www.freertos.org/Stacks-and-stack-overflow-checking.html
*/ */
void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName ); void vApplicationStackOverflowHook( TaskHandle_t pxTask,
char * pcTaskName );
/* /*
* This demo has configSUPPORT_STATIC_ALLOCATION set to 1 so the following * This demo has configSUPPORT_STATIC_ALLOCATION set to 1 so the following
* application callback function must be provided to supply the RAM that will * application callback function must be provided to supply the RAM that will
* get used for the Idle task data structures and stack. * get used for the Idle task data structures and stack.
*/ */
void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize ); void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,
StackType_t ** ppxIdleTaskStackBuffer,
uint32_t * pulIdleTaskStackSize );
/* /*
* This demo has configSUPPORT_STATIC_ALLOCATION set to 1 and configUSE_TIMERS * This demo has configSUPPORT_STATIC_ALLOCATION set to 1 and configUSE_TIMERS
* set to 1 so the following application callback function must be provided to * set to 1 so the following application callback function must be provided to
* supply the RAM that will get used for the Timer task data structures and * supply the RAM that will get used for the Timer task data structures and
* stack. * stack.
*/ */
void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer, StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize ); void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer,
StackType_t ** ppxTimerTaskStackBuffer,
uint32_t * pulTimerTaskStackSize );
/* This demo only uses the standard demo tasks that use statically allocated /* This demo only uses the standard demo tasks that use statically allocated
RAM. A 'check' task is also created to periodically inspect the demo tasks to * RAM. A 'check' task is also created to periodically inspect the demo tasks to
ensure they are still running, and that no errors have been detected. */ * ensure they are still running, and that no errors have been detected. */
static void prvStartCheckTask( void ); static void prvStartCheckTask( void );
static void prvCheckTask( void *pvParameters ); static void prvCheckTask( void * pvParameters );
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
int main( void ) int main( void )
{ {
/* This demo has configSUPPORT_STATIC_ALLOCATION set to 1 and /* This demo has configSUPPORT_STATIC_ALLOCATION set to 1 and
configSUPPORT_DYNAMIC_ALLOCATION set to 0, so the only standard temo tasks * configSUPPORT_DYNAMIC_ALLOCATION set to 0, so the only standard temo tasks
created are the ones that only use static allocation. This allow the * created are the ones that only use static allocation. This allow the
application to be built without including a FreeRTOS heap file (without one * application to be built without including a FreeRTOS heap file (without one
of the heap files described on http://www.freertos.org/a00111.html */ * of the heap files described on http://www.freertos.org/a00111.html */
vStartStaticallyAllocatedTasks(); vStartStaticallyAllocatedTasks();
/* Start a task that periodically inspects the tasks created by /* Start a task that periodically inspects the tasks created by
vStartStaticallyAllocatedTasks() to ensure they are still running, and not * vStartStaticallyAllocatedTasks() to ensure they are still running, and not
reporting any errors. */ * reporting any errors. */
prvStartCheckTask(); prvStartCheckTask();
/* Start the scheduler so the demo tasks start to execute. */ /* Start the scheduler so the demo tasks start to execute. */
vTaskStartScheduler(); vTaskStartScheduler();
/* vTaskStartScheduler() would only return if RAM required by the Idle and /* vTaskStartScheduler() would only return if RAM required by the Idle and
Timer tasks could not be allocated. As this demo uses statically allocated * Timer tasks could not be allocated. As this demo uses statically allocated
RAM only, there are no allocations that could fail, and * RAM only, there are no allocations that could fail, and
vTaskStartScheduler() cannot return - so there is no need to put the normal * vTaskStartScheduler() cannot return - so there is no need to put the normal
infinite loop after the call to vTaskStartScheduler(). */ * infinite loop after the call to vTaskStartScheduler(). */
return 0; return 0;
} }
@ -114,28 +119,28 @@ int main( void )
static void prvStartCheckTask( void ) static void prvStartCheckTask( void )
{ {
/* Allocate the data structure that will hold the task's TCB. NOTE: This is /* Allocate the data structure that will hold the task's TCB. NOTE: This is
declared static so it still exists after this function has returned. */ * declared static so it still exists after this function has returned. */
static StaticTask_t xCheckTask; static StaticTask_t xCheckTask;
/* Allocate the stack that will be used by the task. NOTE: This is declared /* Allocate the stack that will be used by the task. NOTE: This is declared
static so it still exists after this function has returned. */ * static so it still exists after this function has returned. */
static StackType_t ucTaskStack[ configMINIMAL_STACK_SIZE * sizeof( StackType_t ) ]; static StackType_t ucTaskStack[ configMINIMAL_STACK_SIZE * sizeof( StackType_t ) ];
/* Create the task, which will use the RAM allocated by the linker to the /* Create the task, which will use the RAM allocated by the linker to the
variables declared in this function. */ * variables declared in this function. */
xTaskCreateStatic( prvCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, configMAX_PRIORITIES - 1, ucTaskStack, &xCheckTask ); xTaskCreateStatic( prvCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, configMAX_PRIORITIES - 1, ucTaskStack, &xCheckTask );
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
static void prvCheckTask( void *pvParameters ) static void prvCheckTask( void * pvParameters )
{ {
const TickType_t xCycleFrequency = pdMS_TO_TICKS( 2500UL ); const TickType_t xCycleFrequency = pdMS_TO_TICKS( 2500UL );
static char *pcStatusMessage = "No errors"; static char * pcStatusMessage = "No errors";
/* Just to remove compiler warning. */ /* Just to remove compiler warning. */
( void ) pvParameters; ( void ) pvParameters;
for( ;; ) for( ; ; )
{ {
/* Place this task in the blocked state until it is time to run again. */ /* Place this task in the blocked state until it is time to run again. */
vTaskDelay( xCycleFrequency ); vTaskDelay( xCycleFrequency );
@ -147,7 +152,7 @@ static char *pcStatusMessage = "No errors";
} }
/* This is the only task that uses stdout so its ok to call printf() /* This is the only task that uses stdout so its ok to call printf()
directly. */ * directly. */
printf( "%s - tick count %d - number of tasks executing %d\r\n", printf( "%s - tick count %d - number of tasks executing %d\r\n",
pcStatusMessage, pcStatusMessage,
xTaskGetTickCount(), xTaskGetTickCount(),
@ -156,26 +161,28 @@ static char *pcStatusMessage = "No errors";
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName ) void vApplicationStackOverflowHook( TaskHandle_t pxTask,
char * pcTaskName )
{ {
( void ) pcTaskName; ( void ) pcTaskName;
( void ) pxTask; ( void ) pxTask;
/* Run time stack overflow checking is performed if /* Run time stack overflow checking is performed if
configCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2. This hook * configCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2. This hook
function is called if a stack overflow is detected. This function is * function is called if a stack overflow is detected. This function is
provided as an example only as stack overflow checking does not function * provided as an example only as stack overflow checking does not function
when running the FreeRTOS Windows port. */ * when running the FreeRTOS Windows port. */
vAssertCalled( __LINE__, __FILE__ ); vAssertCalled( __LINE__, __FILE__ );
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
void vAssertCalled( unsigned long ulLine, const char * const pcFileName ) void vAssertCalled( unsigned long ulLine,
const char * const pcFileName )
{ {
volatile uint32_t ulSetToNonZeroInDebuggerToContinue = 0; volatile uint32_t ulSetToNonZeroInDebuggerToContinue = 0;
/* Called if an assertion passed to configASSERT() fails. See /* Called if an assertion passed to configASSERT() fails. See
http://www.freertos.org/a00110.html#configASSERT for more information. */ * http://www.freertos.org/a00110.html#configASSERT for more information. */
/* Parameters are not used. */ /* Parameters are not used. */
( void ) ulLine; ( void ) ulLine;
@ -186,12 +193,16 @@ volatile uint32_t ulSetToNonZeroInDebuggerToContinue = 0;
taskENTER_CRITICAL(); taskENTER_CRITICAL();
{ {
/* You can step out of this function to debug the assertion by using /* You can step out of this function to debug the assertion by using
the debugger to set ulSetToNonZeroInDebuggerToContinue to a non-zero * the debugger to set ulSetToNonZeroInDebuggerToContinue to a non-zero
value. */ * value. */
while( ulSetToNonZeroInDebuggerToContinue == 0 ) while( ulSetToNonZeroInDebuggerToContinue == 0 )
{ {
__asm{ NOP }; __asm {
__asm{ NOP }; NOP
};
__asm {
NOP
};
} }
} }
taskEXIT_CRITICAL(); taskEXIT_CRITICAL();
@ -199,51 +210,54 @@ volatile uint32_t ulSetToNonZeroInDebuggerToContinue = 0;
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
/* configUSE_STATIC_ALLOCATION is set to 1, so the application must provide an /* configUSE_STATIC_ALLOCATION is set to 1, so the application must provide an
implementation of vApplicationGetIdleTaskMemory() to provide the memory that is * implementation of vApplicationGetIdleTaskMemory() to provide the memory that is
used by the Idle task. */ * used by the Idle task. */
void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize ) void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,
StackType_t ** ppxIdleTaskStackBuffer,
uint32_t * pulIdleTaskStackSize )
{ {
/* If the buffers to be provided to the Idle task are declared inside this /* If the buffers to be provided to the Idle task are declared inside this
function then they must be declared static - otherwise they will be allocated on * function then they must be declared static - otherwise they will be allocated on
the stack and so not exists after this function exits. */ * the stack and so not exists after this function exits. */
static StaticTask_t xIdleTaskTCB; static StaticTask_t xIdleTaskTCB;
static StackType_t uxIdleTaskStack[ configMINIMAL_STACK_SIZE ]; static StackType_t uxIdleTaskStack[ configMINIMAL_STACK_SIZE ];
/* Pass out a pointer to the StaticTask_t structure in which the Idle task's /* Pass out a pointer to the StaticTask_t structure in which the Idle task's
state will be stored. */ * state will be stored. */
*ppxIdleTaskTCBBuffer = &xIdleTaskTCB; *ppxIdleTaskTCBBuffer = &xIdleTaskTCB;
/* Pass out the array that will be used as the Idle task's stack. */ /* Pass out the array that will be used as the Idle task's stack. */
*ppxIdleTaskStackBuffer = uxIdleTaskStack; *ppxIdleTaskStackBuffer = uxIdleTaskStack;
/* Pass out the size of the array pointed to by *ppxIdleTaskStackBuffer. /* Pass out the size of the array pointed to by *ppxIdleTaskStackBuffer.
Note that, as the array is necessarily of type StackType_t, * Note that, as the array is necessarily of type StackType_t,
configMINIMAL_STACK_SIZE is specified in words, not bytes. */ * configMINIMAL_STACK_SIZE is specified in words, not bytes. */
*pulIdleTaskStackSize = configMINIMAL_STACK_SIZE; *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
/* configUSE_STATIC_ALLOCATION and configUSE_TIMERS are both set to 1, so the /* configUSE_STATIC_ALLOCATION and configUSE_TIMERS are both set to 1, so the
application must provide an implementation of vApplicationGetTimerTaskMemory() * application must provide an implementation of vApplicationGetTimerTaskMemory()
to provide the memory that is used by the Timer service task. */ * to provide the memory that is used by the Timer service task. */
void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer, StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize ) void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer,
StackType_t ** ppxTimerTaskStackBuffer,
uint32_t * pulTimerTaskStackSize )
{ {
/* If the buffers to be provided to the Timer task are declared inside this /* If the buffers to be provided to the Timer task are declared inside this
function then they must be declared static - otherwise they will be allocated on * function then they must be declared static - otherwise they will be allocated on
the stack and so not exists after this function exits. */ * the stack and so not exists after this function exits. */
static StaticTask_t xTimerTaskTCB; static StaticTask_t xTimerTaskTCB;
static StackType_t uxTimerTaskStack[ configTIMER_TASK_STACK_DEPTH ]; static StackType_t uxTimerTaskStack[ configTIMER_TASK_STACK_DEPTH ];
/* Pass out a pointer to the StaticTask_t structure in which the Timer /* Pass out a pointer to the StaticTask_t structure in which the Timer
task's state will be stored. */ * task's state will be stored. */
*ppxTimerTaskTCBBuffer = &xTimerTaskTCB; *ppxTimerTaskTCBBuffer = &xTimerTaskTCB;
/* Pass out the array that will be used as the Timer task's stack. */ /* Pass out the array that will be used as the Timer task's stack. */
*ppxTimerTaskStackBuffer = uxTimerTaskStack; *ppxTimerTaskStackBuffer = uxTimerTaskStack;
/* Pass out the size of the array pointed to by *ppxTimerTaskStackBuffer. /* Pass out the size of the array pointed to by *ppxTimerTaskStackBuffer.
Note that, as the array is necessarily of type StackType_t, * Note that, as the array is necessarily of type StackType_t,
configMINIMAL_STACK_SIZE is specified in words, not bytes. */ * configMINIMAL_STACK_SIZE is specified in words, not bytes. */
*pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH; *pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;
} }

25
FreeRTOS/Demo/WIN32-MSVC/main.c
View file

@ -198,7 +198,7 @@ int main( void )
"will only be the most recent data able to fit within the trace recorder buffer.\r\n", "will only be the most recent data able to fit within the trace recorder buffer.\r\n",
mainTRACE_FILE_NAME, mainOUTPUT_TRACE_KEY ); mainTRACE_FILE_NAME, mainOUTPUT_TRACE_KEY );
configASSERT( xTraceEnable(TRC_START) == TRC_SUCCESS ); configASSERT( xTraceEnable( TRC_START ) == TRC_SUCCESS );
/* Set interrupt handler for keyboard input. */ /* Set interrupt handler for keyboard input. */
vPortSetInterruptHandler( mainINTERRUPT_NUMBER_KEYBOARD, prvKeyboardInterruptHandler ); vPortSetInterruptHandler( mainINTERRUPT_NUMBER_KEYBOARD, prvKeyboardInterruptHandler );
@ -210,7 +210,7 @@ int main( void )
prvWindowsKeyboardInputThread, /* Pointer to thread function. */ prvWindowsKeyboardInputThread, /* Pointer to thread function. */
NULL, /* Argument for new thread. */ NULL, /* Argument for new thread. */
0, /* Creation flags. */ 0, /* Creation flags. */
NULL); NULL );
/* Use the cores that are not used by the FreeRTOS tasks for the Windows thread. */ /* Use the cores that are not used by the FreeRTOS tasks for the Windows thread. */
SetThreadAffinityMask( xWindowsKeyboardInputThreadHandle, ~0x01u ); SetThreadAffinityMask( xWindowsKeyboardInputThreadHandle, ~0x01u );
@ -219,10 +219,12 @@ int main( void )
* of this file. */ * of this file. */
#if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 ) #if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 )
{ {
printf( "\nStarting the blinky demo.\r\n" );
main_blinky(); main_blinky();
} }
#else #else
{ {
printf( "\nStarting the full demo.\r\n" );
main_full(); main_full();
} }
#endif /* if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 ) */ #endif /* if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 ) */
@ -327,7 +329,7 @@ void vAssertCalled( unsigned long ulLine,
taskENTER_CRITICAL(); taskENTER_CRITICAL();
{ {
printf("ASSERT! Line %ld, file %s, GetLastError() %ld\r\n", ulLine, pcFileName, GetLastError()); printf( "ASSERT! Line %ld, file %s, GetLastError() %ld\r\n", ulLine, pcFileName, GetLastError() );
/* Stop the trace recording and save the trace. */ /* Stop the trace recording and save the trace. */
( void ) xTraceDisable(); ( void ) xTraceDisable();
@ -465,31 +467,31 @@ void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer,
/* /*
* Interrupt handler for when keyboard input is received. * Interrupt handler for when keyboard input is received.
*/ */
static uint32_t prvKeyboardInterruptHandler(void) static uint32_t prvKeyboardInterruptHandler( void )
{ {
/* Handle keyboard input. */ /* Handle keyboard input. */
switch (xKeyPressed) switch( xKeyPressed )
{ {
case mainNO_KEY_PRESS_VALUE: case mainNO_KEY_PRESS_VALUE:
break; break;
case mainOUTPUT_TRACE_KEY: case mainOUTPUT_TRACE_KEY:
/* Saving the trace file requires Windows system calls, so enter a critical /* Saving the trace file requires Windows system calls, so enter a critical
section to prevent deadlock or errors resulting from calling a Windows * section to prevent deadlock or errors resulting from calling a Windows
system call from within the FreeRTOS simulator. */ * system call from within the FreeRTOS simulator. */
portENTER_CRITICAL(); portENTER_CRITICAL();
{ {
( void ) xTraceDisable(); ( void ) xTraceDisable();
prvSaveTraceFile(); prvSaveTraceFile();
( void ) xTraceEnable(TRC_START); ( void ) xTraceEnable( TRC_START );
} }
portEXIT_CRITICAL(); portEXIT_CRITICAL();
break; break;
default: default:
#if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 ) #if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 )
{
/* Call the keyboard interrupt handler for the blinky demo. */ /* Call the keyboard interrupt handler for the blinky demo. */
vBlinkyKeyboardInterruptHandler( xKeyPressed ); vBlinkyKeyboardInterruptHandler( xKeyPressed );
}
#endif #endif
break; break;
} }
@ -499,6 +501,7 @@ static uint32_t prvKeyboardInterruptHandler(void)
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
/* /*
* Windows thread function to capture keyboard input from outside of the * Windows thread function to capture keyboard input from outside of the
* FreeRTOS simulator. This thread passes data into the simulator using * FreeRTOS simulator. This thread passes data into the simulator using
@ -508,7 +511,7 @@ static DWORD WINAPI prvWindowsKeyboardInputThread( void * pvParam )
{ {
( void ) pvParam; ( void ) pvParam;
for ( ; ; ) for( ; ; )
{ {
/* Block on acquiring a key press. */ /* Block on acquiring a key press. */
xKeyPressed = _getch(); xKeyPressed = _getch();

263
FreeRTOS/Demo/WIN32-MingW/main.c
View file

@ -43,7 +43,7 @@
* port for further information: * port for further information:
* https://www.FreeRTOS.org/FreeRTOS-Windows-Simulator-Emulator-for-Visual-Studio-and-Eclipse-MingW.html * https://www.FreeRTOS.org/FreeRTOS-Windows-Simulator-Emulator-for-Visual-Studio-and-Eclipse-MingW.html
* *
*
* *
******************************************************************************* *******************************************************************************
*/ */
@ -58,22 +58,22 @@
#include "task.h" #include "task.h"
/* This project provides two demo applications. A simple blinky style demo /* This project provides two demo applications. A simple blinky style demo
application, and a more comprehensive test and demo application. The * application, and a more comprehensive test and demo application. The
mainCREATE_SIMPLE_BLINKY_DEMO_ONLY setting is used to select between the two. * mainCREATE_SIMPLE_BLINKY_DEMO_ONLY setting is used to select between the two.
*
If mainCREATE_SIMPLE_BLINKY_DEMO_ONLY is 1 then the blinky demo will be built. * If mainCREATE_SIMPLE_BLINKY_DEMO_ONLY is 1 then the blinky demo will be built.
The blinky demo is implemented and described in main_blinky.c. * The blinky demo is implemented and described in main_blinky.c.
*
If mainCREATE_SIMPLE_BLINKY_DEMO_ONLY is not 1 then the comprehensive test and * If mainCREATE_SIMPLE_BLINKY_DEMO_ONLY is not 1 then the comprehensive test and
demo application will be built. The comprehensive test and demo application is * demo application will be built. The comprehensive test and demo application is
implemented and described in main_full.c. */ * implemented and described in main_full.c. */
#define mainCREATE_SIMPLE_BLINKY_DEMO_ONLY 0 #define mainCREATE_SIMPLE_BLINKY_DEMO_ONLY 0
/* This demo uses heap_5.c, and these constants define the sizes of the regions /* This demo uses heap_5.c, and these constants define the sizes of the regions
that make up the total heap. heap_5 is only used for test and example purposes * that make up the total heap. heap_5 is only used for test and example purposes
as this demo could easily create one large heap region instead of multiple * as this demo could easily create one large heap region instead of multiple
smaller heap regions - in which case heap_4.c would be the more appropriate * smaller heap regions - in which case heap_4.c would be the more appropriate
choice. See http://www.freertos.org/a00111.html for an explanation. */ * choice. See http://www.freertos.org/a00111.html for an explanation. */
#define mainREGION_1_SIZE 8201 #define mainREGION_1_SIZE 8201
#define mainREGION_2_SIZE 40905 #define mainREGION_2_SIZE 40905
#define mainREGION_3_SIZE 50007 #define mainREGION_3_SIZE 50007
@ -122,10 +122,15 @@ static void prvExerciseHeapStats( void );
*/ */
void vApplicationMallocFailedHook( void ); void vApplicationMallocFailedHook( void );
void vApplicationIdleHook( void ); void vApplicationIdleHook( void );
void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName ); void vApplicationStackOverflowHook( TaskHandle_t pxTask,
char * pcTaskName );
void vApplicationTickHook( void ); void vApplicationTickHook( void );
void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize ); void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,
void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer, StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize ); StackType_t ** ppxIdleTaskStackBuffer,
uint32_t * pulIdleTaskStackSize );
void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer,
StackType_t ** ppxTimerTaskStackBuffer,
uint32_t * pulTimerTaskStackSize );
/* /*
* Writes trace data to a disk file when the trace recording is stopped. * Writes trace data to a disk file when the trace recording is stopped.
@ -153,10 +158,10 @@ extern void vBlinkyKeyboardInterruptHandler( int xKeyPressed );
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
/* When configSUPPORT_STATIC_ALLOCATION is set to 1 the application writer can /* When configSUPPORT_STATIC_ALLOCATION is set to 1 the application writer can
use a callback function to optionally provide the memory required by the idle * use a callback function to optionally provide the memory required by the idle
and timer tasks. This is the stack that will be used by the timer task. It is * and timer tasks. This is the stack that will be used by the timer task. It is
declared here, as a global, so it can be checked by a test that is implemented * declared here, as a global, so it can be checked by a test that is implemented
in a different file. */ * in a different file. */
StackType_t uxTimerTaskStack[ configTIMER_TASK_STACK_DEPTH ]; StackType_t uxTimerTaskStack[ configTIMER_TASK_STACK_DEPTH ];
/* Thread handle for the keyboard input Windows thread. */ /* Thread handle for the keyboard input Windows thread. */
@ -182,7 +187,7 @@ int main( void )
prvWindowsKeyboardInputThread, /* Pointer to thread function. */ prvWindowsKeyboardInputThread, /* Pointer to thread function. */
NULL, /* Argument for new thread. */ NULL, /* Argument for new thread. */
0, /* Creation flags. */ 0, /* Creation flags. */
NULL); NULL );
fflush( stdout ); fflush( stdout );
@ -190,19 +195,19 @@ int main( void )
SetThreadAffinityMask( xWindowsKeyboardInputThreadHandle, ~0x01u ); SetThreadAffinityMask( xWindowsKeyboardInputThreadHandle, ~0x01u );
/* This demo uses heap_5.c, so start by defining some heap regions. heap_5 /* This demo uses heap_5.c, so start by defining some heap regions. heap_5
is only used for test and example reasons. Heap_4 is more appropriate. See * is only used for test and example reasons. Heap_4 is more appropriate. See
http://www.freertos.org/a00111.html for an explanation. */ * http://www.freertos.org/a00111.html for an explanation. */
prvInitialiseHeap(); prvInitialiseHeap();
/* Do not include trace code when performing a code coverage analysis. */ /* Do not include trace code when performing a code coverage analysis. */
#if( projCOVERAGE_TEST != 1 ) #if ( projCOVERAGE_TEST != 1 )
{ {
/* Initialise the trace recorder. Use of the trace recorder is optional. /* Initialise the trace recorder. Use of the trace recorder is optional.
See http://www.FreeRTOS.org/trace for more information. */ * See http://www.FreeRTOS.org/trace for more information. */
configASSERT( xTraceInitialize() == TRC_SUCCESS ); configASSERT( xTraceInitialize() == TRC_SUCCESS );
/* Start the trace recording - the recording is written to a file if /* Start the trace recording - the recording is written to a file if
configASSERT() is called. */ * configASSERT() is called. */
printf( printf(
"Trace started.\r\n" "Trace started.\r\n"
"Note that the trace output uses the ring buffer mode, meaning that the output trace\r\n" "Note that the trace output uses the ring buffer mode, meaning that the output trace\r\n"
@ -215,10 +220,10 @@ int main( void )
fflush( stdout ); fflush( stdout );
configASSERT( xTraceEnable( TRC_START ) == TRC_SUCCESS ); configASSERT( xTraceEnable( TRC_START ) == TRC_SUCCESS );
} }
#endif #endif /* if ( projCOVERAGE_TEST != 1 ) */
/* The mainCREATE_SIMPLE_BLINKY_DEMO_ONLY setting is described at the top /* The mainCREATE_SIMPLE_BLINKY_DEMO_ONLY setting is described at the top
of this file. */ * of this file. */
#if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 ) #if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 )
{ {
main_blinky(); main_blinky();
@ -236,17 +241,17 @@ int main( void )
void vApplicationMallocFailedHook( void ) void vApplicationMallocFailedHook( void )
{ {
/* vApplicationMallocFailedHook() will only be called if /* vApplicationMallocFailedHook() will only be called if
configUSE_MALLOC_FAILED_HOOK is set to 1 in FreeRTOSConfig.h. It is a hook * configUSE_MALLOC_FAILED_HOOK is set to 1 in FreeRTOSConfig.h. It is a hook
function that will get called if a call to pvPortMalloc() fails. * function that will get called if a call to pvPortMalloc() fails.
pvPortMalloc() is called internally by the kernel whenever a task, queue, * pvPortMalloc() is called internally by the kernel whenever a task, queue,
timer or semaphore is created. It is also called by various parts of the * timer or semaphore is created. It is also called by various parts of the
demo application. If heap_1.c, heap_2.c or heap_4.c is being used, then the * demo application. If heap_1.c, heap_2.c or heap_4.c is being used, then the
size of the heap available to pvPortMalloc() is defined by * size of the heap available to pvPortMalloc() is defined by
configTOTAL_HEAP_SIZE in FreeRTOSConfig.h, and the xPortGetFreeHeapSize() * configTOTAL_HEAP_SIZE in FreeRTOSConfig.h, and the xPortGetFreeHeapSize()
API function can be used to query the size of free heap space that remains * API function can be used to query the size of free heap space that remains
(although it does not provide information on how the remaining heap might be * (although it does not provide information on how the remaining heap might be
fragmented). See http://www.freertos.org/a00111.html for more * fragmented). See http://www.freertos.org/a00111.html for more
information. */ * information. */
vAssertCalled( __LINE__, __FILE__ ); vAssertCalled( __LINE__, __FILE__ );
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -254,35 +259,36 @@ void vApplicationMallocFailedHook( void )
void vApplicationIdleHook( void ) void vApplicationIdleHook( void )
{ {
/* vApplicationIdleHook() will only be called if configUSE_IDLE_HOOK is set /* vApplicationIdleHook() will only be called if configUSE_IDLE_HOOK is set
to 1 in FreeRTOSConfig.h. It will be called on each iteration of the idle * to 1 in FreeRTOSConfig.h. It will be called on each iteration of the idle
task. It is essential that code added to this hook function never attempts * task. It is essential that code added to this hook function never attempts
to block in any way (for example, call xQueueReceive() with a block time * to block in any way (for example, call xQueueReceive() with a block time
specified, or call vTaskDelay()). If application tasks make use of the * specified, or call vTaskDelay()). If application tasks make use of the
vTaskDelete() API function to delete themselves then it is also important * vTaskDelete() API function to delete themselves then it is also important
that vApplicationIdleHook() is permitted to return to its calling function, * that vApplicationIdleHook() is permitted to return to its calling function,
because it is the responsibility of the idle task to clean up memory * because it is the responsibility of the idle task to clean up memory
allocated by the kernel to any task that has since deleted itself. */ * allocated by the kernel to any task that has since deleted itself. */
#if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY != 1 ) #if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY != 1 )
{ {
/* Call the idle task processing used by the full demo. The simple /* Call the idle task processing used by the full demo. The simple
blinky demo does not use the idle task hook. */ * blinky demo does not use the idle task hook. */
vFullDemoIdleFunction(); vFullDemoIdleFunction();
} }
#endif #endif
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName ) void vApplicationStackOverflowHook( TaskHandle_t pxTask,
char * pcTaskName )
{ {
( void ) pcTaskName; ( void ) pcTaskName;
( void ) pxTask; ( void ) pxTask;
/* Run time stack overflow checking is performed if /* Run time stack overflow checking is performed if
configCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2. This hook * configCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2. This hook
function is called if a stack overflow is detected. This function is * function is called if a stack overflow is detected. This function is
provided as an example only as stack overflow checking does not function * provided as an example only as stack overflow checking does not function
when running the FreeRTOS Windows port. */ * when running the FreeRTOS Windows port. */
vAssertCalled( __LINE__, __FILE__ ); vAssertCalled( __LINE__, __FILE__ );
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -290,10 +296,10 @@ void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName )
void vApplicationTickHook( void ) void vApplicationTickHook( void )
{ {
/* This function will be called by each tick interrupt if /* This function will be called by each tick interrupt if
configUSE_TICK_HOOK is set to 1 in FreeRTOSConfig.h. User code can be * configUSE_TICK_HOOK is set to 1 in FreeRTOSConfig.h. User code can be
added here, but the tick hook is called from an interrupt context, so * added here, but the tick hook is called from an interrupt context, so
code must not attempt to block, and only the interrupt safe FreeRTOS API * code must not attempt to block, and only the interrupt safe FreeRTOS API
functions can be used (those that end in FromISR()). */ * functions can be used (those that end in FromISR()). */
#if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY != 1 ) #if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY != 1 )
{ {
@ -306,18 +312,19 @@ void vApplicationTickHook( void )
void vApplicationDaemonTaskStartupHook( void ) void vApplicationDaemonTaskStartupHook( void )
{ {
/* This function will be called once only, when the daemon task starts to /* This function will be called once only, when the daemon task starts to
execute (sometimes called the timer task). This is useful if the * execute (sometimes called the timer task). This is useful if the
application includes initialisation code that would benefit from executing * application includes initialisation code that would benefit from executing
after the scheduler has been started. */ * after the scheduler has been started. */
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
void vAssertCalled( unsigned long ulLine, const char * const pcFileName ) void vAssertCalled( unsigned long ulLine,
const char * const pcFileName )
{ {
volatile uint32_t ulSetToNonZeroInDebuggerToContinue = 0; volatile uint32_t ulSetToNonZeroInDebuggerToContinue = 0;
/* Called if an assertion passed to configASSERT() fails. See /* Called if an assertion passed to configASSERT() fails. See
http://www.freertos.org/a00110.html#configASSERT for more information. */ * http://www.freertos.org/a00110.html#configASSERT for more information. */
/* Parameters are not used. */ /* Parameters are not used. */
( void ) ulLine; ( void ) ulLine;
@ -326,10 +333,10 @@ volatile uint32_t ulSetToNonZeroInDebuggerToContinue = 0;
taskENTER_CRITICAL(); taskENTER_CRITICAL();
{ {
printf("ASSERT! Line %ld, file %s, GetLastError() %ld\r\n", ulLine, pcFileName, GetLastError()); printf( "ASSERT! Line %ld, file %s, GetLastError() %ld\r\n", ulLine, pcFileName, GetLastError() );
fflush( stdout ); fflush( stdout );
#if( projCOVERAGE_TEST != 1 ) #if ( projCOVERAGE_TEST != 1 )
{ {
/* Stop the trace recording. */ /* Stop the trace recording. */
( void ) xTraceDisable(); ( void ) xTraceDisable();
@ -338,15 +345,15 @@ volatile uint32_t ulSetToNonZeroInDebuggerToContinue = 0;
#endif #endif
/* You can step out of this function to debug the assertion by using /* You can step out of this function to debug the assertion by using
the debugger to set ulSetToNonZeroInDebuggerToContinue to a non-zero * the debugger to set ulSetToNonZeroInDebuggerToContinue to a non-zero
value. */ * value. */
while( ulSetToNonZeroInDebuggerToContinue == 0 ) while( ulSetToNonZeroInDebuggerToContinue == 0 )
{ {
__asm volatile( "NOP" ); __asm volatile ( "NOP" );
__asm volatile( "NOP" ); __asm volatile ( "NOP" );
} }
#if( projCOVERAGE_TEST != 1 ) #if ( projCOVERAGE_TEST != 1 )
{ {
/* Re-enable recording */ /* Re-enable recording */
( void ) xTraceEnable( TRC_START ); ( void ) xTraceEnable( TRC_START );
@ -360,11 +367,11 @@ volatile uint32_t ulSetToNonZeroInDebuggerToContinue = 0;
static void prvSaveTraceFile( void ) static void prvSaveTraceFile( void )
{ {
/* Tracing is not used when code coverage analysis is being performed. */ /* Tracing is not used when code coverage analysis is being performed. */
#if( projCOVERAGE_TEST != 1 ) #if ( projCOVERAGE_TEST != 1 )
{ {
FILE* pxOutputFile; FILE * pxOutputFile;
pxOutputFile = fopen( mainTRACE_FILE_NAME, "wb"); pxOutputFile = fopen( mainTRACE_FILE_NAME, "wb" );
if( pxOutputFile != NULL ) if( pxOutputFile != NULL )
{ {
@ -379,36 +386,36 @@ static void prvSaveTraceFile( void )
fflush( stdout ); fflush( stdout );
} }
} }
#endif #endif /* if ( projCOVERAGE_TEST != 1 ) */
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
static void prvInitialiseHeap( void ) static void prvInitialiseHeap( void )
{ {
/* The Windows demo could create one large heap region, in which case it would /* The Windows demo could create one large heap region, in which case it would
be appropriate to use heap_4. However, purely for demonstration purposes, * be appropriate to use heap_4. However, purely for demonstration purposes,
heap_5 is used instead, so start by defining some heap regions. No * heap_5 is used instead, so start by defining some heap regions. No
initialisation is required when any other heap implementation is used. See * initialisation is required when any other heap implementation is used. See
http://www.freertos.org/a00111.html for more information. * http://www.freertos.org/a00111.html for more information.
*
The xHeapRegions structure requires the regions to be defined in start address * The xHeapRegions structure requires the regions to be defined in start address
order, so this just creates one big array, then populates the structure with * order, so this just creates one big array, then populates the structure with
offsets into the array - with gaps in between and messy alignment just for test * offsets into the array - with gaps in between and messy alignment just for test
purposes. */ * purposes. */
static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ]; static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];
volatile uint32_t ulAdditionalOffset = 19; /* Just to prevent 'condition is always true' warnings in configASSERT(). */ volatile uint32_t ulAdditionalOffset = 19; /* Just to prevent 'condition is always true' warnings in configASSERT(). */
HeapStats_t xHeapStats; HeapStats_t xHeapStats;
const HeapRegion_t xHeapRegions[] = const HeapRegion_t xHeapRegions[] =
{ {
/* Start address with dummy offsets Size */ /* Start address with dummy offsets Size */
{ ucHeap + 1, mainREGION_1_SIZE }, { ucHeap + 1, mainREGION_1_SIZE },
{ ucHeap + 15 + mainREGION_1_SIZE, mainREGION_2_SIZE }, { ucHeap + 15 + mainREGION_1_SIZE, mainREGION_2_SIZE },
{ ucHeap + 19 + mainREGION_1_SIZE + mainREGION_2_SIZE, mainREGION_3_SIZE }, { ucHeap + 19 + mainREGION_1_SIZE + mainREGION_2_SIZE, mainREGION_3_SIZE },
{ NULL, 0 } { NULL, 0 }
}; };
/* Sanity check that the sizes and offsets defined actually fit into the /* Sanity check that the sizes and offsets defined actually fit into the
array. */ * array. */
configASSERT( ( ulAdditionalOffset + mainREGION_1_SIZE + mainREGION_2_SIZE + mainREGION_3_SIZE ) < configTOTAL_HEAP_SIZE ); configASSERT( ( ulAdditionalOffset + mainREGION_1_SIZE + mainREGION_2_SIZE + mainREGION_3_SIZE ) < configTOTAL_HEAP_SIZE );
/* Prevent compiler warnings when configASSERT() is not defined. */ /* Prevent compiler warnings when configASSERT() is not defined. */
@ -426,19 +433,19 @@ const HeapRegion_t xHeapRegions[] =
static void prvExerciseHeapStats( void ) static void prvExerciseHeapStats( void )
{ {
HeapStats_t xHeapStats; HeapStats_t xHeapStats;
size_t xInitialFreeSpace = xPortGetFreeHeapSize(), xMinimumFreeBytes; size_t xInitialFreeSpace = xPortGetFreeHeapSize(), xMinimumFreeBytes;
size_t xMetaDataOverhead, i; size_t xMetaDataOverhead, i;
void *pvAllocatedBlock; void * pvAllocatedBlock;
const size_t xArraySize = 5, xBlockSize = 1000UL; const size_t xArraySize = 5, xBlockSize = 1000UL;
void *pvAllocatedBlocks[ xArraySize ]; void * pvAllocatedBlocks[ xArraySize ];
/* Check heap stats are as expected after initialisation but before any /* Check heap stats are as expected after initialisation but before any
allocations. */ * allocations. */
vPortGetHeapStats( &xHeapStats ); vPortGetHeapStats( &xHeapStats );
/* Minimum ever free bytes remaining should be the same as the total number /* Minimum ever free bytes remaining should be the same as the total number
of bytes as nothing has been allocated yet. */ * of bytes as nothing has been allocated yet. */
configASSERT( xHeapStats.xMinimumEverFreeBytesRemaining == xHeapStats.xAvailableHeapSpaceInBytes ); configASSERT( xHeapStats.xMinimumEverFreeBytesRemaining == xHeapStats.xAvailableHeapSpaceInBytes );
configASSERT( xHeapStats.xMinimumEverFreeBytesRemaining == xInitialFreeSpace ); configASSERT( xHeapStats.xMinimumEverFreeBytesRemaining == xInitialFreeSpace );
@ -447,8 +454,8 @@ void *pvAllocatedBlocks[ xArraySize ];
configASSERT( xHeapStats.xNumberOfSuccessfulFrees == 0 ); configASSERT( xHeapStats.xNumberOfSuccessfulFrees == 0 );
/* Allocate a 1000 byte block then measure what the overhead of the /* Allocate a 1000 byte block then measure what the overhead of the
allocation in regards to how many bytes more than 1000 were actually * allocation in regards to how many bytes more than 1000 were actually
removed from the heap in order to store metadata about the allocation. */ * removed from the heap in order to store metadata about the allocation. */
pvAllocatedBlock = pvPortMalloc( xBlockSize ); pvAllocatedBlock = pvPortMalloc( xBlockSize );
configASSERT( pvAllocatedBlock ); configASSERT( pvAllocatedBlock );
xMetaDataOverhead = ( xInitialFreeSpace - xPortGetFreeHeapSize() ) - xBlockSize; xMetaDataOverhead = ( xInitialFreeSpace - xPortGetFreeHeapSize() ) - xBlockSize;
@ -491,51 +498,55 @@ void *pvAllocatedBlocks[ xArraySize ];
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
/* configUSE_STATIC_ALLOCATION is set to 1, so the application must provide an /* configUSE_STATIC_ALLOCATION is set to 1, so the application must provide an
implementation of vApplicationGetIdleTaskMemory() to provide the memory that is * implementation of vApplicationGetIdleTaskMemory() to provide the memory that is
used by the Idle task. */ * used by the Idle task. */
void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize ) void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,
StackType_t ** ppxIdleTaskStackBuffer,
uint32_t * pulIdleTaskStackSize )
{ {
/* If the buffers to be provided to the Idle task are declared inside this /* If the buffers to be provided to the Idle task are declared inside this
function then they must be declared static - otherwise they will be allocated on * function then they must be declared static - otherwise they will be allocated on
the stack and so not exists after this function exits. */ * the stack and so not exists after this function exits. */
static StaticTask_t xIdleTaskTCB; static StaticTask_t xIdleTaskTCB;
static StackType_t uxIdleTaskStack[ configMINIMAL_STACK_SIZE ]; static StackType_t uxIdleTaskStack[ configMINIMAL_STACK_SIZE ];
/* Pass out a pointer to the StaticTask_t structure in which the Idle task's /* Pass out a pointer to the StaticTask_t structure in which the Idle task's
state will be stored. */ * state will be stored. */
*ppxIdleTaskTCBBuffer = &xIdleTaskTCB; *ppxIdleTaskTCBBuffer = &xIdleTaskTCB;
/* Pass out the array that will be used as the Idle task's stack. */ /* Pass out the array that will be used as the Idle task's stack. */
*ppxIdleTaskStackBuffer = uxIdleTaskStack; *ppxIdleTaskStackBuffer = uxIdleTaskStack;
/* Pass out the size of the array pointed to by *ppxIdleTaskStackBuffer. /* Pass out the size of the array pointed to by *ppxIdleTaskStackBuffer.
Note that, as the array is necessarily of type StackType_t, * Note that, as the array is necessarily of type StackType_t,
configMINIMAL_STACK_SIZE is specified in words, not bytes. */ * configMINIMAL_STACK_SIZE is specified in words, not bytes. */
*pulIdleTaskStackSize = configMINIMAL_STACK_SIZE; *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
/* configUSE_STATIC_ALLOCATION and configUSE_TIMERS are both set to 1, so the /* configUSE_STATIC_ALLOCATION and configUSE_TIMERS are both set to 1, so the
application must provide an implementation of vApplicationGetTimerTaskMemory() * application must provide an implementation of vApplicationGetTimerTaskMemory()
to provide the memory that is used by the Timer service task. */ * to provide the memory that is used by the Timer service task. */
void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer, StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize ) void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer,
StackType_t ** ppxTimerTaskStackBuffer,
uint32_t * pulTimerTaskStackSize )
{ {
/* If the buffers to be provided to the Timer task are declared inside this /* If the buffers to be provided to the Timer task are declared inside this
function then they must be declared static - otherwise they will be allocated on * function then they must be declared static - otherwise they will be allocated on
the stack and so not exists after this function exits. */ * the stack and so not exists after this function exits. */
static StaticTask_t xTimerTaskTCB; static StaticTask_t xTimerTaskTCB;
/* Pass out a pointer to the StaticTask_t structure in which the Timer /* Pass out a pointer to the StaticTask_t structure in which the Timer
task's state will be stored. */ * task's state will be stored. */
*ppxTimerTaskTCBBuffer = &xTimerTaskTCB; *ppxTimerTaskTCBBuffer = &xTimerTaskTCB;
/* Pass out the array that will be used as the Timer task's stack. */ /* Pass out the array that will be used as the Timer task's stack. */
*ppxTimerTaskStackBuffer = uxTimerTaskStack; *ppxTimerTaskStackBuffer = uxTimerTaskStack;
/* Pass out the size of the array pointed to by *ppxTimerTaskStackBuffer. /* Pass out the size of the array pointed to by *ppxTimerTaskStackBuffer.
Note that, as the array is necessarily of type StackType_t, * Note that, as the array is necessarily of type StackType_t,
configMINIMAL_STACK_SIZE is specified in words, not bytes. */ * configMINIMAL_STACK_SIZE is specified in words, not bytes. */
*pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH; *pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;
} }
@ -547,13 +558,13 @@ static StaticTask_t xTimerTaskTCB;
static uint32_t prvKeyboardInterruptHandler( void ) static uint32_t prvKeyboardInterruptHandler( void )
{ {
/* Handle keyboard input. */ /* Handle keyboard input. */
switch ( xKeyPressed ) switch( xKeyPressed )
{ {
case mainNO_KEY_PRESS_VALUE: case mainNO_KEY_PRESS_VALUE:
break; break;
case mainOUTPUT_TRACE_KEY: case mainOUTPUT_TRACE_KEY:
#if( projCOVERAGE_TEST != 1 ) #if ( projCOVERAGE_TEST != 1 )
{
/* Saving the trace file requires Windows system calls, so enter a critical /* Saving the trace file requires Windows system calls, so enter a critical
* section to prevent deadlock or errors resulting from calling a Windows * section to prevent deadlock or errors resulting from calling a Windows
* system call from within the FreeRTOS simulator. */ * system call from within the FreeRTOS simulator. */
@ -564,15 +575,13 @@ static uint32_t prvKeyboardInterruptHandler( void )
( void ) xTraceEnable( TRC_START ); ( void ) xTraceEnable( TRC_START );
} }
portEXIT_CRITICAL(); portEXIT_CRITICAL();
}
#endif #endif
break; break;
default: default:
#if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 ) #if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 )
{
/* Call the keyboard interrupt handler for the blinky demo. */ /* Call the keyboard interrupt handler for the blinky demo. */
vBlinkyKeyboardInterruptHandler( xKeyPressed ); vBlinkyKeyboardInterruptHandler( xKeyPressed );
}
#endif #endif
break; break;
} }
@ -592,7 +601,7 @@ static DWORD WINAPI prvWindowsKeyboardInputThread( void * pvParam )
{ {
( void ) pvParam; ( void ) pvParam;
for ( ; ; ) for( ; ; )
{ {
/* Block on acquiring a key press */ /* Block on acquiring a key press */
xKeyPressed = _getch(); xKeyPressed = _getch();