begriffs open source - freertos/blob - Demo/Common/Utils/CommandInterpreter.c

   1 /*\r
   2     FreeRTOS V7.1.0 - Copyright (C) 2011 Real Time Engineers Ltd.\r
   3         \r
   4 \r
   5     ***************************************************************************\r
   6      *                                                                       *\r
   7      *    FreeRTOS tutorial books are available in pdf and paperback.        *\r
   8      *    Complete, revised, and edited pdf reference manuals are also       *\r
   9      *    available.                                                         *\r
  10      *                                                                       *\r
  11      *    Purchasing FreeRTOS documentation will not only help you, by       *\r
  12      *    ensuring you get running as quickly as possible and with an        *\r
  13      *    in-depth knowledge of how to use FreeRTOS, it will also help       *\r
  14      *    the FreeRTOS project to continue with its mission of providing     *\r
  15      *    professional grade, cross platform, de facto standard solutions    *\r
  16      *    for microcontrollers - completely free of charge!                  *\r
  17      *                                                                       *\r
  18      *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *\r
  19      *                                                                       *\r
  20      *    Thank you for using FreeRTOS, and thank you for your support!      *\r
  21      *                                                                       *\r
  22     ***************************************************************************\r
  23 \r
  24 \r
  25     This file is part of the FreeRTOS distribution.\r
  26 \r
  27     FreeRTOS is free software; you can redistribute it and/or modify it under\r
  28     the terms of the GNU General Public License (version 2) as published by the\r
  29     Free Software Foundation AND MODIFIED BY the FreeRTOS exception.\r
  30     >>>NOTE<<< The modification to the GPL is included to allow you to\r
  31     distribute a combined work that includes FreeRTOS without being obliged to\r
  32     provide the source code for proprietary components outside of the FreeRTOS\r
  33     kernel.  FreeRTOS is distributed in the hope that it will be useful, but\r
  34     WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\r
  35     or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for\r
  36     more details. You should have received a copy of the GNU General Public\r
  37     License and the FreeRTOS license exception along with FreeRTOS; if not it\r
  38     can be viewed here: http://www.freertos.org/a00114.html and also obtained\r
  39     by writing to Richard Barry, contact details for whom are available on the\r
  40     FreeRTOS WEB site.\r
  41 \r
  42     1 tab == 4 spaces!\r
  43 \r
  44     http://www.FreeRTOS.org - Documentation, latest information, license and\r
  45     contact details.\r
  46 \r
  47     http://www.SafeRTOS.com - A version that is certified for use in safety\r
  48     critical systems.\r
  49 \r
  50     http://www.OpenRTOS.com - Commercial support, development, porting,\r
  51     licensing and training services.\r
  52 */\r
  53 \r
  54 /* Standard includes. */\r
  55 #include <string.h>\r
  56 \r
  57 /* FreeRTOS includes. */\r
  58 #include "FreeRTOS.h"\r
  59 #include "task.h"\r
  60 \r
  61 /* Utils includes. */\r
  62 #include "CommandInterpreter.h"\r
  63 \r
  64 typedef struct xCOMMAND_INPUT_LIST\r
  65 {\r
  66         const xCommandLineInput *pxCommandLineDefinition;\r
  67         struct xCOMMAND_INPUT_LIST *pxNext;\r
  68 } xCommandLineInputListItem;\r
  69 \r
  70 /*\r
  71  * The callback function that is executed when "help" is entered.  This is the\r
  72  * only default command that is always present.\r
  73  */\r
  74 static portBASE_TYPE prvHelpCommand( signed char *pcWriteBuffer, size_t xWriteBufferLen, const signed char *pcCommandString );\r
  75 \r
  76 /*\r
  77  * Return the number of parameters that follow the command name.\r
  78  */\r
  79 static signed char prvGetNumberOfParameters( const signed char * pcCommandString );\r
  80 \r
  81 /* The definition of the "help" command.  This command is always at the front\r
  82 of the list of registered commands. */\r
  83 static const xCommandLineInput xHelpCommand = \r
  84 {\r
  85         ( const signed char * const ) "help",\r
  86         ( const signed char * const ) "help: Lists all the registered commands\r\n",\r
  87         prvHelpCommand,\r
  88         0\r
  89 };\r
  90 \r
  91 /* The definition of the list of commands.  Commands that are registered are\r
  92 added to this list. */\r
  93 static xCommandLineInputListItem xRegisteredCommands =\r
  94 {       \r
  95         &xHelpCommand,  /* The first command in the list is always the help command, defined in this file. */\r
  96         NULL                    /* The next pointer is initialised to NULL, as there are no other registered commands yet. */\r
  97 };\r
  98 \r
  99 /* A buffer into which command outputs can be written is declared here, rather\r
 100 than in the command console implementation, to allow multiple command consoles\r
 101 to share the same buffer.  For example, an application may allow access to the\r
 102 command interpreter by UART and by Ethernet.  Sharing a buffer is done purely\r
 103 to save RAM.  Note, however, that the command console itself is not re-entrant,\r
 104 so only one command interpreter interface can be used at any one time.  For that\r
 105 reason, no attempt at providing mutual exclusion to the cOutputBuffer array is\r
 106 attempted. */\r
 107 static signed char cOutputBuffer[ configCOMMAND_INT_MAX_OUTPUT_SIZE ];\r
 108 \r
 109 /*-----------------------------------------------------------*/\r
 110 \r
 111 portBASE_TYPE xCmdIntRegisterCommand( const xCommandLineInput * const pxCommandToRegister )\r
 112 {\r
 113 static xCommandLineInputListItem *pxLastCommandInList = &xRegisteredCommands;\r
 114 xCommandLineInputListItem *pxNewListItem;\r
 115 portBASE_TYPE xReturn = pdFAIL;\r
 116 \r
 117         /* Check the parameter is not NULL. */\r
 118         configASSERT( pxCommandToRegister );\r
 119 \r
 120         /* Create a new list item that will reference the command being registered. */\r
 121         pxNewListItem = ( xCommandLineInputListItem * ) pvPortMalloc( sizeof( xCommandLineInputListItem ) );\r
 122         configASSERT( pxNewListItem );\r
 123 \r
 124         if( pxNewListItem != NULL )\r
 125         {\r
 126                 taskENTER_CRITICAL();\r
 127                 {\r
 128                         /* Reference the command being registered from the newly created \r
 129                         list item. */\r
 130                         pxNewListItem->pxCommandLineDefinition = pxCommandToRegister;\r
 131 \r
 132                         /* The new list item will get added to the end of the list, so \r
 133                         pxNext has nowhere to point. */\r
 134                         pxNewListItem->pxNext = NULL;\r
 135 \r
 136                         /* Add the newly created list item to the end of the already existing\r
 137                         list. */\r
 138                         pxLastCommandInList->pxNext = pxNewListItem;\r
 139 \r
 140                         /* Set the end of list marker to the new list item. */\r
 141                         pxLastCommandInList = pxNewListItem;\r
 142                 }\r
 143                 taskEXIT_CRITICAL();\r
 144                 \r
 145                 xReturn = pdPASS;\r
 146         }\r
 147 \r
 148         return xReturn;\r
 149 }\r
 150 /*-----------------------------------------------------------*/\r
 151 \r
 152 portBASE_TYPE xCmdIntProcessCommand( const signed char * const pcCommandInput, signed char * pcWriteBuffer, size_t xWriteBufferLen  )\r
 153 {\r
 154 static const xCommandLineInputListItem *pxCommand = NULL;\r
 155 portBASE_TYPE xReturn = pdTRUE;\r
 156 const signed char *pcRegisteredCommandString;\r
 157 \r
 158         /* Note:  This function is not re-entrant.  It must not be called from more\r
 159         thank one task. */\r
 160 \r
 161         if( pxCommand == NULL )\r
 162         {\r
 163                 /* Search for the command string in the list of registered commands. */\r
 164                 for( pxCommand = &xRegisteredCommands; pxCommand != NULL; pxCommand = pxCommand->pxNext )\r
 165                 {\r
 166                         pcRegisteredCommandString = pxCommand->pxCommandLineDefinition->pcCommand;\r
 167                         if( strncmp( ( const char * ) pcCommandInput, ( const char * ) pcRegisteredCommandString, strlen( ( const char * ) pcRegisteredCommandString ) ) == 0 )\r
 168                         {\r
 169                                 /* The command has been found.  Check it has the expected\r
 170                                 number of parameters.  If cExpectedNumberOfParameters is -1,\r
 171                                 then there could be a variable number of parameters and no\r
 172                                 check is made. */\r
 173                                 if( pxCommand->pxCommandLineDefinition->cExpectedNumberOfParameters >= 0 )\r
 174                                 {\r
 175                                         if( prvGetNumberOfParameters( pcCommandInput ) != pxCommand->pxCommandLineDefinition->cExpectedNumberOfParameters )\r
 176                                         {\r
 177                                                 xReturn = pdFALSE;\r
 178                                         }\r
 179                                 }\r
 180 \r
 181                                 break;\r
 182                         }\r
 183                 }\r
 184         }\r
 185 \r
 186         if( ( pxCommand != NULL ) && ( xReturn == pdFALSE ) )\r
 187         {\r
 188                 /* The command was found, but the number of parameters with the command\r
 189                 was incorrect. */\r
 190                 strncpy( ( char * ) pcWriteBuffer, "Incorrect command parameter(s).  Enter \"help\" to view a list of available commands.\r\n\r\n", xWriteBufferLen );\r
 191                 pxCommand = NULL;\r
 192         }\r
 193         else if( pxCommand != NULL )\r
 194         {\r
 195                 /* Call the callback function that is registered to this command. */\r
 196                 xReturn = pxCommand->pxCommandLineDefinition->pxCommandInterpreter( pcWriteBuffer, xWriteBufferLen, pcCommandInput );\r
 197 \r
 198                 /* If xReturn is pdFALSE, then no further strings will be returned\r
 199                 after this one, and     pxCommand can be reset to NULL ready to search \r
 200                 for the next entered command. */\r
 201                 if( xReturn == pdFALSE )\r
 202                 {\r
 203                         pxCommand = NULL;\r
 204                 }\r
 205         }\r
 206         else\r
 207         {\r
 208                 /* pxCommand was NULL, the command was not found. */\r
 209                 strncpy( ( char * ) pcWriteBuffer, ( const char * const ) "Command not recognised.  Enter \"help\" to view a list of available commands.\r\n\r\n", xWriteBufferLen );\r
 210                 xReturn = pdFALSE;\r
 211         }\r
 212 \r
 213         return xReturn;\r
 214 }\r
 215 /*-----------------------------------------------------------*/\r
 216 \r
 217 signed char *pcCmdIntGetOutputBuffer( void )\r
 218 {\r
 219         return cOutputBuffer;\r
 220 }\r
 221 /*-----------------------------------------------------------*/\r
 222 \r
 223 unsigned portBASE_TYPE uxCmdIntGetOutputBufferSizeBytes( void )\r
 224 {\r
 225         return configCOMMAND_INT_MAX_OUTPUT_SIZE;\r
 226 }\r
 227 /*-----------------------------------------------------------*/\r
 228 \r
 229 const signed char *pcCmdIntGetParameter( const signed char *pcCommandString, unsigned portBASE_TYPE uxWantedParameter, portBASE_TYPE *pxParameterStringLength )\r
 230 {\r
 231 unsigned portBASE_TYPE uxParametersFound = 0;\r
 232 const signed char *pcReturn = NULL;\r
 233 \r
 234         *pxParameterStringLength = 0;\r
 235 \r
 236         while( uxParametersFound < uxWantedParameter )\r
 237         {\r
 238                 /* Index the character pointer past the current word.  If this is the start\r
 239                 of the command string then the first word is the command itself. */\r
 240                 while( ( ( *pcCommandString ) != 0x00 ) && ( ( *pcCommandString ) != ' ' ) )\r
 241                 {\r
 242                         pcCommandString++;\r
 243                 }\r
 244 \r
 245                 /* Find the start of the next string. */\r
 246                 while( ( ( *pcCommandString ) != 0x00 ) && ( ( *pcCommandString ) == ' ' ) )\r
 247                 {\r
 248                         pcCommandString++;\r
 249                 }\r
 250 \r
 251                 /* Was a string found? */\r
 252                 if( *pcCommandString != 0x00 )\r
 253                 {\r
 254                         /* Is this the start of the required parameter? */\r
 255                         uxParametersFound++;\r
 256 \r
 257                         if( uxParametersFound == uxWantedParameter )\r
 258                         {\r
 259                                 /* How long is the parameter? */\r
 260                                 pcReturn = pcCommandString;\r
 261                                 while( ( ( *pcCommandString ) != 0x00 ) && ( ( *pcCommandString ) != ' ' ) )\r
 262                                 {\r
 263                                         ( *pxParameterStringLength )++;\r
 264                                         pcCommandString++;\r
 265                                 }\r
 266 \r
 267                                 break;\r
 268                         }\r
 269                 }\r
 270                 else\r
 271                 {\r
 272                         break;\r
 273                 }\r
 274         }\r
 275 \r
 276         return pcReturn;\r
 277 }\r
 278 /*-----------------------------------------------------------*/\r
 279 \r
 280 static portBASE_TYPE prvHelpCommand( signed char *pcWriteBuffer, size_t xWriteBufferLen, const signed char *pcCommandString )\r
 281 {\r
 282 static const xCommandLineInputListItem * pxCommand = NULL;\r
 283 signed portBASE_TYPE xReturn;\r
 284 \r
 285         ( void ) pcCommandString;\r
 286 \r
 287         if( pxCommand == NULL )\r
 288         {\r
 289                 /* Reset the pxCommand pointer back to the start of the list. */\r
 290                 pxCommand = &xRegisteredCommands;\r
 291         }\r
 292 \r
 293         /* Return the next command help string, before moving the pointer on to\r
 294         the next command in the list. */\r
 295         strncpy( ( char * ) pcWriteBuffer, ( const char * ) pxCommand->pxCommandLineDefinition->pcHelpString, xWriteBufferLen );\r
 296         pxCommand = pxCommand->pxNext;\r
 297 \r
 298         if( pxCommand == NULL )\r
 299         {\r
 300                 /* There are no more commands in the list, so there will be no more\r
 301                 strings to return after this one and pdFALSE should be returned. */\r
 302                 xReturn = pdFALSE;\r
 303         }\r
 304         else\r
 305         {\r
 306                 xReturn = pdTRUE;\r
 307         }\r
 308 \r
 309         return xReturn;\r
 310 }\r
 311 /*-----------------------------------------------------------*/\r
 312 \r
 313 static signed char prvGetNumberOfParameters( const signed char * pcCommandString )\r
 314 {\r
 315 signed char cParameters = 0;\r
 316 portBASE_TYPE xLastCharacterWasSpace = pdFALSE;\r
 317 \r
 318         /* Count the number of space delimited words in pcCommandString. */\r
 319         while( *pcCommandString != 0x00 )\r
 320         {\r
 321                 if( ( *pcCommandString ) == ' ' )\r
 322                 {\r
 323                         if( xLastCharacterWasSpace != pdTRUE )\r
 324                         {\r
 325                                 cParameters++;\r
 326                                 xLastCharacterWasSpace = pdTRUE;\r
 327                         }\r
 328                 }\r
 329                 else\r
 330                 {\r
 331                         xLastCharacterWasSpace = pdFALSE;\r
 332                 }\r
 333 \r
 334                 pcCommandString++;\r
 335         }\r
 336 \r
 337         /* The value returned is one less than the number of space delimited words,\r
 338         as the first word should be the command itself. */\r
 339         return cParameters;\r
 340 }\r
 341 \r