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

Get the trace utility and co-routines working.

Browse source
This commit is contained in:
Richard Barry 2008-02-15 20:08:30 +00:00
parent 91a1b614f8
commit c8b4248e5d
11 changed files with 780 additions and 229 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Demo/MB91460_Softune/SRC/FreeRTOSConfig.h
View file

@ -62,7 +62,7 @@
#define configUSE_MUTEXES 1
/* Co-routine definitions. */
#define configUSE_CO_ROUTINES 0
#define configUSE_CO_ROUTINES 1
#define configMAX_CO_ROUTINE_PRIORITIES ( 4 )

2
Demo/MB91460_Softune/SRC/Start91460.asm
View file

@ -234,7 +234,7 @@
;
#set STACK_RESERVE ON ; <<< reserve stack area in
; ; this module
#set STACK_SYS_SIZE 2000 ; <<< byte size of System stack
#set STACK_SYS_SIZE 1000 ; <<< byte size of System stack
#set STACK_USR_SIZE 4 ; <<< byte size of User stack
;
#set STACK_FILL ON ; <<< fills the stack area with pattern

230
Demo/MB91460_Softune/SRC/crflash_modified.c Normal file
View file

@ -0,0 +1,230 @@
/*
FreeRTOS.org V4.7.1 - Copyright (C) 2003-2008 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.
***************************************************************************
Please ensure to read the configuration and relevant port sections of the
online documentation.
+++ http://www.FreeRTOS.org +++
Documentation, latest information, license and contact details.
+++ http://www.SafeRTOS.com +++
A version that is certified for use in safety critical systems.
+++ http://www.OpenRTOS.com +++
Commercial support, development, porting, licensing and training services.
***************************************************************************
*/
/*
* This demo application file demonstrates the use of queues to pass data
* between co-routines.
*
* N represents the number of 'fixed delay' co-routines that are created and
* is set during initialisation.
*
* N 'fixed delay' co-routines are created that just block for a fixed
* period then post the number of an LED onto a queue. Each such co-routine
* uses a different block period. A single 'flash' co-routine is also created
* that blocks on the same queue, waiting for the number of the next LED it
* should flash. Upon receiving a number it simply toggle the instructed LED
* then blocks on the queue once more. In this manner each LED from LED 0 to
* LED N-1 is caused to flash at a different rate.
*
* The 'fixed delay' co-routines are created with co-routine priority 0. The
* flash co-routine is created with co-routine priority 1. This means that
* the queue should never contain more than a single item. This is because
* posting to the queue will unblock the 'flash' co-routine, and as this has
* a priority greater than the tasks posting to the queue it is guaranteed to
* have emptied the queue and blocked once again before the queue can contain
* any more date. An error is indicated if an attempt to post data to the
* queue fails - indicating that the queue is already full.
*
*/
/* Scheduler includes. */
#include "FreeRTOS.h"
#include "croutine.h"
#include "queue.h"
/* Demo application includes. */
#include "partest.h"
#include "crflash.h"
/* The queue should only need to be of length 1. See the description at the
top of the file. */
#define crfQUEUE_LENGTH 1
#define crfFIXED_DELAY_PRIORITY 0
#define crfFLASH_PRIORITY 1
/* Only one flash co-routine is created so the index is not significant. */
#define crfFLASH_INDEX 0
/* Don't allow more than crfMAX_FLASH_TASKS 'fixed delay' co-routines to be
created. */
#define crfMAX_FLASH_TASKS 8
/* We don't want to block when posting to the queue. */
#define crfPOSTING_BLOCK_TIME 0
/* Added by MPi, this define is added in order to make the vParTestToggleLED()
work. This basically differentiates the PDR09 from PDR00. 7-seg display LEDs connected
to PDR09 (SEG1) are used by the prvFlashCoRoutine() and PDR00 (SEG2) are used by tasks. */
#define PDR00_Offset 8
/*
* The 'fixed delay' co-routine as described at the top of the file.
*/
static void prvFixedDelayCoRoutine( xCoRoutineHandle xHandle, unsigned portBASE_TYPE uxIndex );
/*
* The 'flash' co-routine as described at the top of the file.
*/
static void prvFlashCoRoutine( xCoRoutineHandle xHandle, unsigned portBASE_TYPE uxIndex );
/* The queue used to pass data between the 'fixed delay' co-routines and the
'flash' co-routine. */
static xQueueHandle xFlashQueue;
/* This will be set to pdFALSE if we detect an error. */
static unsigned portBASE_TYPE uxCoRoutineFlashStatus = pdPASS;
/*-----------------------------------------------------------*/
/*
* See the header file for details.
*/
void vStartFlashCoRoutines( unsigned portBASE_TYPE uxNumberToCreate )
{
unsigned portBASE_TYPE uxIndex;
if( uxNumberToCreate > crfMAX_FLASH_TASKS )
{
uxNumberToCreate = crfMAX_FLASH_TASKS;
}
/* Create the queue used to pass data between the co-routines. */
xFlashQueue = xQueueCreate( crfQUEUE_LENGTH, sizeof( unsigned portBASE_TYPE ) );
if( xFlashQueue )
{
/* Create uxNumberToCreate 'fixed delay' co-routines. */
for( uxIndex = 0; uxIndex < uxNumberToCreate; uxIndex++ )
{
xCoRoutineCreate( prvFixedDelayCoRoutine, crfFIXED_DELAY_PRIORITY, uxIndex );
}
/* Create the 'flash' co-routine. */
xCoRoutineCreate( prvFlashCoRoutine, crfFLASH_PRIORITY, crfFLASH_INDEX );
}
}
/*-----------------------------------------------------------*/
static void prvFixedDelayCoRoutine( xCoRoutineHandle xHandle, unsigned portBASE_TYPE uxIndex )
{
/* Even though this is a co-routine the xResult variable does not need to be
static as we do not need it to maintain its state between blocks. */
signed portBASE_TYPE xResult;
/* The uxIndex parameter of the co-routine function is used as an index into
the xFlashRates array to obtain the delay period to use. */
static const portTickType xFlashRates[ crfMAX_FLASH_TASKS ] = { 150 / portTICK_RATE_MS,
200 / portTICK_RATE_MS,
250 / portTICK_RATE_MS,
300 / portTICK_RATE_MS,
350 / portTICK_RATE_MS,
400 / portTICK_RATE_MS,
450 / portTICK_RATE_MS,
500 / portTICK_RATE_MS };
/* Co-routines MUST start with a call to crSTART. */
crSTART( xHandle );
for( ;; )
{
/* Post our uxIndex value onto the queue. This is used as the LED to
flash. */
crQUEUE_SEND( xHandle, xFlashQueue, ( void * ) &uxIndex, crfPOSTING_BLOCK_TIME, &xResult );
if( xResult != pdPASS )
{
/* For the reasons stated at the top of the file we should always
find that we can post to the queue. If we could not then an error
has occurred. */
uxCoRoutineFlashStatus = pdFAIL;
}
crDELAY( xHandle, xFlashRates[ uxIndex ] );
}
/* Co-routines MUST end with a call to crEND. */
crEND();
}
/*-----------------------------------------------------------*/
static void prvFlashCoRoutine( xCoRoutineHandle xHandle, unsigned portBASE_TYPE uxIndex )
{
/* Even though this is a co-routine the variable do not need to be
static as we do not need it to maintain their state between blocks. */
signed portBASE_TYPE xResult;
unsigned portBASE_TYPE uxLEDToFlash;
/* Co-routines MUST start with a call to crSTART. */
crSTART( xHandle );
( void ) uxIndex;
for( ;; )
{
/* Block to wait for the number of the LED to flash. */
crQUEUE_RECEIVE( xHandle, xFlashQueue, &uxLEDToFlash, portMAX_DELAY, &xResult );
if( xResult != pdPASS )
{
/* We would not expect to wake unless we received something. */
uxCoRoutineFlashStatus = pdFAIL;
}
else
{
/* We received the number of an LED to flash - flash it! */
/* Added by MPi, PDR00_Offset is added in order to make the
vParTestToggleLED() work. */
vParTestToggleLED( uxLEDToFlash + PDR00_Offset );
}
}
/* Co-routines MUST end with a call to crEND. */
crEND();
}
/*-----------------------------------------------------------*/
portBASE_TYPE xAreFlashCoRoutinesStillRunning( void )
{
/* Return pdPASS or pdFAIL depending on whether an error has been detected
or not. */
return uxCoRoutineFlashStatus;
}

