shell.c File Reference


Detailed Description

AVR32 UC3 Control Panel Command Exec module.

This module provides a Command execution service.

Author:
Atmel Corporation: http://www.atmel.com
Support and FAQ: http://support.atmel.no/

Definition in file shell.c.

#include <string.h>
#include "compiler.h"
#include "board.h"
#include "shell.h"
#include "sensor.h"
#include "actuator.h"
#include "fscmds.h"
#include "syscmds.h"
#include "supervisor.h"
#include "tracedump.h"
#include "ethernet.h"
#include "usbsys.h"
#include "com1shell.h"

Go to the source code of this file.

Data Structures

struct  st_cmd_registration

Defines

#define SHELL_FS_FIRSTCMDIDX   9
#define SHELL_FS_LASTCMDIDX   29
#define SHELL_MAX_NBTOKEN   8
#define SHELL_NB_COMMANDS   35

Typedefs

typedef struct st_cmd_registration Cmd_registration

Enumerations

enum  eCmdStatus { SHELL_CMDSTATUS_FOUND, SHELL_CMDSTATUS_NOTFOUND, SHELL_CMDSTATUS_PERMISSIONDENIED }

Functions

static eExecStatus e_Shell_help (eModId xModId, signed short FsNavId, int ac, signed portCHAR *av[], signed portCHAR **ppcStringReply)
 The help command: displays all available commands. Format: help.
eExecStatus e_supervisor_switch_to_maintenance_mode (eModId xModId, signed short FsNavId, int ac, signed portCHAR *av[], signed portCHAR **ppcStringReply)
 The switch-to-maintenance-mode command: initiate the process to
switch to maintenance mode. Format: maintain.
static eCmdStatus prvCmdIdentify_Tokenize (signed portCHAR *pcStringCmd, eModId xModId, portBASE_TYPE *ac, signed portCHAR **av, portBASE_TYPE *pCmdIdx)
 Identify the cmd and tokenize the rest of the command line string.
eExecStatus Shell_exec (signed portCHAR *pcStringCmd, eModId xModId, signed short FsNavId, signed portCHAR **ppcStringReply)
 a command line executor.
void v_shell_Print_String_To_Requester_Stream (eModId xModId, const signed portCHAR *pcStringToDisplay)
 Print a string directly to the output stream of a module.

Variables

Cmd_registration a_cmd_registration [SHELL_NB_COMMANDS]
static portBASE_TYPE PrevCmdAc
signed portCHAR * PrevCmdAv [SHELL_MAX_NBTOKEN]
static portBASE_TYPE PrevCmdIdx = -1
const signed portCHAR *const SHELL_ERRMSG_HELP_SYNTAXERROR = (signed portCHAR *)"Error"CRLF"Usage: help [sensor,actuator,sys,fs]"CRLF
const signed portCHAR *const SHELL_MSG_CMDNOTFOUND = (signed portCHAR *)"Error"CRLF"Command not found"CRLF
const signed portCHAR *const SHELL_MSG_HELP = (signed portCHAR *)"Commands summary"CRLF"help"CRLF"!!: execute the previous command"CRLF
const signed portCHAR *const SHELL_MSG_NOHISTORY = (signed portCHAR *)"Error"CRLF"No previous command"CRLF
const signed portCHAR *const SHELL_MSG_PERMISSIONDENIED = (signed portCHAR *)"Error"CRLF"Permission denied"CRLF
const signed portCHAR *const SHELL_MSG_SYNTAXERROR = (signed portCHAR *)"Error"CRLF"Syntax error"CRLF
xSemaphoreHandle xSHELLFSMutex


Define Documentation

#define SHELL_FS_FIRSTCMDIDX   9

First file system cmd idx in the a_cmd_registration[] array.

Definition at line 99 of file shell.c.

Referenced by Shell_exec().

#define SHELL_FS_LASTCMDIDX   29

Last file system cmd idx in the a_cmd_registration[] array.

