github-forks
/
FreeRTOS
mirror of https://github.com/FreeRTOS/FreeRTOS.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Some changes to the RX/Renesas main-full.c file to tidy up a bit.

Browse Source
pull/1/head
Richard Barry 15 years ago
parent c1dca1a069
commit bb26ea557f
1 changed files with 130 additions and 119 deletions
Show Stats Download Patch File Download Diff File

133
Demo/RX600_RX62N-MDK_Renesas/RTOSDemo/main-full.c
Unescape Escape View File

@ -56,7 +56,7 @@
* If you would prefer a much simpler project to get started with then select
* the 'Blinky' build configuration within the HEW IDE.
*
* Creates all the demo application tasks, then starts the scheduler. The WEB
* Creates all the demo application tasks, then starts the scheduler. The web
* documentation provides more details of the standard demo application tasks,
* which provide no particular functionality but do provide a good example of
* how to use the FreeRTOS API. The tasks defined in flop.c are included in the
@ -68,15 +68,14 @@
*
* "Reg test" tasks - These fill the registers with known values, then check
* that each register still contains its expected value. Each task uses
* different values. The tasks run with very low priority so get preempted very
* frequently. A register containing an unexpected value is indicative of an
* error in the context switching mechanism and will result in interrupts being
* disabled and a branch to a null loop. This has the effect of stopping
* execution of all the tests and tasks, which in turn results in all LED
* activity stopping too. The nature of the reg test tasks necessitates that
* they are written in assembly code. The check task (described below) checks
* that the reg test tasks are still executing and will indicate an error if
* either reg test task is found to have stalled.
* different values. The tasks run with very low priority so get preempted
* very frequently. A check variable is incremented on each iteration of the
* test loop. A register containing an unexpected value is indicative of an
* error in the context switching mechanism and will result in a branch to a
* null loop - which in turn will prevent the check variable from incrementing
* any further and allow the check task (described below) to determine that an
* error has occurred. The nature of the reg test tasks necessitates that they
* are written in assembly code.
*
* "Check" task - This only executes every five seconds but has a high priority
* to ensure it gets processor time. Its main function is to check that all the
@ -149,22 +148,22 @@ tasks check that the values are passed in correctly. */
#define mainFLOP_TASK_PRIORITY ( tskIDLE_PRIORITY )
/* The LED toggled by the check task. */
#define mainCHECK_LED ( 5 )
#define mainCHECK_LED ( 5 )
/* The rate at which mainCHECK_LED will toggle when all the tasks are running
without error. Controlled by the check task as described at the top of this
file. */
#define mainNO_ERROR_CYCLE_TIME ( 5000 / portTICK_RATE_MS )
#define mainNO_ERROR_CYCLE_TIME ( 5000 / portTICK_RATE_MS )
/* The rate at which mainCHECK_LED will toggle when an error has been reported
by at least one task. Controlled by the check task as described at the top of
this file. */
#define mainERROR_CYCLE_TIME ( 200 / portTICK_RATE_MS )
#define mainERROR_CYCLE_TIME ( 200 / portTICK_RATE_MS )
/* The period of the peripheral clock in nano seconds. This is used to calculate
the jitter time in nano seconds as part of the high frequency timer test. The
clock driving the timer is divided by 8. */
#define mainNS_PER_CLOCK ( ( unsigned long ) ( ( 1.0 / ( ( double ) configPERIPHERAL_CLOCK_HZ ) / 8.0 ) * 1000000000.0 ) )
#define mainNS_PER_CLOCK ( ( unsigned long ) ( ( 1.0 / ( ( double ) configPERIPHERAL_CLOCK_HZ ) / 8.0 ) * 1000000000.0 ) )
/*
* vApplicationMallocFailedHook() will only be called if
@ -245,12 +244,12 @@ extern void HardwareSetup( void );
/* Create the standard demo tasks. */
vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );
vCreateBlockTimeTasks();
vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );
vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );
vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY );
vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );
vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );
vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );
vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY );
vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );
vStartLEDFlashTasks( mainFLASH_TASK_PRIORITY );
vStartQueuePeekTasks();
vStartQueuePeekTasks();
vStartRecursiveMutexTasks();
vStartInterruptQueueTasks();
vStartMathTasks( mainFLOP_TASK_PRIORITY );
@ -258,7 +257,7 @@ extern void HardwareSetup( void );
/* The suicide tasks must be created last as they need to know how many
tasks were running prior to their creation in order to ascertain whether
or not the correct/expected number of tasks are running at any given time. */
vCreateSuicidalTasks( mainCREATOR_TASK_PRIORITY );
vCreateSuicidalTasks( mainCREATOR_TASK_PRIORITY );
/* Start the tasks running. */
vTaskStartScheduler();
@ -277,6 +276,7 @@ portTickType xNextWakeTime, xCycleFrequency = mainNO_ERROR_CYCLE_TIME;
extern void vSetupHighFrequencyTimer( void );
extern volatile unsigned short usMaxJitter;
volatile unsigned long ulActualJitter = 0;
static char cErrorText[ 100 ];
/* If this is being executed then the kernel has been started. Start the high
frequency timer test as described at the top of this file. This is only
@ -301,46 +301,57 @@ volatile unsigned long ulActualJitter = 0;
rate at which mainCHECK_LED flashes to give visual feedback that an error
has occurred. */
xCycleFrequency = mainERROR_CYCLE_TIME;
strcpy( cErrorText, "Error: GenQueue" );
}
else if( xAreQueuePeekTasksStillRunning() != pdTRUE )
{
xCycleFrequency = mainERROR_CYCLE_TIME;
strcpy( cErrorText, "Error: QueuePeek" );
}
else if( xAreBlockingQueuesStillRunning() != pdTRUE )
{
xCycleFrequency = mainERROR_CYCLE_TIME;
strcpy( cErrorText, "Error: BlockQueue" );
}
else if( xAreBlockTimeTestTasksStillRunning() != pdTRUE )
{
xCycleFrequency = mainERROR_CYCLE_TIME;
strcpy( cErrorText, "Error: BlockTime" );
}
else if( xAreSemaphoreTasksStillRunning() != pdTRUE )
{
xCycleFrequency = mainERROR_CYCLE_TIME;
strcpy( cErrorText, "Error: SemTest" );
}
else if( xArePollingQueuesStillRunning() != pdTRUE )
{
xCycleFrequency = mainERROR_CYCLE_TIME;
strcpy( cErrorText, "Error: PollQueue" );
}
else if( xIsCreateTaskStillRunning() != pdTRUE )
{
xCycleFrequency = mainERROR_CYCLE_TIME;
strcpy( cErrorText, "Error: Death" );
}
else if( xAreIntegerMathsTaskStillRunning() != pdTRUE )
{
xCycleFrequency = mainERROR_CYCLE_TIME;
strcpy( cErrorText, "Error: IntMath" );
}
else if( xAreRecursiveMutexTasksStillRunning() != pdTRUE )
{
xCycleFrequency = mainERROR_CYCLE_TIME;
strcpy( cErrorText, "Error: RecMutex" );
}
else if( xAreSemaphoreTasksStillRunning() != pdTRUE )
{
xCycleFrequency = mainERROR_CYCLE_TIME;
}
else if( xArePollingQueuesStillRunning() != pdTRUE )
{
xCycleFrequency = mainERROR_CYCLE_TIME;
}
else if( xIsCreateTaskStillRunning() != pdTRUE )
{
xCycleFrequency = mainERROR_CYCLE_TIME;
}
else if( xAreIntegerMathsTaskStillRunning() != pdTRUE )
{
xCycleFrequency = mainERROR_CYCLE_TIME;
}
else if( xAreRecursiveMutexTasksStillRunning() != pdTRUE )
{
xCycleFrequency = mainERROR_CYCLE_TIME;
}
else if( xAreIntQueueTasksStillRunning() != pdPASS )
{
xCycleFrequency = mainERROR_CYCLE_TIME;
strcpy( cErrorText, "Error: IntQueue" );
}
else if( xAreMathsTaskStillRunning() != pdPASS )
{
xCycleFrequency = mainERROR_CYCLE_TIME;
strcpy( cErrorText, "Error: Flop" );
}
/* Check the reg test tasks are still cycling. They will stop incrementing
@ -348,11 +359,13 @@ volatile unsigned long ulActualJitter = 0;
if( ulRegTest1CycleCount == ulLastRegTest1CycleCount )
{
xCycleFrequency = mainERROR_CYCLE_TIME;
strcpy( cErrorText, "Error: RegTest1" );
}
if( ulRegTest2CycleCount == ulLastRegTest2CycleCount )
{
xCycleFrequency = mainERROR_CYCLE_TIME;
strcpy( cErrorText, "Error: RegTest2" );
}
ulLastRegTest1CycleCount = ulRegTest1CycleCount;
@ -505,43 +518,42 @@ TestLoop1:
; Now compare each register to ensure it still contains the value that was
; set before this loop was entered.
CMP #1, R1
BNE RegTest2Error
BNE RegTest1Error
CMP #2, R2
BNE RegTest2Error
BNE RegTest1Error
CMP #3, R3
BNE RegTest2Error
BNE RegTest1Error
CMP #4, R4
BNE RegTest2Error
BNE RegTest1Error
CMP #5, R5
BNE RegTest2Error
BNE RegTest1Error
CMP #6, R6
BNE RegTest2Error
BNE RegTest1Error
CMP #7, R7
BNE RegTest2Error
BNE RegTest1Error
CMP #8, R8
BNE RegTest2Error
BNE RegTest1Error
CMP #9, R9
BNE RegTest2Error
BNE RegTest1Error
CMP #10, R10
BNE RegTest2Error
BNE RegTest1Error
CMP #11, R11
BNE RegTest2Error
BNE RegTest1Error
CMP #12, R12
BNE RegTest2Error
BNE RegTest1Error
CMP #13, R13
BNE RegTest2Error
BNE RegTest1Error
CMP #14, R14
BNE RegTest2Error
BNE RegTest1Error
CMP #15, R15
BNE RegTest2Error
BNE RegTest1Error
; All comparisons passed, start a new itteratio of this loop.
BRA TestLoop1
RegTest1Error:
; A compare failed, something has gone wrong. Stop the tick and any other
; interrupts to make it obvious that things have halted.
CLRPSW I
; A compare failed, just loop here so the loop counter stops incrementing
; causing the check task to indicate the error.
BRA RegTest1Error
}
/*-----------------------------------------------------------*/
@ -618,9 +630,8 @@ TestLoop2:
BRA TestLoop2
RegTest2Error:
; A compare failed, something went wrong. Stop the tick and any other
; interrupts to make it obvious that things have halted.
CLRPSW I
; A compare failed, just loop here so the loop counter stops incrementing
; - causing the check task to indicate the error.
BRA RegTest2Error
}

Write Preview
Loading…
Cancel
Save