17
Demo/MB91460_Softune/SRC/main.c
View file

@ -83,7 +83,6 @@
#include "flash.h"
#include "integer.h"
#include "comtest2.h"
#include "PollQ.h"
#include "semtest.h"
#include "BlockQ.h"
#include "dynamic.h"
@ -94,14 +93,14 @@
#include "death.h"
#include "taskutility.h"
#include "partest.h"
#include "crflash.h"
/* Demo task priorities. */
#define mainWATCHDOG_TASK_PRIORITY ( tskIDLE_PRIORITY + 5 )
#define mainCHECK_TASK_PRIORITY ( tskIDLE_PRIORITY + 4 )
#define mainUTILITY_TASK_PRIORITY ( tskIDLE_PRIORITY + 3 )
#define mainUTILITY_TASK_PRIORITY ( tskIDLE_PRIORITY )
#define mainSEM_TEST_PRIORITY ( tskIDLE_PRIORITY + 3 )
#define mainCOM_TEST_PRIORITY ( tskIDLE_PRIORITY + 2 )
#define mainQUEUE_POLL_PRIORITY ( tskIDLE_PRIORITY + 2 )
#define mainQUEUE_BLOCK_PRIORITY ( tskIDLE_PRIORITY + 2 )
#define mainDEATH_PRIORITY ( tskIDLE_PRIORITY + 1 )
#define mainLED_TASK_PRIORITY ( tskIDLE_PRIORITY + 1 )
@ -130,6 +129,9 @@ LCD represent LEDs]*/
/* The number of interrupt levels to use. */
#define mainINTERRUPT_LEVELS ( 31 )
/* The number of 'flash' co-routines to create - each toggles a different LED. */
#define mainNUM_FLASH_CO_ROUTINES ( 8 )
/*---------------------------------------------------------------------------*/
/*
@ -176,7 +178,6 @@ void main(void)
vStartLEDFlashTasks( mainLED_TASK_PRIORITY );
vStartIntegerMathTasks( tskIDLE_PRIORITY );
vAltStartComTestTasks( mainCOM_TEST_PRIORITY, mainCOM_TEST_BAUD_RATE, mainCOM_TEST_LED - 1 );
vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );
vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );
vStartBlockingQueueTasks ( mainQUEUE_BLOCK_PRIORITY );
vStartDynamicPriorityTasks();
@ -184,6 +185,7 @@ void main(void)
vStartGenericQueueTasks( mainGENERIC_QUEUE_PRIORITY );
vStartQueuePeekTasks();
vCreateBlockTimeTasks();
vStartFlashCoRoutines( mainNUM_FLASH_CO_ROUTINES );
/* Start the 'Check' task which is defined in this file. */
xTaskCreate( prvErrorChecks, ( signed portCHAR * ) "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );
@ -264,11 +266,6 @@ portBASE_TYPE lReturn = pdPASS;
lReturn = pdFAIL;
}
if( xArePollingQueuesStillRunning() != pdTRUE )
{
lReturn = pdFAIL;
}
if( xAreComTestTasksStillRunning() != pdTRUE )
{
lReturn = pdFAIL;
@ -353,6 +350,8 @@ static void prvSetupHardware( void )
#if WATCHDOG == WTC_IN_IDLE
Kick_Watchdog();
#endif
vCoRoutineSchedule();
}
#else
#if WATCHDOG == WTC_IN_IDLE