Definition at line 102 of file shell.c.

Referenced by Shell_exec().

#define SHELL_MAX_NBTOKEN   8

Brief description of the module. This module is a central point for commands execution.

Detailled description of the module. It proposes only one interface function, Shell_exec(). This function parses a command line string to: 1) identify the command 2) verify that the caller has the right to execute the command 3) tokenize all arguments of the command If the command has been found, and the caller has the right to execute it, the command is executed. The command execution is managed by the target module. Target modules are: sensor, actuator, filesys, supervisor.

The input command line string must have the following format: cmd [arg[=val]], 5 (arg,val) maximum.

Max number of tokens

Definition at line 89 of file shell.c.

Referenced by prvCmdIdentify_Tokenize(), and Shell_exec().

#define SHELL_NB_COMMANDS   35

Number of registered commands.

Definition at line 95 of file shell.c.

Referenced by prvCmdIdentify_Tokenize().


Typedef Documentation


Enumeration Type Documentation

enum eCmdStatus

The cmd status enum.

Enumerator:
SHELL_CMDSTATUS_FOUND 
SHELL_CMDSTATUS_NOTFOUND 
SHELL_CMDSTATUS_PERMISSIONDENIED 

Definition at line 119 of file shell.c.

00119              {
00120    SHELL_CMDSTATUS_FOUND,              // All commands.
00121    SHELL_CMDSTATUS_NOTFOUND,           // Cmd not found.
00122    SHELL_CMDSTATUS_PERMISSIONDENIED,   // Cmd not found.
00123 } eCmdStatus;


Function Documentation

static eExecStatus e_Shell_help ( eModId  xModId,
signed short  FsNavId,
int  ac,
signed portCHAR *  av[],
signed portCHAR **  ppcStringReply 
) [static]

The help command: displays all available commands. Format: help.

Note:
This function must be of the type pfShellCmd defined by the shell module.
Parameters:
xModId Input. The module that is calling this exe function.
FsNavId Input. The file system navigator id to use if the cmd is a file system command. NOT USED.
ac Input. The argument counter. Not considered for this command.
av Input. The argument vector. Not considered for this command.
ppcStringReply Input/Output. The response string. If Input is NULL, no response string will be output. Else a malloc for the response string is performed here; the caller must free this string.
Returns:
the status of the command execution.

Definition at line 446 of file shell.c.

References e_actuator_help(), e_fscmds_shell_help(), e_sensor_help(), e_syscmds_help(), SHELL_EXECSTATUS_KO, and SHELL_EXECSTATUS_OK.

00449 {
00450    signed portCHAR *pcStringSensor;
00451    signed portCHAR *pcStringActuator;
00452    signed portCHAR *pcStringFs;
00453    signed portCHAR *pcStringSys;
00454    int             ShellMsgLen = strlen((char *)SHELL_MSG_HELP);
00455    eExecStatus     eRetStatus = SHELL_EXECSTATUS_KO;
00456 
00457 
00458    // 0) If the way to reply is unavailable, it's no use to continue.
00459    if( ppcStringReply == NULL )
00460       return( eRetStatus );
00461 
00462    // TODO: add one possible parameter, one of sensor, actuator, sys, fs.
00463    // i.e.: help, help sensor, help actuator, help sys, help fs.
00464    // Check the input: no argument.
00465    if( 0 != ac )
00466    {   // Syntax error.
00467       *ppcStringReply = (signed portCHAR *)SHELL_ERRMSG_HELP_SYNTAXERROR;
00468       return( eRetStatus );
00469    }
00470 
00471    // Ask for the file system help.
00472    e_fscmds_shell_help( xModId, FsNavId, ac, av, &pcStringFs );
00473    // Ask for the sensors help.
00474    e_sensor_help( xModId, FsNavId, ac, av, &pcStringSensor );
00475    // Ask for the actuators help.
00476    e_actuator_help(xModId, FsNavId, ac, av, &pcStringActuator );
00477    // Ask for the sys help.
00478    e_syscmds_help(xModId, FsNavId, ac, av, &pcStringSys );
00479 
00480    // Malloc the necessary memory to concatenate the messages.
00481    ShellMsgLen += strlen( (char *)pcStringFs ) + strlen( (char *)pcStringSensor )
00482                   + strlen( (char *)pcStringActuator ) + strlen( (char *)pcStringSys ) +1;
00483    *ppcStringReply = (signed portCHAR *)pvPortMalloc(ShellMsgLen);
00484 
00485    // Build the message.
00486    strcpy((char *)*ppcStringReply, (char *)SHELL_MSG_HELP);
00487    strcat((char *)*ppcStringReply, (char *)pcStringSensor);
00488    strcat((char *)*ppcStringReply, (char *)pcStringActuator);
00489    strcat((char *)*ppcStringReply, (char *)pcStringFs);
00490    strcat((char *)*ppcStringReply, (char *)pcStringSys);
00491 
00492    // NOTE: we know that the strings returned from the misc _help functions
00493    // are const. So we don't free these strings.
00494 
00495    return(SHELL_EXECSTATUS_OK);
00496 }

