len0rd/FreeRTOS-Kernel
1
0
Fork 0
mirror of https://github.com/FreeRTOS/FreeRTOS-Kernel.git synced 2025-08-19 09:38:32 -04:00
Code Issues Projects Releases Packages Wiki Activity

Changes ready for V4.1.0.

Browse source
This commit is contained in:
Richard Barry 2006-08-27 14:09:54 +00:00
parent b7199e5967
commit b18929ef7d
9 changed files with 870 additions and 235 deletions
Download patch file Download diff file Expand all files Collapse all files

467
Demo/Common/Minimal/blocktim.c Normal file
View file

@ -0,0 +1,467 @@
/*
FreeRTOS.org V4.0.5 - Copyright (C) 2003-2006 Richard Barry.
This file is part of the FreeRTOS.org distribution.
FreeRTOS.org is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
FreeRTOS.org is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with FreeRTOS.org; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
A special exception to the GPL can be applied should you wish to distribute
a combined work that includes FreeRTOS.org, without being obliged to provide
the source code for any proprietary components. See the licensing section
of http://www.FreeRTOS.org for full details of how and when the exception
can be applied.
***************************************************************************
See http://www.FreeRTOS.org for documentation, latest information, license
and contact details. Please ensure to read the configuration and relevant
port sections of the online documentation.
***************************************************************************
*/
/*
* This file contains some test scenarios that ensure tasks do not exit queue
* send or receive functions prematurely. A description of the tests is
* included within the code.
*/
/* Kernel includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
/* Task priorities. */
#define bktPRIMARY_PRIORITY ( 3 )
#define bktSECONDARY_PRIORITY ( 2 )
/* Task behaviour. */
#define bktQUEUE_LENGTH ( 5 )
#define bktSHORT_WAIT ( ( ( portTickType ) 20 ) / portTICK_RATE_MS )
#define bktPRIMARY_BLOCK_TIME ( 10 )
#define bktALLOWABLE_MARGIN ( 12 )
#define bktTIME_TO_BLOCK ( 175 )
#define bktDONT_BLOCK ( ( portTickType ) 0 )
#define bktRUN_INDICATOR ( ( unsigned portBASE_TYPE ) 0x55 )
/* The queue on which the tasks block. */
static xQueueHandle xTestQueue;
/* Handle to the secondary task is required by the primary task for calls
to vTaskSuspend/Resume(). */
static xTaskHandle xSecondary;
/* Used to ensure that tasks are still executing without error. */
static portBASE_TYPE xPrimaryCycles = 0, xSecondaryCycles = 0;
static portBASE_TYPE xErrorOccurred = pdFALSE;
/* Provides a simple mechanism for the primary task to know when the
secondary task has executed. */
static volatile unsigned portBASE_TYPE xRunIndicator;
/* The two test tasks. Their behaviour is commented within the files. */
static void vPrimaryBlockTimeTestTask( void *pvParameters );
static void vSecondaryBlockTimeTestTask( void *pvParameters );
/*-----------------------------------------------------------*/
void vCreateBlockTimeTasks( void )
{
/* Create the queue on which the two tasks block. */
xTestQueue = xQueueCreate( bktQUEUE_LENGTH, sizeof( portBASE_TYPE ) );
/* Create the two test tasks. */
xTaskCreate( vPrimaryBlockTimeTestTask, "BTest1", configMINIMAL_STACK_SIZE, NULL, bktPRIMARY_PRIORITY, NULL );
xTaskCreate( vSecondaryBlockTimeTestTask, "BTest2", configMINIMAL_STACK_SIZE, NULL, bktSECONDARY_PRIORITY, &xSecondary );
}
/*-----------------------------------------------------------*/
static void vPrimaryBlockTimeTestTask( void *pvParameters )
{
portBASE_TYPE xItem, xData;
portTickType xTimeWhenBlocking;
portTickType xTimeToBlock, xBlockedTime;
for( ;; )
{
/*********************************************************************
Test 1
Simple block time wakeup test on queue receives. */
for( xItem = 0; xItem < bktQUEUE_LENGTH; xItem++ )
{
/* The queue is empty. Attempt to read from the queue using a block
time. When we wake, ensure the delta in time is as expected. */
xTimeToBlock = bktPRIMARY_BLOCK_TIME << xItem;
/* A critical section is used to minimise the jitter in the time
measurements. */
portENTER_CRITICAL();
{
xTimeWhenBlocking = xTaskGetTickCount();
/* We should unblock after xTimeToBlock having not received
anything on the queue. */
if( xQueueReceive( xTestQueue, &xData, xTimeToBlock ) != errQUEUE_EMPTY )
{
xErrorOccurred = pdTRUE;
}
/* How long were we blocked for? */
xBlockedTime = xTaskGetTickCount() - xTimeWhenBlocking;
}
portEXIT_CRITICAL();
if( xBlockedTime < xTimeToBlock )
{
/* Should not have blocked for less than we requested. */
xErrorOccurred = pdTRUE;
}
if( xBlockedTime > ( xTimeToBlock + bktALLOWABLE_MARGIN ) )
{
/* Should not have blocked for longer than we requested,
although we would not necessarily run as soon as we were
unblocked so a margin is allowed. */
xErrorOccurred = pdTRUE;
}
}
/*********************************************************************
Test 2
Simple block time wakeup test on queue sends.
First fill the queue. It should be empty so all sends should pass. */
for( xItem = 0; xItem < bktQUEUE_LENGTH; xItem++ )
{
if( xQueueSend( xTestQueue, &xItem, bktDONT_BLOCK ) != pdPASS )
{
xErrorOccurred = pdTRUE;
}
}
for( xItem = 0; xItem < bktQUEUE_LENGTH; xItem++ )
{
/* The queue is full. Attempt to write to the queue using a block
time. When we wake, ensure the delta in time is as expected. */
xTimeToBlock = bktPRIMARY_BLOCK_TIME << xItem;
portENTER_CRITICAL();
{
xTimeWhenBlocking = xTaskGetTickCount();
/* We should unblock after xTimeToBlock having not received
anything on the queue. */
if( xQueueSend( xTestQueue, &xItem, xTimeToBlock ) != errQUEUE_FULL )
{
xErrorOccurred = pdTRUE;
}
/* How long were we blocked for? */
xBlockedTime = xTaskGetTickCount() - xTimeWhenBlocking;
}
portEXIT_CRITICAL();
if( xBlockedTime < xTimeToBlock )
{
/* Should not have blocked for less than we requested. */
xErrorOccurred = pdTRUE;
}
if( xBlockedTime > ( xTimeToBlock + bktALLOWABLE_MARGIN ) )
{
/* Should not have blocked for longer than we requested,
although we would not necessarily run as soon as we were
unblocked so a margin is allowed. */
xErrorOccurred = pdTRUE;
}
}
/*********************************************************************
Test 3
Wake the other task, it will block attempting to post to the queue.
When we read from the queue the other task will wake, but before it
can run we will post to the queue again. When the other task runs it
will find the queue still full, even though it was woken. It should
recognise that its block time has not expired and return to block for
the remains of its block time.
Wake the other task so it blocks attempting to post to the already
full queue. */
xRunIndicator = 0;
vTaskResume( xSecondary );
/* We need to wait a little to ensure the other task executes. */
while( xRunIndicator != bktRUN_INDICATOR )
{
/* The other task has not yet executed. */
vTaskDelay( bktSHORT_WAIT );
}
/* Make sure the other task is blocked on the queue. */
vTaskDelay( bktSHORT_WAIT );
xRunIndicator = 0;
for( xItem = 0; xItem < bktQUEUE_LENGTH; xItem++ )
{
/* Now when we make space on the queue the other task should wake
but not execute as this task has higher priority. */
if( xQueueReceive( xTestQueue, &xData, bktDONT_BLOCK ) != pdPASS )
{
xErrorOccurred = pdTRUE;
}
/* Now fill the queue again before the other task gets a chance to
execute. If the other task had executed we would find the queue
full ourselves, and the other task have set xRunIndicator. */
if( xQueueSend( xTestQueue, &xItem, bktDONT_BLOCK ) != pdPASS )
{
xErrorOccurred = pdTRUE;
}
if( xRunIndicator == bktRUN_INDICATOR )
{
/* The other task should not have executed. */
xErrorOccurred = pdTRUE;
}
/* Raise the priority of the other task so it executes and blocks
on the queue again. */
vTaskPrioritySet( xSecondary, bktPRIMARY_PRIORITY + 2 );
/* The other task should now have re-blocked without exiting the
queue function. */
if( xRunIndicator == bktRUN_INDICATOR )
{
/* The other task should not have executed outside of the
queue function. */
xErrorOccurred = pdTRUE;
}
/* Set the priority back down. */
vTaskPrioritySet( xSecondary, bktSECONDARY_PRIORITY );
}
/* Let the other task timeout. When it unblockes it will check that it
unblocked at the correct time, then suspend itself. */
while( xRunIndicator != bktRUN_INDICATOR )
{
vTaskDelay( bktSHORT_WAIT );
}
vTaskDelay( bktSHORT_WAIT );
xRunIndicator = 0;
/*********************************************************************
Test 4
As per test 3 - but with the send and receive the other way around.
The other task blocks attempting to read from the queue.
Empty the queue. We should find that it is full. */
for( xItem = 0; xItem < bktQUEUE_LENGTH; xItem++ )
{
if( xQueueReceive( xTestQueue, &xData, bktDONT_BLOCK ) != pdPASS )
{
xErrorOccurred = pdTRUE;
}
}
/* Wake the other task so it blocks attempting to read from the
already empty queue. */
vTaskResume( xSecondary );
/* We need to wait a little to ensure the other task executes. */
while( xRunIndicator != bktRUN_INDICATOR )
{
vTaskDelay( bktSHORT_WAIT );
}
vTaskDelay( bktSHORT_WAIT );
xRunIndicator = 0;
for( xItem = 0; xItem < bktQUEUE_LENGTH; xItem++ )
{
/* Now when we place an item on the queue the other task should
wake but not execute as this task has higher priority. */
if( xQueueSend( xTestQueue, &xItem, bktDONT_BLOCK ) != pdPASS )
{
xErrorOccurred = pdTRUE;
}
/* Now empty the queue again before the other task gets a chance to
execute. If the other task had executed we would find the queue
empty ourselves, and the other task would be suspended. */
if( xQueueReceive( xTestQueue, &xData, bktDONT_BLOCK ) != pdPASS )
{
xErrorOccurred = pdTRUE;
}
if( xRunIndicator == bktRUN_INDICATOR )
{
/* The other task should not have executed. */
xErrorOccurred = pdTRUE;
}
/* Raise the priority of the other task so it executes and blocks
on the queue again. */
vTaskPrioritySet( xSecondary, bktPRIMARY_PRIORITY + 2 );
/* The other task should now have re-blocked without exiting the
queue function. */
if( xRunIndicator == bktRUN_INDICATOR )
{
/* The other task should not have executed outside of the
queue function. */
xErrorOccurred = pdTRUE;
}
vTaskPrioritySet( xSecondary, bktSECONDARY_PRIORITY );
}
/* Let the other task timeout. When it unblockes it will check that it
unblocked at the correct time, then suspend itself. */
while( xRunIndicator != bktRUN_INDICATOR )
{
vTaskDelay( bktSHORT_WAIT );
}
vTaskDelay( bktSHORT_WAIT );
xPrimaryCycles++;
}
}
/*-----------------------------------------------------------*/
static void vSecondaryBlockTimeTestTask( void *pvParameters )
{
portTickType xTimeWhenBlocking, xBlockedTime;
portBASE_TYPE xData;
for( ;; )
{
/*********************************************************************
Test 1 and 2
This task does does not participate in these tests. */
vTaskSuspend( NULL );
/*********************************************************************
Test 3
The first thing we do is attempt to read from the queue. It should be
full so we block. Note the time before we block so we can check the
wake time is as per that expected. */
portENTER_CRITICAL();
{
xTimeWhenBlocking = xTaskGetTickCount();
/* We should unblock after bktTIME_TO_BLOCK having not received
anything on the queue. */
xData = 0;
xRunIndicator = bktRUN_INDICATOR;
if( xQueueSend( xTestQueue, &xData, bktTIME_TO_BLOCK ) != errQUEUE_FULL )
{
xErrorOccurred = pdTRUE;
}
/* How long were we inside the send function? */
xBlockedTime = xTaskGetTickCount() - xTimeWhenBlocking;
}
portEXIT_CRITICAL();
/* We should not have blocked for less time than bktTIME_TO_BLOCK. */
if( xBlockedTime < bktTIME_TO_BLOCK )
{
xErrorOccurred = pdTRUE;
}
/* We should of not blocked for much longer than bktALLOWABLE_MARGIN
either. A margin is permitted as we would not necessarily run as
soon as we unblocked. */
if( xBlockedTime > ( bktTIME_TO_BLOCK + bktALLOWABLE_MARGIN ) )
{
xErrorOccurred = pdTRUE;
}
/* Suspend ready for test 3. */
xRunIndicator = bktRUN_INDICATOR;
vTaskSuspend( NULL );
/*********************************************************************
Test 4
As per test three, but with the send and receive reversed. */
portENTER_CRITICAL();
{
xTimeWhenBlocking = xTaskGetTickCount();
/* We should unblock after bktTIME_TO_BLOCK having not received
anything on the queue. */
xRunIndicator = bktRUN_INDICATOR;
if( xQueueReceive( xTestQueue, &xData, bktTIME_TO_BLOCK ) != errQUEUE_EMPTY )
{
xErrorOccurred = pdTRUE;
}
xBlockedTime = xTaskGetTickCount() - xTimeWhenBlocking;
}
portEXIT_CRITICAL();
/* We should not have blocked for less time than bktTIME_TO_BLOCK. */
if( xBlockedTime < bktTIME_TO_BLOCK )
{
xErrorOccurred = pdTRUE;
}
/* We should of not blocked for much longer than bktALLOWABLE_MARGIN
either. A margin is permitted as we would not necessarily run as soon
as we unblocked. */
if( xBlockedTime > ( bktTIME_TO_BLOCK + bktALLOWABLE_MARGIN ) )
{
xErrorOccurred = pdTRUE;
}
xRunIndicator = bktRUN_INDICATOR;
xSecondaryCycles++;
}
}
/*-----------------------------------------------------------*/
portBASE_TYPE xAreBlockTimeTestTasksStillRunning( void )
{
static portBASE_TYPE xLastPrimaryCycleCount = 0, xLastSecondaryCycleCount = 0;
portBASE_TYPE xReturn = pdPASS;
/* Have both tasks performed at least one cycle since this function was
last called? */
if( xPrimaryCycles == xLastPrimaryCycleCount )
{
xReturn = pdFAIL;
}
if( xSecondaryCycles == xLastSecondaryCycleCount )
{
xReturn = pdFAIL;
}
if( xErrorOccurred == pdTRUE )
{
xReturn = pdFAIL;
}
xLastSecondaryCycleCount = xSecondaryCycles;
xLastPrimaryCycleCount = xPrimaryCycles;
return xReturn;
}