82
Demo/MB91460_Softune/SRC/partest/partest.c
View file

@ -48,14 +48,25 @@
#define partstNUM_LEDs 8
static unsigned portCHAR sState[ 2 ] = { 0xFF, 0xFF };
static unsigned portSHORT sState1[ partstNUM_LEDs ] = { pdFALSE };
/*-----------------------------------------------------------*/
void vParTestInitialise( void )
{
<<<<<<< .mine
/* Set port for LED outputs. */
DDR16 = 0xFF;
DDR25=0xFF;
/* Start with LEDs off. */
PDR16 = 0x00;
PDR25 = 0x00;
=======
DDR00 = 0xFF;
PDR00 = 0xFF;
DDR09 = 0xFF;
PDR09 = 0xFF;
>>>>>>> .r192
}
/*-----------------------------------------------------------*/
@ -63,11 +74,30 @@ void vParTestToggleLED( unsigned portBASE_TYPE uxLED )
{
if( uxLED < partstNUM_LEDs )
{
<<<<<<< .mine
taskENTER_CRITICAL();
=======
vTaskSuspendAll();
/* Toggle the state of the single genuine on board LED. */
if( ( sState[ 0 ] & ( ( unsigned portCHAR ) ( 1 << uxLED ) ) ) == 0 )
>>>>>>> .r192
{
<<<<<<< .mine
/* Toggle the state of the single genuine on board LED. */
if( sState[ uxLED ])
{
PDR25 |= ( 1 << uxLED );
}
else
{
PDR25 &= ~( 1 << uxLED );
}
sState[ uxLED ] = !( sState[ uxLED ] );
}
taskEXIT_CRITICAL();
=======
PDR09 |= ( 1 << uxLED );
sState[ 0 ] |= ( 1 << uxLED );
}
@ -78,7 +108,33 @@ void vParTestToggleLED( unsigned portBASE_TYPE uxLED )
}
xTaskResumeAll();
>>>>>>> .r192
}
<<<<<<< .mine
else
{
uxLED -= partstNUM_LEDs;
if( uxLED < partstNUM_LEDs )
{
taskENTER_CRITICAL();
{
/* Toggle the state of the single genuine on board LED. */
if( sState1[uxLED])
{
PDR16 |= ( 1 << uxLED );
}
else
{
PDR16 &= ~( 1 << uxLED );
}
sState1[ uxLED ] = !( sState1[ uxLED ] );
}
taskEXIT_CRITICAL();
}
}
=======
else
{
vTaskSuspendAll();
@ -98,6 +154,7 @@ void vParTestToggleLED( unsigned portBASE_TYPE uxLED )
xTaskResumeAll();
}
>>>>>>> .r192
}
/*-----------------------------------------------------------*/
@ -122,6 +179,30 @@ void vParTestSetLED( unsigned portBASE_TYPE uxLED, signed portBASE_TYPE xValue )
xTaskResumeAll();
}
<<<<<<< .mine
else
{
uxLED -= partstNUM_LEDs;
if( uxLED < partstNUM_LEDs )
{
taskENTER_CRITICAL();
{
if( xValue )
{
PDR16 |= (1 << uxLED);
sState1[uxLED] = 1;
}
else
{
PDR16 &= ~(1 << uxLED);
sState1[uxLED] = 0;
}
}
taskEXIT_CRITICAL();
}
}
=======
else
{
vTaskSuspendAll();
@ -140,5 +221,6 @@ void vParTestSetLED( unsigned portBASE_TYPE uxLED, signed portBASE_TYPE xValue )
xTaskResumeAll();
}
>>>>>>> .r192
}