eExecStatus e_supervisor_switch_to_maintenance_mode ( eModId  xModId,
signed short  FsNavId,
int  ac,
signed portCHAR *  av[],
signed portCHAR **  ppcStringReply 
)

The switch-to-maintenance-mode command: initiate the process to
switch to maintenance mode. Format: maintain.

Note:
This function must be of the type pfShellCmd defined by the shell module.
Parameters:
xModId Input. The module that is calling this function.
FsNavId Ignored.
ac Ignored.
av Ignored.
ppcStringReply Input/Output. The response string. If Input is NULL, no response string will be output. Else a malloc for the response string is performed here; the caller must free this string.
Returns:
the status of the command execution.

Definition at line 949 of file supervisor.c.

References bIsInMaintenance, CRLF, eUserMenuWaitHost, NAKED_TRACE_COM2, SHELL_EXECSTATUS_OK, SUPERVISOR_MAINTENANCE_NBMUTEX_TOTAKE, TRACE_COM2, u8CurrentUsbRole, u8IsMaintenanceRequired, vMMI_SetUserMenuMode(), x_supervisor_SemaphoreTake(), xCFGMutex, xLOGMutex, xSHELLFSMutex, xUSBMutex, and xWEBMutex.

Referenced by b_supervisor_switch_to_maintenance_mode(), and e_syscmds_reboot().

