len0rd/FreeRTOS-Kernel
1
0
Fork 0
mirror of https://github.com/FreeRTOS/FreeRTOS-Kernel.git synced 2025-10-14 00:37:44 -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:
push:
pull_request:
workflow_dispatch:
jobs:
WIN32-MSVC:
@ -19,13 +20,60 @@ jobs:
- name: Add msbuild to PATH
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
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
id: build-win32-msvs-static-allocation-only-demo
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:
name: WIN32 MingW
@ -44,15 +92,49 @@ jobs:
run: |
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
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
make --version
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:
name: Native GCC
name: Posix GCC
runs-on: ubuntu-latest
steps:
- name: Checkout Repository
@ -73,19 +155,17 @@ jobs:
shell: bash
working-directory: FreeRTOS/Demo/Posix_GCC
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
- name: Run and monitor Posix_GCC Full Demo
if: success() || failure() && steps.build-posix-gcc-full-demo.outcome == 'success'
working-directory: FreeRTOS/Demo/Posix_GCC
run: |
timeout 5m build/posix_demo | tee output.txt
if grep -q "OK: No errors" output.txt; then
echo -e "\nSUCCESS - Found SUCCESS string in output."
else
echo -e "\nFAILURE - SUCCESS string not found in output."
exit 1
fi
uses: FreeRTOS/CI-CD-GitHub-Actions/executable-monitor@main
with:
exe-path: FreeRTOS/Demo/Posix_GCC/build/posix_demo
log-dir: demo_run_logs
timeout-seconds: 60
success-line: "OK: No errors"
- name: Build Posix_GCC Blinky Demo
id: build-posix-gcc-blinky-demo
@ -93,20 +173,18 @@ jobs:
shell: bash
working-directory: FreeRTOS/Demo/Posix_GCC
run: |
sed -i "s/#define[[:space:]]\+mainSELECTED_APPLICATION[[:space:]]\+FULL_DEMO/#define mainSELECTED_APPLICATION BLINKY_DEMO/g" main.c
make -j
sed -i -z "s/int[[:space:]]*main[[:space:]]*([[:space:]]*void[[:space:]]*)\n{/int main( void ){setvbuf( stdout, NULL, _IONBF, 0 );/g" main.c
rm -rf build
make -j USER_DEMO=BLINKY_DEMO
- name: Run and monitor Posix_GCC Blinky Demo
if: success() || failure() && steps.build-posix-gcc-blinky-demo.outcome == 'success'
working-directory: FreeRTOS/Demo/Posix_GCC
run: |
timeout 30s build/posix_demo | tee output.txt
if grep -q "Message received from software timer" output.txt; then
echo -e "\nSUCCESS - Found SUCCESS string in output."
else
echo -e "\nFAILURE - SUCCESS string not found in output."
exit 1
fi
uses: FreeRTOS/CI-CD-GitHub-Actions/executable-monitor@main
with:
exe-path: FreeRTOS/Demo/Posix_GCC/build/posix_demo
log-dir: demo_run_logs
timeout-seconds: 60
success-line: "Message received from software timer"
MSP430-GCC:
name: GNU MSP430 Toolchain

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

@ -449,7 +449,7 @@ static uint32_t ulEntryTime = 0;
void vTraceTimerReset( void )
{
ulEntryTime = xTaskGetTickCount();
ulEntryTime = xTaskGetTickCount();
}
uint32_t uiTraceTimerGetFrequency( void )
@ -459,6 +459,5 @@ uint32_t uiTraceTimerGetFrequency( void )
uint32_t uiTraceTimerGetValue( void )
{
return ( xTaskGetTickCount() - ulEntryTime );
return( xTaskGetTickCount() - ulEntryTime );
}

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

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

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

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

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