286
Demo/MB91460_Softune/SRC/utility/printf-stdarg.c Normal file
View file

@ -0,0 +1,286 @@
/*
Copyright 2001, 2002 Georges Menie (www.menie.org)
stdarg version contributed by Christian Ettinger
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*
putchar is the only external dependency for this file,
if you have a working putchar, leave it commented out.
If not, uncomment the define below and
replace outbyte(c) by your own function call.
#define putchar(c) outbyte(c)
*/
#include <stdarg.h>
static void printchar(char **str, int c)
{
extern int putchar(int c);
if (str) {
**str = c;
++(*str);
}
else (void)putchar(c);
}
#define PAD_RIGHT 1
#define PAD_ZERO 2
static int prints(char **out, const char *string, int width, int pad)
{
register int pc = 0, padchar = ' ';
if (width > 0) {
register int len = 0;
register const char *ptr;
for (ptr = string; *ptr; ++ptr) ++len;
if (len >= width) width = 0;
else width -= len;
if (pad & PAD_ZERO) padchar = '0';
}
if (!(pad & PAD_RIGHT)) {
for ( ; width > 0; --width) {
printchar (out, padchar);
++pc;
}
}
for ( ; *string ; ++string) {
printchar (out, *string);
++pc;
}
for ( ; width > 0; --width) {
printchar (out, padchar);
++pc;
}
return pc;
}
/* the following should be enough for 32 bit int */
#define PRINT_BUF_LEN 12
static int printi(char **out, int i, int b, int sg, int width, int pad, int letbase)
{
char print_buf[PRINT_BUF_LEN];
register char *s;
register int t, neg = 0, pc = 0;
register unsigned int u = i;
if (i == 0) {
print_buf[0] = '0';
print_buf[1] = '\0';
return prints (out, print_buf, width, pad);
}
if (sg && b == 10 && i < 0) {
neg = 1;
u = -i;
}
s = print_buf + PRINT_BUF_LEN-1;
*s = '\0';
while (u) {
t = u % b;
if( t >= 10 )
t += letbase - '0' - 10;
*--s = t + '0';
u /= b;
}
if (neg) {
if( width && (pad & PAD_ZERO) ) {
printchar (out, '-');
++pc;
--width;
}
else {
*--s = '-';
}
}
return pc + prints (out, s, width, pad);
}
static int print( char **out, const char *format, va_list args )
{
register int width, pad;
register int pc = 0;
char scr[2];
for (; *format != 0; ++format) {
if (*format == '%') {
++format;
width = pad = 0;
if (*format == '\0') break;
if (*format == '%') goto out;
if (*format == '-') {
++format;
pad = PAD_RIGHT;
}
while (*format == '0') {
++format;
pad |= PAD_ZERO;
}
for ( ; *format >= '0' && *format <= '9'; ++format) {
width *= 10;
width += *format - '0';
}
if( *format == 's' ) {
register char *s = (char *)va_arg( args, int );
pc += prints (out, s?s:"(null)", width, pad);
continue;
}
if( *format == 'd' ) {
pc += printi (out, va_arg( args, int ), 10, 1, width, pad, 'a');
continue;
}
if( *format == 'x' ) {
pc += printi (out, va_arg( args, int ), 16, 0, width, pad, 'a');
continue;
}
if( *format == 'X' ) {
pc += printi (out, va_arg( args, int ), 16, 0, width, pad, 'A');
continue;
}
if( *format == 'u' ) {
pc += printi (out, va_arg( args, int ), 10, 0, width, pad, 'a');
continue;
}
if( *format == 'c' ) {
/* char are converted to int then pushed on the stack */
scr[0] = (char)va_arg( args, int );
scr[1] = '\0';
pc += prints (out, scr, width, pad);
continue;
}
}
else {
out:
printchar (out, *format);
++pc;
}
}
if (out) **out = '\0';
va_end( args );
return pc;
}
int printf(const char *format, ...)
{
va_list args;
va_start( args, format );
return print( 0, format, args );
}
int sprintf(char *out, const char *format, ...)
{
va_list args;
va_start( args, format );
return print( &out, format, args );
}
int snprintf( char *buf, unsigned int count, const char *format, ... )
{
va_list args;
( void ) count;
va_start( args, format );
return print( &buf, format, args );
}
#ifdef TEST_PRINTF
int main(void)
{
char *ptr = "Hello world!";
char *np = 0;
int i = 5;
unsigned int bs = sizeof(int)*8;
int mi;
char buf[80];
mi = (1 << (bs-1)) + 1;
printf("%s\n", ptr);
printf("printf test\n");
printf("%s is null pointer\n", np);
printf("%d = 5\n", i);
printf("%d = - max int\n", mi);
printf("char %c = 'a'\n", 'a');
printf("hex %x = ff\n", 0xff);
printf("hex %02x = 00\n", 0);
printf("signed %d = unsigned %u = hex %x\n", -3, -3, -3);
printf("%d %s(s)%", 0, "message");
printf("\n");
printf("%d %s(s) with %%\n", 0, "message");
sprintf(buf, "justif: \"%-10s\"\n", "left"); printf("%s", buf);
sprintf(buf, "justif: \"%10s\"\n", "right"); printf("%s", buf);
sprintf(buf, " 3: %04d zero padded\n", 3); printf("%s", buf);
sprintf(buf, " 3: %-4d left justif.\n", 3); printf("%s", buf);
sprintf(buf, " 3: %4d right justif.\n", 3); printf("%s", buf);
sprintf(buf, "-3: %04d zero padded\n", -3); printf("%s", buf);
sprintf(buf, "-3: %-4d left justif.\n", -3); printf("%s", buf);
sprintf(buf, "-3: %4d right justif.\n", -3); printf("%s", buf);
return 0;
}
/*
* if you compile this file with
* gcc -Wall $(YOUR_C_OPTIONS) -DTEST_PRINTF -c printf.c
* you will get a normal warning:
* printf.c:214: warning: spurious trailing `%' in format
* this line is testing an invalid % at the end of the format string.
*
* this should display (on 32bit int machine) :
*
* Hello world!
* printf test
* (null) is null pointer
* 5 = 5
* -2147483647 = - max int
* char a = 'a'
* hex ff = ff
* hex 00 = 00
* signed -3 = unsigned 4294967293 = hex fffffffd
* 0 message(s)
* 0 message(s) with %
* justif: "left "
* justif: " right"
* 3: 0003 zero padded
* 3: 3 left justif.
* 3: 3 right justif.
* -3: -003 zero padded
* -3: -3 left justif.
* -3: -3 right justif.
*/
#endif
/* To keep linker happy. */
int write( int i, char* c, int n)
{
return 0;
}