00953 {
00954    if( NULL != ppcStringReply )
00955       *ppcStringReply = NULL;
00956 
00957 #ifdef USB_ENABLE
00958 #if USB_DEVICE_FEATURE == ENABLED
00959    if( ( FALSE == bIsInMaintenance )
00960        && ( 0 == u8IsMaintenanceRequired ) )
00961    {   // We're not in maintenance mode.
00962       // Initiate the process of switching to maintenance mode.
00963       if( 0 == u8IsMaintenanceRequired )   u8IsMaintenanceRequired++;
00964 
00965       // Take all maintenance mutex except the USB mutex.
00966       if( TRUE == x_supervisor_SemaphoreTake( xLOGMutex, 0 ) )       u8IsMaintenanceRequired++;
00967 #if NW_INTEGRATED_IN_CONTROL_PANEL
00968       if( TRUE == x_supervisor_SemaphoreTake( xWEBMutex, 0 ) )       u8IsMaintenanceRequired++;
00969 #endif
00970       if( TRUE == x_supervisor_SemaphoreTake( xSHELLFSMutex, 0 ) )   u8IsMaintenanceRequired++;
00971       if( TRUE == x_supervisor_SemaphoreTake( xCFGMutex, 0 ) )       u8IsMaintenanceRequired++;
00972 
00973       // If all mutexes have been acquired, switch to maintenance mode.
00974       if( ( SUPERVISOR_MAINTENANCE_NBMUTEX_TOTAKE +1 ) == u8IsMaintenanceRequired )
00975       {
00976          fat_cache_flush(); // flush the FAT cache.
00977          nav_reset();       // Reset all file system navigators. We will mount 
00978                             // the com1shell default drive when we'll leave the 
00979                             // maintenance mode.
00980          // Switch to maintenance mode.
00981          xSemaphoreGive( xUSBMutex );
00982 
00983          // If the USB clock is frozen, unfreeze it so that we can write in the
00984          // USB registers.
00985          if(TRUE == Is_usb_clock_frozen())
00986          {
00987            Usb_unfreeze_clock();
00988          }
00989          // If it is not akready detached, physically detach the USB device.
00990          if(FALSE == Is_usb_detached())
00991          {
00992            Usb_detach();
00993          }
00994          vTaskDelay(500); // Wait 500ms
00995          Usb_attach();     // Reconnect the device.
00996 
00997          bIsInMaintenance = TRUE;
00998          u8IsMaintenanceRequired = 0;
00999          TRACE_COM2( "Entering maintenance mode");
01000 #ifdef MMILCD_ENABLE
01001          vMMI_SetUserMenuMode( eUserMenuWaitHost, pdTRUE );
01002 #endif
01003       }
01004       // ELSE: we'll switch to maintenance mode in x_supervisor_SemaphoreGive()
01005       // (when the mutex(es) that we couldn't get will be released).
01006    }
01007    else
01008    {
01009       NAKED_TRACE_COM2( "Won't go to maintenance mode:"CRLF"bIsInMaintenance=%d u8CurrentUsbRole=%d u8IsMaintenanceRequired=%d", bIsInMaintenance, u8CurrentUsbRole, u8IsMaintenanceRequired );
01010    }
01011 #endif
01012 #endif
01013 
01014    return( SHELL_EXECSTATUS_OK );
01015 }

static eCmdStatus prvCmdIdentify_Tokenize ( signed portCHAR *  pcStringCmd,
eModId  xModId,
portBASE_TYPE *  ac,
signed portCHAR **  av,
portBASE_TYPE *  pCmdIdx 
) [static]

Identify the cmd and tokenize the rest of the command line string.

Parameters:
pcStringCmd Input. The cmd line to parse. NULL-terminated string. Format: cmd [arg] [arg=val], with 6 (arg,val) maximum. WARNING: this string will be modified.
xModId Input. The module that is requesting the exe of this cmd line.
ac Output. Argument count, in [0,SHELL_MAX_NBTOKEN].
av Output. Argument vector, made of SHELL_MAX_NBTOKEN string ptrs maximum.
pCmdIdx Output. The index of the command, in one of the cmd array.
Returns:
the command status(eCmdStatus), indicating the Identify & Tokenize status.

Parse one arg.

Definition at line 334 of file shell.c.

References SHELL_CMDSTATUS_FOUND, SHELL_CMDSTATUS_NOTFOUND, SHELL_CMDSTATUS_PERMISSIONDENIED, SHELL_MAX_NBTOKEN, and SHELL_NB_COMMANDS.

Referenced by Shell_exec().