41
Demo/Common/include/blocktim.h Normal file
View file

@ -0,0 +1,41 @@
/*
FreeRTOS.org V4.0.5 - Copyright (C) 2003-2006 Richard Barry.
This file is part of the FreeRTOS.org distribution.
FreeRTOS.org is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
FreeRTOS.org is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with FreeRTOS.org; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
A special exception to the GPL can be applied should you wish to distribute
a combined work that includes FreeRTOS.org, without being obliged to provide
the source code for any proprietary components. See the licensing section
of http://www.FreeRTOS.org for full details of how and when the exception
can be applied.
***************************************************************************
See http://www.FreeRTOS.org for documentation, latest information, license
and contact details. Please ensure to read the configuration and relevant
port sections of the online documentation.
***************************************************************************
*/
#ifndef BLOCK_TIME_TEST_H
#define BLOCK_TIME_TEST_H
void vCreateBlockTimeTasks( void );
portBASE_TYPE xAreBlockTimeTestTasksStillRunning( void );
#endif

8
Demo/PC/main.c
View file

@ -115,6 +115,7 @@ Changes from V3.2.4
#include "dynamic.h"
#include "mevents.h"
#include "crhook.h"
#include "blocktim.h"
/* Priority definitions for the tasks in the demo application. */
#define mainLED_TASK_PRIORITY ( tskIDLE_PRIORITY + 1 )
@ -171,6 +172,7 @@ portSHORT main( void )
vStartComTestTasks( mainCOM_TEST_PRIORITY, serCOM1, ser115200 );
vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );
vStartBlockingQueueTasks( mainQUEUE_BLOCK_PRIORITY );
vCreateBlockTimeTasks();
vStartSemaphoreTasks( mainSEMAPHORE_TASK_PRIORITY );
vStartDynamicPriorityTasks();
@ -380,6 +382,12 @@ static portSHORT sErrorHasOccurred = pdFALSE;
sErrorHasOccurred = pdTRUE;
}
if( xAreBlockTimeTestTasksStillRunning() != pdTRUE )
{
vDisplayMessage( "Error in block time test tasks!\r\n" );
sErrorHasOccurred = pdTRUE;
}
if( sErrorHasOccurred == pdFALSE )
{
vDisplayMessage( "OK " );

210
Demo/PC/rtosdemo.tgt
View file

@ -75,7 +75,7 @@ WVList
0
19
WPickList
48
50
20
MItem
3
@ -706,8 +706,8 @@ WVList
0
168
MItem
27
..\COMMON\MINIMAL\crflash.c
28
..\COMMON\MINIMAL\blocktim.c
169
WString
4
@ -724,8 +724,8 @@ WVList
0
172
MItem
26
..\COMMON\MINIMAL\crhook.c
27
..\COMMON\MINIMAL\crflash.c
173
WString
4
@ -742,8 +742,8 @@ WVList
0
176
MItem
15
fileio\fileio.c
26
..\COMMON\MINIMAL\crhook.c
177
WString
4
@ -760,8 +760,8 @@ WVList
0
180
MItem
6
main.c
15
fileio\fileio.c
181
WString
4
@ -778,8 +778,8 @@ WVList
0
184
MItem
17
partest\partest.c
6
main.c
185
WString
4
@ -796,8 +796,8 @@ WVList
0
188
MItem
15
serial\serial.c
17
partest\partest.c
189
WString
4
@ -814,26 +814,26 @@ WVList
0
192
MItem
3
*.h
15
serial\serial.c
193
WString
3
NIL
4
COBJ
194
WVList
0
195
WVList
0
-1
20
1
1
0
196
MItem
31
..\..\SOURCE\INCLUDE\croutine.h
3
*.h
197
WString
3
@ -844,14 +844,14 @@ WVList
199
WVList
0
192
1
-1
1
0
0
200
MItem
27
..\..\source\include\list.h
31
..\..\SOURCE\INCLUDE\croutine.h
201
WString
3
@ -862,14 +862,14 @@ WVList
203
WVList
0
192
196
1
1
0
204
MItem
31
..\..\source\include\portable.h
27
..\..\source\include\list.h
205
WString
3
@ -880,14 +880,14 @@ WVList
207
WVList
0
192
196
1
1
0
208
MItem
31
..\..\source\include\projdefs.h
..\..\source\include\portable.h
209
WString
3
@ -898,14 +898,14 @@ WVList
211
WVList
0
192
196
1
1
0
212
MItem
28
..\..\source\include\queue.h
31
..\..\source\include\projdefs.h
213
WString
3
@ -916,14 +916,14 @@ WVList
215
WVList
0
192
196
1
1
0
216
MItem
29
..\..\source\include\semphr.h
28
..\..\source\include\queue.h
217
WString
3
@ -934,14 +934,14 @@ WVList
219
WVList
0
192
196
1
1
0
220
MItem
27
..\..\source\include\task.h
29
..\..\source\include\semphr.h
221
WString
3
@ -952,14 +952,14 @@ WVList
223
WVList
0
192
196
1
1
0
224
MItem
55
..\..\source\portable\owatcom\16bitdos\common\portasm.h
27
..\..\source\include\task.h
225
WString
3
@ -970,14 +970,14 @@ WVList
227
WVList
0
192
196
1
1
0
228
MItem
53
..\..\source\portable\owatcom\16bitdos\pc\portmacro.h
55
..\..\source\portable\owatcom\16bitdos\common\portasm.h
229
WString
3
@ -988,14 +988,14 @@ WVList
231
WVList
0
192
196
1
1
0
232
MItem
26
..\common\include\blockq.h
53
..\..\source\portable\owatcom\16bitdos\pc\portmacro.h
233
WString
3
@ -1006,14 +1006,14 @@ WVList
235
WVList
0
192
196
1
1
0
236
MItem
27
..\common\include\comtest.h
26
..\common\include\blockq.h
237
WString
3
@ -1024,14 +1024,14 @@ WVList
239
WVList
0
192
196
1
1
0
240
MItem
26
..\COMMON\INCLUDE\crhook.h
28
..\COMMON\INCLUDE\blocktim.h
241
WString
3
@ -1042,14 +1042,14 @@ WVList
243
WVList
0
192
196
1
1
0
244
MItem
25
..\common\include\death.h
27
..\common\include\comtest.h
245
WString
3
@ -1060,14 +1060,14 @@ WVList
247
WVList
0
192
196
1
1
0
248
MItem
27
..\COMMON\INCLUDE\dynamic.h
26
..\COMMON\INCLUDE\crhook.h
249
WString
3
@ -1078,14 +1078,14 @@ WVList
251
WVList
0
192
196
1
1
0
252
MItem
26
..\common\include\fileio.h
25
..\common\include\death.h
253
WString
3
@ -1096,14 +1096,14 @@ WVList
255
WVList
0
192
196
1
1
0
256
MItem
25
..\common\include\flash.h
27
..\COMMON\INCLUDE\dynamic.h
257
WString
3
@ -1114,14 +1114,14 @@ WVList
259
WVList
0
192
196
1
1
0
260
MItem
24
..\common\include\flop.h
26
..\common\include\fileio.h
261
WString
3
@ -1132,14 +1132,14 @@ WVList
263
WVList
0
192
196
1
1
0
264
MItem
27
..\common\include\partest.h
25
..\common\include\flash.h
265
WString
3
@ -1150,14 +1150,14 @@ WVList
267
WVList
0
192
196
1
1
0
268
MItem
25
..\common\include\pollq.h
24
..\common\include\flop.h
269
WString
3
@ -1168,14 +1168,14 @@ WVList
271
WVList
0
192
196
1
1
0
272
MItem
25
..\common\include\print.h
27
..\common\include\partest.h
273
WString
3
@ -1186,14 +1186,14 @@ WVList
275
WVList
0
192
196
1
1
0
276
MItem
27
..\common\include\semtest.h
25
..\common\include\pollq.h
277
WString
3
@ -1204,14 +1204,14 @@ WVList
279
WVList
0
192
196
1
1
0
280
MItem
26
..\common\include\serial.h
25
..\common\include\print.h
281
WString
3
@ -1222,14 +1222,14 @@ WVList
283
WVList
0
192
196
1
1
0
284
MItem
16
FreeRTOSConfig.h
27
..\common\include\semtest.h
285
WString
3
@ -1240,7 +1240,43 @@ WVList
287
WVList
0
192
196
1
1
0
288
MItem
26
..\common\include\serial.h
289
WString
3
NIL
290
WVList
0
291
WVList
0
196
1
1
0
292
MItem
16
FreeRTOSConfig.h
293
WString
3
NIL
294
WVList
0
295
WVList
0
196
1
1
0

4
Demo/PC/rtosdemo.wpj
View file

@ -31,7 +31,7 @@ WRect
0
0
7168
7353
7168
0
0
9
@ -39,5 +39,5 @@ WFileName
12
rtosdemo.tgt
0
19
25
7