@ -43,7 +43,7 @@
* port for further information:
* https://www.FreeRTOS.org/FreeRTOS-Windows-Simulator-Emulator-for-Visual-Studio-and-Eclipse-MingW.html
*
*
*
*******************************************************************************
*/
@ -58,25 +58,25 @@
#include "task.h"
/* This project provides two demo applications. A simple blinky style demo
application, and a more comprehensive test and demo application. The
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.
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
demo application will be built. The comprehensive test and demo application is
implemented and described in main_full.c. */
* application, and a more comprehensive test and demo application. The
* 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.
* 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
* demo application will be built. The comprehensive test and demo application is
* implemented and described in main_full.c. */
#define mainCREATE_SIMPLE_BLINKY_DEMO_ONLY 0
/* 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
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
choice. See http://www.freertos.org/a00111.html for an explanation. */
#define mainREGION_1_SIZE 8201
#define mainREGION_2_SIZE 40905
#define mainREGION_3_SIZE 50007
* 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
* 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. */
#define mainREGION_1_SIZE 8201
#define mainREGION_2_SIZE 40905
#define mainREGION_3_SIZE 50007
/* This demo allows for users to perform actions with the keyboard. */
#define mainNO_KEY_PRESS_VALUE -1
@ -108,7 +108,7 @@ void vFullDemoIdleFunction( void );
* region. Heap_5 is only used for test and example purposes. See
* https://www.FreeRTOS.org/a00111.html for an explanation.
*/
static void prvInitialiseHeap( void );
static void prvInitialiseHeap( void );
/*
* Performs a few sanity checks on the behaviour of the vPortGetHeapStats()
@ -122,10 +122,15 @@ static void prvExerciseHeapStats( void );
*/
void vApplicationMallocFailedHook( void );
void vApplicationIdleHook( void );
void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName );
void vApplicationStackOverflowHook( TaskHandle_t pxTask,
char * pcTaskName );
void vApplicationTickHook( void );
void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize );
void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer, StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize );
void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,
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.
@ -153,10 +158,10 @@ extern void vBlinkyKeyboardInterruptHandler( int xKeyPressed );
/*-----------------------------------------------------------*/
/* 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
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
in a different file. */
* 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
* declared here, as a global, so it can be checked by a test that is implemented
* in a different file. */
StackType_t uxTimerTaskStack[ configTIMER_TASK_STACK_DEPTH ];
/* Thread handle for the keyboard input Windows thread. */
@ -182,7 +187,7 @@ int main( void )
prvWindowsKeyboardInputThread, /* Pointer to thread function. */
NULL, /* Argument for new thread. */
0, /* Creation flags. */
NULL);
NULL );
fflush( stdout );
@ -190,20 +195,20 @@ int main( void )
SetThreadAffinityMask( xWindowsKeyboardInputThreadHandle, ~0x01u );
/* 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
http://www.freertos.org/a00111.html for an explanation. */
* is only used for test and example reasons. Heap_4 is more appropriate. See
* http://www.freertos.org/a00111.html for an explanation. */
prvInitialiseHeap();
/* Do not include trace code when performing a code coverage analysis. */
#if( projCOVERAGE_TEST != 1 )
{
/* Initialise the trace recorder. Use of the trace recorder is optional.
See http://www.FreeRTOS.org/trace for more information. */
configASSERT( xTraceInitialize() == TRC_SUCCESS );
#if ( projCOVERAGE_TEST != 1 )
{
/* Initialise the trace recorder. Use of the trace recorder is optional.
* See http://www.FreeRTOS.org/trace for more information. */
configASSERT( xTraceInitialize() == TRC_SUCCESS );
/* Start the trace recording - the recording is written to a file if
configASSERT() is called. */
printf(
/* Start the trace recording - the recording is written to a file if
* configASSERT() is called. */
printf(
"Trace started.\r\n"
"Note that the trace output uses the ring buffer mode, meaning that the output trace\r\n"
"will only be the most recent data able to fit within the trace recorder buffer.\r\n\r\n"
@ -212,21 +217,21 @@ int main( void )
"Note that key presses cannot be captured in the Eclipse console, so for key presses to work\r\n"
"you will have to run this demo in a Windows console.\r\n\r\n",
mainTRACE_FILE_NAME, mainOUTPUT_TRACE_KEY );
fflush( stdout );
configASSERT( xTraceEnable( TRC_START ) == TRC_SUCCESS );
}
#endif
fflush( stdout );
configASSERT( xTraceEnable( TRC_START ) == TRC_SUCCESS );
}
#endif /* if ( projCOVERAGE_TEST != 1 ) */
/* 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 )
{
main_blinky();
}
{
main_blinky();
}
#else
{
main_full();
}
{
main_full();
}
#endif
return 0;
@ -236,17 +241,17 @@ int main( void )
void vApplicationMallocFailedHook( void )
{
/* vApplicationMallocFailedHook() will only be called if
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.
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
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
configTOTAL_HEAP_SIZE in FreeRTOSConfig.h, and the xPortGetFreeHeapSize()
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
fragmented). See http://www.freertos.org/a00111.html for more
information. */
* 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.
* 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
* 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
* configTOTAL_HEAP_SIZE in FreeRTOSConfig.h, and the xPortGetFreeHeapSize()
* 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
* fragmented). See http://www.freertos.org/a00111.html for more
* information. */
vAssertCalled( __LINE__, __FILE__ );
}
/*-----------------------------------------------------------*/
@ -254,35 +259,36 @@ void vApplicationMallocFailedHook( void )
void vApplicationIdleHook( void )
{
/* 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
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
specified, or call vTaskDelay()). If application tasks make use of the
vTaskDelete() API function to delete themselves then it is also important
that vApplicationIdleHook() is permitted to return to its calling function,
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. */
* 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
* to block in any way (for example, call xQueueReceive() with a block time
* specified, or call vTaskDelay()). If application tasks make use of the
* vTaskDelete() API function to delete themselves then it is also important
* that vApplicationIdleHook() is permitted to return to its calling function,
* 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. */
#if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY != 1 )
{
/* Call the idle task processing used by the full demo. The simple
blinky demo does not use the idle task hook. */
vFullDemoIdleFunction();
}
{
/* Call the idle task processing used by the full demo. The simple
* blinky demo does not use the idle task hook. */
vFullDemoIdleFunction();
}
#endif
}
/*-----------------------------------------------------------*/
void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName )
void vApplicationStackOverflowHook( TaskHandle_t pxTask,
char * pcTaskName )
{
( void ) pcTaskName;
( void ) pxTask;
/* Run time stack overflow checking is performed if
configCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2. This hook
function is called if a stack overflow is detected. This function is
provided as an example only as stack overflow checking does not function
when running the FreeRTOS Windows port. */
* configCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2. This hook
* function is called if a stack overflow is detected. This function is
* provided as an example only as stack overflow checking does not function
* when running the FreeRTOS Windows port. */
vAssertCalled( __LINE__, __FILE__ );
}
/*-----------------------------------------------------------*/
@ -290,15 +296,15 @@ void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName )
void vApplicationTickHook( void )
{
/* This function will be called by each tick interrupt if
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
code must not attempt to block, and only the interrupt safe FreeRTOS API
functions can be used (those that end in FromISR()). */
* 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
* code must not attempt to block, and only the interrupt safe FreeRTOS API
* functions can be used (those that end in FromISR()). */
#if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY != 1 )
{
vFullDemoTickHookFunction();
}
{
vFullDemoTickHookFunction();
}
#endif /* mainCREATE_SIMPLE_BLINKY_DEMO_ONLY */
}
/*-----------------------------------------------------------*/
@ -306,18 +312,19 @@ void vApplicationTickHook( void )
void vApplicationDaemonTaskStartupHook( void )
{
/* This function will be called once only, when the daemon task starts to
execute (sometimes called the timer task). This is useful if the
application includes initialisation code that would benefit from executing
after the scheduler has been started. */
* execute (sometimes called the timer task). This is useful if the
* application includes initialisation code that would benefit from executing
* 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
http://www.freertos.org/a00110.html#configASSERT for more information. */
* http://www.freertos.org/a00110.html#configASSERT for more information. */
/* Parameters are not used. */
( void ) ulLine;
@ -326,31 +333,31 @@ volatile uint32_t ulSetToNonZeroInDebuggerToContinue = 0;
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 );
#if( projCOVERAGE_TEST != 1 )
{
/* Stop the trace recording. */
( void ) xTraceDisable();
prvSaveTraceFile();
}
#if ( projCOVERAGE_TEST != 1 )
{
/* Stop the trace recording. */
( void ) xTraceDisable();
prvSaveTraceFile();
}
#endif
/* You can step out of this function to debug the assertion by using
the debugger to set ulSetToNonZeroInDebuggerToContinue to a non-zero
value. */
* the debugger to set ulSetToNonZeroInDebuggerToContinue to a non-zero
* value. */
while( ulSetToNonZeroInDebuggerToContinue == 0 )
{
__asm volatile( "NOP" );
__asm volatile( "NOP" );
__asm volatile ( "NOP" );
__asm volatile ( "NOP" );
}
#if( projCOVERAGE_TEST != 1 )
{
/* Re-enable recording */
( void ) xTraceEnable( TRC_START );
}
#if ( projCOVERAGE_TEST != 1 )
{
/* Re-enable recording */
( void ) xTraceEnable( TRC_START );
}
#endif
}
taskEXIT_CRITICAL();
@ -360,55 +367,55 @@ volatile uint32_t ulSetToNonZeroInDebuggerToContinue = 0;
static void prvSaveTraceFile( void )
{
/* Tracing is not used when code coverage analysis is being performed. */
#if( projCOVERAGE_TEST != 1 )
{
FILE* pxOutputFile;
pxOutputFile = fopen( mainTRACE_FILE_NAME, "wb");
#if ( projCOVERAGE_TEST != 1 )
{
FILE * pxOutputFile;
if( pxOutputFile != NULL )
{
fwrite( RecorderDataPtr, sizeof( RecorderDataType ), 1, pxOutputFile );
fclose( pxOutputFile );
printf( "\r\nTrace output saved to %s\r\n", mainTRACE_FILE_NAME );
fflush( stdout );
pxOutputFile = fopen( mainTRACE_FILE_NAME, "wb" );
if( pxOutputFile != NULL )
{
fwrite( RecorderDataPtr, sizeof( RecorderDataType ), 1, pxOutputFile );
fclose( pxOutputFile );
printf( "\r\nTrace output saved to %s\r\n", mainTRACE_FILE_NAME );
fflush( stdout );
}
else
{
printf( "\r\nFailed to create trace dump file\r\n" );
fflush( stdout );
}
}
else
{
printf( "\r\nFailed to create trace dump file\r\n" );
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
be appropriate to use heap_4. However, purely for demonstration purposes,
heap_5 is used instead, so start by defining some heap regions. No
initialisation is required when any other heap implementation is used. See
http://www.freertos.org/a00111.html for more information.
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
offsets into the array - with gaps in between and messy alignment just for test
purposes. */
static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];
volatile uint32_t ulAdditionalOffset = 19; /* Just to prevent 'condition is always true' warnings in configASSERT(). */
HeapStats_t xHeapStats;
const HeapRegion_t xHeapRegions[] =
{
/* Start address with dummy offsets Size */
{ ucHeap + 1, mainREGION_1_SIZE },
{ ucHeap + 15 + mainREGION_1_SIZE, mainREGION_2_SIZE },
{ ucHeap + 19 + mainREGION_1_SIZE + mainREGION_2_SIZE, mainREGION_3_SIZE },
{ NULL, 0 }
};
* be appropriate to use heap_4. However, purely for demonstration purposes,
* heap_5 is used instead, so start by defining some heap regions. No
* initialisation is required when any other heap implementation is used. See
* http://www.freertos.org/a00111.html for more information.
*
* 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
* offsets into the array - with gaps in between and messy alignment just for test
* purposes. */
static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];
volatile uint32_t ulAdditionalOffset = 19; /* Just to prevent 'condition is always true' warnings in configASSERT(). */
HeapStats_t xHeapStats;
const HeapRegion_t xHeapRegions[] =
{
/* Start address with dummy offsets Size */
{ ucHeap + 1, mainREGION_1_SIZE },
{ ucHeap + 15 + mainREGION_1_SIZE, mainREGION_2_SIZE },
{ ucHeap + 19 + mainREGION_1_SIZE + mainREGION_2_SIZE, mainREGION_3_SIZE },
{ NULL, 0 }
};
/* 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 );
/* Prevent compiler warnings when configASSERT() is not defined. */
@ -426,19 +433,19 @@ const HeapRegion_t xHeapRegions[] =
static void prvExerciseHeapStats( void )
{
HeapStats_t xHeapStats;
size_t xInitialFreeSpace = xPortGetFreeHeapSize(), xMinimumFreeBytes;
size_t xMetaDataOverhead, i;
void *pvAllocatedBlock;
const size_t xArraySize = 5, xBlockSize = 1000UL;
void *pvAllocatedBlocks[ xArraySize ];
HeapStats_t xHeapStats;
size_t xInitialFreeSpace = xPortGetFreeHeapSize(), xMinimumFreeBytes;
size_t xMetaDataOverhead, i;
void * pvAllocatedBlock;
const size_t xArraySize = 5, xBlockSize = 1000UL;
void * pvAllocatedBlocks[ xArraySize ];
/* Check heap stats are as expected after initialisation but before any
allocations. */
* allocations. */
vPortGetHeapStats( &xHeapStats );
/* 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 == xInitialFreeSpace );
@ -447,8 +454,8 @@ void *pvAllocatedBlocks[ xArraySize ];
configASSERT( xHeapStats.xNumberOfSuccessfulFrees == 0 );
/* Allocate a 1000 byte block then measure what the overhead of the
allocation in regards to how many bytes more than 1000 were actually
removed from the heap in order to store metadata about the allocation. */
* allocation in regards to how many bytes more than 1000 were actually
* removed from the heap in order to store metadata about the allocation. */
pvAllocatedBlock = pvPortMalloc( xBlockSize );
configASSERT( pvAllocatedBlock );
xMetaDataOverhead = ( xInitialFreeSpace - xPortGetFreeHeapSize() ) - xBlockSize;
@ -491,51 +498,55 @@ void *pvAllocatedBlocks[ xArraySize ];
/*-----------------------------------------------------------*/
/* configUSE_STATIC_ALLOCATION is set to 1, so the application must provide an
implementation of vApplicationGetIdleTaskMemory() to provide the memory that is
used by the Idle task. */
void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize )
* implementation of vApplicationGetIdleTaskMemory() to provide the memory that is
* used by the Idle task. */
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
function then they must be declared static - otherwise they will be allocated on
the stack and so not exists after this function exits. */
static StaticTask_t xIdleTaskTCB;
static StackType_t uxIdleTaskStack[ configMINIMAL_STACK_SIZE ];
* function then they must be declared static - otherwise they will be allocated on
* the stack and so not exists after this function exits. */
static StaticTask_t xIdleTaskTCB;
static StackType_t uxIdleTaskStack[ configMINIMAL_STACK_SIZE ];
/* 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;
/* Pass out the array that will be used as the Idle task's stack. */
*ppxIdleTaskStackBuffer = uxIdleTaskStack;
/* Pass out the size of the array pointed to by *ppxIdleTaskStackBuffer.
Note that, as the array is necessarily of type StackType_t,
configMINIMAL_STACK_SIZE is specified in words, not bytes. */
* Note that, as the array is necessarily of type StackType_t,
* configMINIMAL_STACK_SIZE is specified in words, not bytes. */
*pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
}
/*-----------------------------------------------------------*/
/* configUSE_STATIC_ALLOCATION and configUSE_TIMERS are both set to 1, so the
application must provide an implementation of vApplicationGetTimerTaskMemory()
to provide the memory that is used by the Timer service task. */
void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer, StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize )
* application must provide an implementation of vApplicationGetTimerTaskMemory()
* to provide the memory that is used by the Timer service task. */
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
function then they must be declared static - otherwise they will be allocated on
the stack and so not exists after this function exits. */
static StaticTask_t xTimerTaskTCB;
* function then they must be declared static - otherwise they will be allocated on
* the stack and so not exists after this function exits. */
static StaticTask_t xTimerTaskTCB;
/* 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;
/* Pass out the array that will be used as the Timer task's stack. */
*ppxTimerTaskStackBuffer = uxTimerTaskStack;
/* Pass out the size of the array pointed to by *ppxTimerTaskStackBuffer.
Note that, as the array is necessarily of type StackType_t,
configMINIMAL_STACK_SIZE is specified in words, not bytes. */
* Note that, as the array is necessarily of type StackType_t,
* configMINIMAL_STACK_SIZE is specified in words, not bytes. */
*pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;
}
@ -547,34 +558,32 @@ static StaticTask_t xTimerTaskTCB;
static uint32_t prvKeyboardInterruptHandler( void )
{
/* Handle keyboard input. */
switch ( xKeyPressed )
switch( xKeyPressed )
{
case mainNO_KEY_PRESS_VALUE:
break;
case mainOUTPUT_TRACE_KEY:
#if( projCOVERAGE_TEST != 1 )
{
/* Saving the trace file requires Windows system calls, so enter a critical
* section to prevent deadlock or errors resulting from calling a Windows
* system call from within the FreeRTOS simulator. */
portENTER_CRITICAL();
{
( void ) xTraceDisable();
prvSaveTraceFile();
( void ) xTraceEnable( TRC_START );
}
portEXIT_CRITICAL();
}
#endif
break;
default:
#if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 )
{
case mainNO_KEY_PRESS_VALUE:
break;
case mainOUTPUT_TRACE_KEY:
#if ( projCOVERAGE_TEST != 1 )
/* Saving the trace file requires Windows system calls, so enter a critical
* section to prevent deadlock or errors resulting from calling a Windows
* system call from within the FreeRTOS simulator. */
portENTER_CRITICAL();
{
( void ) xTraceDisable();
prvSaveTraceFile();
( void ) xTraceEnable( TRC_START );
}
portEXIT_CRITICAL();
#endif
break;
default:
#if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 )
/* Call the keyboard interrupt handler for the blinky demo. */
vBlinkyKeyboardInterruptHandler( xKeyPressed );
}
#endif
break;
#endif
break;
}
/* This interrupt does not require a context switch so return pdFALSE */
@ -592,7 +601,7 @@ static DWORD WINAPI prvWindowsKeyboardInputThread( void * pvParam )
{
( void ) pvParam;
for ( ; ; )
for( ; ; )
{
/* Block on acquiring a key press */
xKeyPressed = _getch();