00337 {
00338    signed portCHAR   *pcStringPtr = pcStringCmd;
00339    size_t            token_len, parsed_len, tempo_len;
00340    portBASE_TYPE     cmd_len = strlen( (char *)pcStringCmd );
00341 
00342    /*
00343     * 1) Identify the command.
00344     */
00345    //    i) skip space.
00346    pcStringPtr += parsed_len = strspn((char *)pcStringCmd, " ");
00347    //    ii) Get the len of the cmd name (i.e. the token we're on).
00348    // NOTE: a cmd name is delimited by: {space,\0}.
00349    parsed_len += token_len = strcspn((char *)pcStringPtr," ");
00350    // Insert a \0 on the space or on \0.
00351    pcStringPtr[token_len] = '\0';
00352 
00353    //    iii) Spot the cmd in the cmd registration array.
00354    for(*pCmdIdx = 0; *pCmdIdx < SHELL_NB_COMMANDS; (*pCmdIdx)++)
00355    {   // Search in the regular commands array.
00356       if(0 == strcmp( (char *)pcStringPtr,
00357                       (char *)a_cmd_registration[*pCmdIdx].pc_string_cmd_name ) )
00358          break;
00359    }
00360    if(SHELL_NB_COMMANDS == *pCmdIdx)
00361       return(SHELL_CMDSTATUS_NOTFOUND);   // Command not found.
00362 
00363    /*
00364     * 2) Check the module rights on this cmd.
00365     */
00366    if( 0 == ( xModId & a_cmd_registration[*pCmdIdx].mod_rights_map ) )
00367       return(SHELL_CMDSTATUS_PERMISSIONDENIED);
00368 
00369    pcStringPtr += token_len+1;
00370    parsed_len++;
00371    // pcStringPtr now points just after the \0 after the cmd name.
00372 
00373    /*
00374     * 3) Tokenize the rest of the string.
00375     */
00376    *ac = 0; // Init arg count to 0 (no args yet).
00377    while( ( parsed_len < cmd_len ) && (*pcStringPtr != '\0') && (*ac <= SHELL_MAX_NBTOKEN) )
00378    {
00382       // Skip space.
00383       parsed_len += tempo_len = strspn((char *)pcStringPtr, " =");
00384       pcStringPtr += tempo_len;
00385       // pcStringPtr now points to the beginning of a token or at the end of the
00386       // cmd line.
00387       if(*pcStringPtr == '\0')
00388          break; // End of command line.
00389       // pcStringPtr now points to the beginning of a token.
00390 
00391       // Get the len of this token.
00392       if(*pcStringPtr == '"')
00393       {
00394          pcStringPtr++;   // Dump the ".
00395          parsed_len++;
00396          // Deal with string values, beginning with a " and ending with a ".
00397          // Strings can hold spaces, thus a space should not be considered a
00398          // delimiter when between "".
00399          // => a token is delimited by: {",\0}.
00400          token_len = strcspn((char *)pcStringPtr,"\"");
00401          // NOTE: token_len is == 0 if the string is just "". We consider this
00402          // a parameter (i.e. a string value is set to empty). So ac will be
00403          // incremented and the corresponding av will be set to an empty string.
00404       }
00405       else
00406       {
00407          // NOTE: a token is delimited by: {space,equal-sign,\0}.
00408          token_len = strcspn((char *)pcStringPtr," =");
00409       }
00410 
00411       // One more token.
00412       av[*ac] = pcStringPtr;
00413       (*ac)++;
00414       pcStringPtr += token_len;
00415       parsed_len += token_len;
00416       if(*pcStringPtr == '\0')
00417          break; // End of command line.
00418       else
00419          *pcStringPtr++ = '\0';
00420       // pcStringPtr now points on a space or on an equal-sign or at the end
00421       // of the cmd line.
00422    }
00423 
00424    return(SHELL_CMDSTATUS_FOUND);
00425 }

eExecStatus Shell_exec ( signed portCHAR *  pcStringCmd,
eModId  xModId,
signed short  FsNavId,
signed portCHAR **  ppcStringReply 
)

a command line executor.

Parameters:
pcStringCmd Input. The cmd line to execute. NULL-terminated string. Format: cmd [arg] [arg=val], with 6 (arg,val) maximum. WARNING: this string will be modified.
xModId Input. The module that is calling this exe function.
FsNavId Input. The file system navigator id to use if the cmd is a file system command.
ppcStringReply Output. The caller must free this string (by calling vportFree()) only if it is non-NULL and the returned status is OK.
Returns:
the status of the command execution.

Definition at line 235 of file shell.c.