44
Demo/MB91460_Softune/SRC/utility/taskutility.c
View file

@ -10,7 +10,7 @@
#include "vectors.h"
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
#include "queue.h"
static void vUART5Task( void *pvParameters );
@ -18,7 +18,8 @@ const char ASCII[] = "0123456789ABCDEF";
void vInitUart5( void );
xSemaphoreHandle xSemaphore;
static xQueueHandle xQueue;
void vInitUart5( void )
{
@ -65,7 +66,7 @@ void Puts5( const char *Name5 ) /* Puts a String to UART */
volatile portSHORT i, len;
len = strlen( Name5 );
for( i = 0; i < strlen(Name5); i++ ) /* go through string */
for( i = 0; i < len; i++ ) /* go through string */
{
if( Name5[i] == 10 )
{
@ -124,25 +125,26 @@ void Putdec5( unsigned long x, int digits )
void vUtilityStartTraceTask( unsigned portBASE_TYPE uxPriority )
{
portENTER_CRITICAL();
vInitUart5();
portENTER_CRITICAL();
xQueue = xQueueCreate( 5, sizeof( char ) );
vSemaphoreCreateBinary( xSemaphore );
if( xSemaphore != NULL )
if( xQueue != NULL )
{
xTaskCreate( vUART5Task, (signed portCHAR *) "UART4", ( unsigned portSHORT ) 2048, ( void * ) NULL, uxPriority, NULL );
portENTER_CRITICAL();
vInitUart5();
portENTER_CRITICAL();
xTaskCreate( vUART5Task, (signed portCHAR *) "UART5", configMINIMAL_STACK_SIZE * 2, ( void * ) NULL, uxPriority, NULL );
}
}
static void vUART5Task( void *pvParameters )
{
portCHAR tasklist_buff[512], trace_buff[512];
static portCHAR buff[ 900 ] = { 0 };
unsigned portLONG trace_len, j;
unsigned portCHAR ch;
SSR05_RIE = 1;
Puts5( "\n -------------MB91467D FreeRTOS DEMO Task List and Trace Utility----------- \n" );
for( ;; )
@ -153,28 +155,24 @@ static void vUART5Task( void *pvParameters )
Puts5( "\n\r2: To call vTaskStartTrace() and to display trace results once the trace ends" );
SSR05_RIE = 1;
/* Block on the semaphore. The UART interrupt will use the semaphore to
wake this task when required. */
xSemaphoreTake( xSemaphore, portMAX_DELAY );
ch = Getch5();
xQueueReceive( xQueue, &ch, portMAX_DELAY );
switch( ch )
{
case '1':
vTaskList( (signed char *) tasklist_buff );
vTaskList( (signed char *) buff );
Puts5( "\n\rThe current task list is as follows...." );
Puts5( "\n\r----------------------------------------------" );
Puts5( "\n\rName State Priority Stack Number" );
Puts5( "\n\r----------------------------------------------" );
Puts5( tasklist_buff );
Puts5( buff );
Puts5( "\r----------------------------------------------" );
break;
case '2':
vTaskStartTrace( (signed char *) trace_buff, 512 );
vTaskStartTrace( (signed char *) buff, 512 );
Puts5( "\n\rThe trace started!!" );
vTaskDelay( (portTickType) 450 );
trace_len = ulTaskEndTrace();
@ -185,7 +183,7 @@ static void vUART5Task( void *pvParameters )
Puts5( "\n\r--------------------------------------------------------\n\r" );
for( j = 0; j < trace_len; j++ )
{
Puthex5( trace_buff[j], 2 );
Puthex5( buff[j], 2 );
if( j % 4 == 3 )
{
Puts5( " | " );
@ -210,6 +208,8 @@ static void vUART5Task( void *pvParameters )
__interrupt void UART5_RxISR( void )
{
SSR05_RIE = 0;
xSemaphoreGiveFromISR( xSemaphore, pdFALSE );
unsigned portCHAR ch;
ch = RDR05;
xQueueSendFromISR( xQueue, &ch, pdFALSE );
}