From 64518905955e0ebebc83879c756c138c7d4047b2 Mon Sep 17 00:00:00 2001 From: richardbarry Date: Wed, 20 Apr 2011 09:09:25 +0000 Subject: [PATCH] Complete the commenting for main-blinky.c in the A2F demo project. git-svn-id: https://svn.code.sf.net/p/freertos/code/trunk@1367 1d2547de-c912-0410-9cb9-b8ca96c0e9e2 --- Demo/CORTEX_A2F200_SoftConsole/main-blinky.c | 108 +++---- .../CORTEX_A2F200_SoftConsole/printf-stdarg.c | 293 ++++++++++++++++++ 2 files changed, 349 insertions(+), 52 deletions(-) create mode 100644 Demo/CORTEX_A2F200_SoftConsole/printf-stdarg.c diff --git a/Demo/CORTEX_A2F200_SoftConsole/main-blinky.c b/Demo/CORTEX_A2F200_SoftConsole/main-blinky.c index d954ff71a..3c578c21b 100644 --- a/Demo/CORTEX_A2F200_SoftConsole/main-blinky.c +++ b/Demo/CORTEX_A2F200_SoftConsole/main-blinky.c @@ -52,55 +52,54 @@ */ /* -* This simple demo project runs on the STM32 Discovery board, which is -* populated with an STM32F100RB Cortex-M3 microcontroller. The discovery board -* makes an ideal low cost evaluation platform, but the 8K of RAM provided on the -* STM32F100RB does not allow the simple application to demonstrate all of all the -* FreeRTOS kernel features. Therefore, this simple demo only actively -* demonstrates task, queue, timer and interrupt functionality. In addition, the -* demo is configured to include malloc failure, idle and stack overflow hook -* functions. -* -* The idle hook function: -* The idle hook function queries the amount of FreeRTOS heap space that is -* remaining (see vApplicationIdleHook() defined in this file). The demo -* application is configured use 7K or the available 8K of RAM as the FreeRTOS heap. -* Memory is only allocated from this heap during initialisation, and this demo -* only actually uses 1.6K bytes of the configured 7K available - leaving 5.4K -* bytes of heap space unallocated. -* -* The main() Function: -* main() creates one software timer, one queue, and two tasks. It then starts the -* scheduler. -* -* The Queue Send Task: -* The queue send task is implemented by the prvQueueSendTask() function in this -* file. prvQueueSendTask() sits in a loop that causes it to repeatedly block for -* 200 milliseconds, before sending the value 100 to the queue that was created -* within main(). Once the value is sent, the task loops back around to block for -* another 200 milliseconds. -* -* The Queue Receive Task: -* The queue receive task is implemented by the prvQueueReceiveTask() function -* in this file. prvQueueReceiveTask() sits in a loop that causes repeatedly -* attempt to read data from the queue that was created within main(). When data -* is received, the task checks the value of the data, and if the value equals -* the expected 100, toggles the green LED. The 'block time' parameter passed to -* the queue receive function specifies that the task should be held in the Blocked -* state indefinitely to wait for data to be available on the queue. The queue -* receive task will only leave the Blocked state when the queue send task writes -* to the queue. As the queue send task writes to the queue every 200 -* milliseconds, the queue receive task leaves the Blocked state every 200 -* milliseconds, and therefore toggles the green LED every 200 milliseconds. -* -* The LED Software Timer and the Button Interrupt: -* The user button B1 is configured to generate an interrupt each time it is -* pressed. The interrupt service routine switches the red LED on, and resets the -* LED software timer. The LED timer has a 5000 millisecond (5 second) period, and -* uses a callback function that is defined to just turn the red LED off. -* Therefore, pressing the user button will turn the red LED on, and the LED will -* remain on until a full five seconds pass without the button being pressed. -*/ + * main-blinky.c is included when the "Blinky" build configuration is used. + * main-full.c is included when the "Full" build configuration is used. + * + * main-blinky.c (this file) defines a very simple demo that creates two tasks, + * one queue, and one timer. It also demonstrates how Cortex-M3 interrupts can + * interact with FreeRTOS tasks/timers. + * + * This simple demo project runs on the SmartFusion A2F-EVAL-KIT evaluation + * board, which is populated with an A2F200M3F SmartFusion mixed signal FPGA. + * The A2F200M3F incorporates a Cortex-M3 microcontroller. + * + * The idle hook function: + * The idle hook function demonstrates how to query the amount of FreeRTOS heap + * space that is remaining (see vApplicationIdleHook() defined in this file). + * + * The main() Function: + * main() creates one software timer, one queue, and two tasks. It then starts + * the scheduler. + * + * The Queue Send Task: + * The queue send task is implemented by the prvQueueSendTask() function in + * this file. prvQueueSendTask() sits in a loop that causes it to repeatedly + * block for 200 milliseconds, before sending the value 100 to the queue that + * was created within main(). Once the value is sent, the task loops back + * around to block for another 200 milliseconds. + * + * The Queue Receive Task: + * The queue receive task is implemented by the prvQueueReceiveTask() function + * in this file. prvQueueReceiveTask() sits in a loop that causes it to + * repeatedly attempt to read data from the queue that was created within + * main(). When data is received, the task checks the value of the data, and + * if the value equals the expected 100, toggles the green LED. The 'block + * time' parameter passed to the queue receive function specifies that the task + * should be held in the Blocked state indefinitely to wait for data to be + * available on the queue. The queue receive task will only leave the Blocked + * state when the queue send task writes to the queue. As the queue send task + * writes to the queue every 200 milliseconds, the queue receive task leaves + * the Blocked state every 200 milliseconds, and therefore toggles the LED + * every 200 milliseconds. + * + * The LED Software Timer and the Button Interrupt: + * The user button SW1 is configured to generate an interrupt each time it is + * pressed. The interrupt service routine switches an LED on, and resets the + * LED software timer. The LED timer has a 5000 millisecond (5 second) period, + * and uses a callback function that is defined to just turn the LED off again. + * Therefore, pressing the user button will turn the LED on, and the LED will + * remain on until a full five seconds pass without the button being pressed. + */ /* Kernel includes. */ #include "FreeRTOS.h" @@ -126,8 +125,12 @@ will remove items as they are added, meaning the send task should always find the queue empty. */ #define mainQUEUE_LENGTH ( 1 ) +/* The LED toggle by the queue receive task. */ #define mainTASK_CONTROLLED_LED 0x01UL + +/* The LED turned on by the button interrupt, and turned off by the LED timer. */ #define mainTIMER_CONTROLLED_LED 0x02UL + /*-----------------------------------------------------------*/ /* @@ -142,8 +145,8 @@ static void prvQueueReceiveTask( void *pvParameters ); static void prvQueueSendTask( void *pvParameters ); /* - * The LED timer callback function. This does nothing but switch the red LED - * off. + * The LED timer callback function. This does nothing but switch off the + * LED defined by the mainTIMER_CONTROLLED_LED constant. */ static void vLEDTimerCallback( xTimerHandle xTimer ); @@ -156,7 +159,8 @@ static xQueueHandle xQueue = NULL; function. */ static xTimerHandle xLEDTimer = NULL; -volatile unsigned long ulGPIOState = 0UL; +/* Maintains the current LED output state. */ +static volatile unsigned long ulGPIOState = 0UL; /*-----------------------------------------------------------*/ diff --git a/Demo/CORTEX_A2F200_SoftConsole/printf-stdarg.c b/Demo/CORTEX_A2F200_SoftConsole/printf-stdarg.c new file mode 100644 index 000000000..b5ac41be7 --- /dev/null +++ b/Demo/CORTEX_A2F200_SoftConsole/printf-stdarg.c @@ -0,0 +1,293 @@ +/* + 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) c + +#include + +static void printchar(char **str, int c) +{ + //extern int putchar(int c); + + if (str) { + **str = (char)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 = (unsigned int)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 = (unsigned int)-i; + } + + s = print_buf + PRINT_BUF_LEN-1; + *s = '\0'; + + while (u) { + t = (unsigned int)u % b; + if( t >= 10 ) + t += letbase - '0' - 10; + *--s = (char)(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) +{ + (void)i; + (void)n; + (void)c; + return 0; +} + -- 2.39.5