References st_cmd_registration::pf_exec_cmd, prvCmdIdentify_Tokenize(), SHELL_CMDSTATUS_NOTFOUND, SHELL_CMDSTATUS_PERMISSIONDENIED, SHELL_ERRMSG_MAINTENANCEMODE, SHELL_EXECSTATUS_KO, SHELL_FS_FIRSTCMDIDX, SHELL_FS_LASTCMDIDX, SHELL_MAX_NBTOKEN, x_supervisor_SemaphoreGive(), and x_supervisor_SemaphoreTake().

Referenced by portTASK_FUNCTION(), and prvweb_ParseCGIRequest().

00239 {
00240    eCmdStatus        xCmdStatus;
00241    portBASE_TYPE     ac;
00242    signed portCHAR   *av[SHELL_MAX_NBTOKEN];
00243    portBASE_TYPE     CmdIdx;
00244    int               i;
00245    eExecStatus       xRet;
00246 
00247 
00248    // 1) Identify the command and tokenize the rest of the command line.
00249    xCmdStatus = prvCmdIdentify_Tokenize( pcStringCmd, xModId, &ac, av, &CmdIdx );
00250    if(SHELL_CMDSTATUS_NOTFOUND == xCmdStatus)
00251    {   // Command not found.
00252       if(ppcStringReply != NULL)
00253       {
00254          *ppcStringReply = (signed portCHAR *)SHELL_MSG_CMDNOTFOUND;
00255       }
00256       return(SHELL_EXECSTATUS_KO);
00257    }
00258    else if(SHELL_CMDSTATUS_PERMISSIONDENIED == xCmdStatus)
00259    {   // Permission denied.
00260       if(ppcStringReply != NULL)
00261       {
00262          *ppcStringReply = (signed portCHAR *)SHELL_MSG_PERMISSIONDENIED;
00263       }
00264       return(SHELL_EXECSTATUS_KO);
00265    }
00266 
00267    /* Get the SHELLFS mutex for File system access. */
00268    // We put this check here to reduce the code footprint (normally it should be
00269    // in each fs cmd function).
00270    if( ( CmdIdx >= SHELL_FS_FIRSTCMDIDX ) && ( CmdIdx <= SHELL_FS_LASTCMDIDX ) )
00271    {
00272       if( pdFALSE == x_supervisor_SemaphoreTake( xSHELLFSMutex, 0 ) )
00273       {   // Failed to get the SHELLFS mutex.
00274          if(ppcStringReply != NULL)
00275          {
00276             *ppcStringReply = (signed portCHAR *)SHELL_ERRMSG_MAINTENANCEMODE;
00277          }
00278          return(SHELL_EXECSTATUS_KO);
00279       }
00280    }
00281 
00282    /* Special case for the !! command. Only for the SYS_MODID_COM1SHELL module,
00283       cf. a_cmd_registration[]. */
00284    if( 0 == CmdIdx ) // !! command
00285    {
00286       CmdIdx = PrevCmdIdx; // Execute the previous cmd.
00287       if( -1 == CmdIdx )
00288       {   // No previous command.
00289          if(ppcStringReply != NULL)
00290          {
00291             *ppcStringReply = (signed portCHAR *)SHELL_MSG_NOHISTORY;
00292          }
00293          return(SHELL_EXECSTATUS_KO);
00294       }
00295       ac = PrevCmdAc;      // NOTE: we take a shortcut here: we suppose the caller
00296                            // keeps the same pcStringCmd from one call to another.
00297       for(i=0; i<ac; i++)   av[i] = PrevCmdAv[i];
00298    }
00299    else
00300    {
00301       PrevCmdIdx = CmdIdx; // Save the cmd (used by the !! cmd).
00302       PrevCmdAc = ac;
00303       for(i=0; i<ac; i++)   PrevCmdAv[i] = av[i];
00304    }
00305 
00306    // 2) Execute the command.
00307    if(ppcStringReply != NULL)
00308       *ppcStringReply = NULL;
00309    xRet = a_cmd_registration[CmdIdx].pf_exec_cmd( xModId, FsNavId, ac, av, ppcStringReply );
00310 
00311    /* Release the SHELLFS mutex. */
00312    if( ( CmdIdx >= SHELL_FS_FIRSTCMDIDX ) && ( CmdIdx <= SHELL_FS_LASTCMDIDX ) )
00313    {
00314       x_supervisor_SemaphoreGive( xSHELLFSMutex );
00315    }
00316 
00317    return( xRet );
00318 }

void v_shell_Print_String_To_Requester_Stream ( eModId  xModId,
const signed portCHAR *  pcStringToDisplay 
)

Print a string directly to the output stream of a module.

Parameters:
xModId Input. The module associated with the target output stream.
pcStringToDisplay Input. The string to print.

Definition at line 506 of file shell.c.

References SYS_MODID_COM1SHELL, SYS_MODID_USB, TRACE_COM2, and vcom1shell_PrintMsg().

Referenced by e_fscmds_shell_fat(), e_fscmds_shell_pwd(), e_usbsys_lsusb(), prv_append(), prv_cat(), prv_df(), prv_e_usbsys_sync_cp_ukey(), and prv_ls().

00508 {
00509    switch( xModId )
00510    {
00511       case SYS_MODID_COM1SHELL:
00512          vcom1shell_PrintMsg(pcStringToDisplay);
00513          break;
00514       case SYS_MODID_USB:
00515          TRACE_COM2((char *)"Unimplemented stream redirection (from fscmds to USB)");
00516          break;
00517       default: // SHOULD NEVER HAPPEN
00518          TRACE_COM2((char *) "Unexpected stream redirection");
00519          break;
00520    }
00521 }


Variable Documentation

The array of commands registration.

Definition at line 141 of file shell.c.

portBASE_TYPE PrevCmdAc [static]

Definition at line 206 of file shell.c.

signed portCHAR* PrevCmdAv[SHELL_MAX_NBTOKEN]

Definition at line 207 of file shell.c.

portBASE_TYPE PrevCmdIdx = -1 [static]

Previous cmd index.

Definition at line 205 of file shell.c.

const signed portCHAR* const SHELL_ERRMSG_HELP_SYNTAXERROR = (signed portCHAR *)"Error"CRLF"Usage: help [sensor,actuator,sys,fs]"CRLF

Error msg upon help syntax error.

Definition at line 202 of file shell.c.

const signed portCHAR* const SHELL_MSG_CMDNOTFOUND = (signed portCHAR *)"Error"CRLF"Command not found"CRLF

String messages.

Error msg upon command not found.

Definition at line 190 of file shell.c.

const signed portCHAR* const SHELL_MSG_HELP = (signed portCHAR *)"Commands summary"CRLF"help"CRLF"!!: execute the previous command"CRLF

Definition at line 196 of file shell.c.

const signed portCHAR* const SHELL_MSG_NOHISTORY = (signed portCHAR *)"Error"CRLF"No previous command"CRLF

Error msg if !! is executed and there is no previous comand.

Definition at line 199 of file shell.c.

const signed portCHAR* const SHELL_MSG_PERMISSIONDENIED = (signed portCHAR *)"Error"CRLF"Permission denied"CRLF

Error msg upon command execution permission denied.

Definition at line 194 of file shell.c.

const signed portCHAR* const SHELL_MSG_SYNTAXERROR = (signed portCHAR *)"Error"CRLF"Syntax error"CRLF

Error msg upon syntax error.

Definition at line 192 of file shell.c.

xSemaphoreHandle xSHELLFSMutex

The SHELLFS system mutex.

The SHELL system mutex.

Definition at line 200 of file supervisor.c.

Referenced by e_supervisor_switch_to_maintenance_mode(), portTASK_FUNCTION(), and prv_v_common_leave_UsbDevice_mode().


Generated on Fri Feb 19 02:22:47 2010 for AVR32 - Control Panel demonstration. by  doxygen 1.5.5