Debug/cli/cli.c

   1 /* Copyright (C) 2014 by Jacob Alexander
   2  *
   3  * Permission is hereby granted, free of charge, to any person obtaining a copy
   4  * of this software and associated documentation files (the "Software"), to deal
   5  * in the Software without restriction, including without limitation the rights
   6  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   7  * copies of the Software, and to permit persons to whom the Software is
   8  * furnished to do so, subject to the following conditions:
   9  *
  10  * The above copyright notice and this permission notice shall be included in
  11  * all copies or substantial portions of the Software.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  18  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  19  * THE SOFTWARE.
  20  */
  21
  22 // ----- Includes -----
  23
  24 // Compiler Includes
  25 //#include <stdarg.h>
  26
  27 // Project Includes
  28 #include <buildvars.h>
  29 #include "cli.h"
  30 #include <led.h>
  31 #include <print.h>
  32
  33
  34
  35 // ----- Variables -----
  36
  37 // Basic command dictionary
  38 char*       basicCLIDictName = "General Commands";
  39 CLIDictItem basicCLIDict[] = {
  40         { "cliDebug", "Enables/Disables hex output of the most recent cli input.", cliFunc_cliDebug },
  41         { "help",     "You're looking at it :P", cliFunc_help },
  42         { "led",      "Enables/Disables indicator LED. Try a couple times just in case the LED is in an odd state.\r\n\t\t\033[33mWarning\033[0m: May adversely affect some modules...", cliFunc_led },
  43         { "reload",   "Signals microcontroller to reflash/reload.", cliFunc_reload },
  44         { "reset",    "Resets the terminal back to initial settings.", cliFunc_reset },
  45         { "restart",  "Sends a software restart, should be similar to powering on the device.", cliFunc_restart },
  46         { "version",  "Version information about this firmware.", cliFunc_version },
  47         { 0, 0, 0 } // Null entry for dictionary end
  48 };
  49
  50
  51
  52 // ----- Functions -----
  53
  54 inline void prompt()
  55 {
  56         print("\033[2K"); // Erases the current line
  57         print("\033[1;34m:\033[0m ");
  58 }
  59
  60 // Initialize the CLI
  61 inline void init_cli()
  62 {
  63         // Reset the Line Buffer
  64         CLILineBufferCurrent = 0;
  65
  66         // Set prompt
  67         prompt();
  68
  69         // Register first dictionary
  70         CLIDictionariesUsed = 0;
  71         registerDictionary_cli( basicCLIDict, basicCLIDictName );
  72
  73         // Initialize main LED
  74         init_errorLED();
  75         CLILEDState = 0;
  76
  77         // Hex debug mode is off by default
  78         CLIHexDebugMode = 0;
  79 }
  80
  81 // Query the serial input buffer for any new characters
  82 void process_cli()
  83 {
  84         // Current buffer position
  85         uint8_t prev_buf_pos = CLILineBufferCurrent;
  86
  87         // Process each character while available
  88         int result = 0;
  89         while ( 1 )
  90         {
  91                 // No more characters to process
  92                 result = usb_serial_getchar(); // Retrieve from serial module // TODO Make USB agnostic
  93                 if ( result == -1 )
  94                         break;
  95
  96                 char cur_char = (char)result;
  97
  98                 // Make sure buffer isn't full
  99                 if ( CLILineBufferCurrent >= CLILineBufferMaxSize )
 100                 {
 101                         print( NL );
 102                         erro_print("Serial line buffer is full, dropping character and resetting...");
 103
 104                         // Clear buffer
 105                         CLILineBufferCurrent = 0;
 106
 107                         // Reset the prompt
 108                         prompt();
 109
 110                         return;
 111                 }
 112
 113                 // Place into line buffer
 114                 CLILineBuffer[CLILineBufferCurrent++] = cur_char;
 115         }
 116
 117         // Display Hex Key Input if enabled
 118         if ( CLIHexDebugMode && CLILineBufferCurrent > prev_buf_pos )
 119         {
 120                 print("\033[s\r\n"); // Save cursor position, and move to the next line
 121                 print("\033[2K");    // Erases the current line
 122
 123                 uint8_t pos = prev_buf_pos;
 124                 while ( CLILineBufferCurrent > pos )
 125                 {
 126                         printHex( CLILineBuffer[pos++] );
 127                         print(" ");
 128                 }
 129
 130                 print("\033[u"); // Restore cursor position
 131         }
 132
 133         // If buffer has changed, output to screen while there are still characters in the buffer not displayed
 134         while ( CLILineBufferCurrent > prev_buf_pos )
 135         {
 136                 // Check for control characters
 137                 switch ( CLILineBuffer[prev_buf_pos] )
 138                 {
 139                 case 0x0D: // Enter
 140                         CLILineBufferCurrent--; // Remove the Enter
 141
 142                         // Process the current line buffer
 143                         commandLookup_cli();
 144
 145                         // Reset the buffer
 146                         CLILineBufferCurrent = 0;
 147
 148                         // Reset the prompt after processing has finished
 149                         print( NL );
 150                         prompt();
 151
 152                         // XXX There is a potential bug here when resetting the buffer (losing valid keypresses)
 153                         //     Doesn't look like it will happen *that* often, so not handling it for now -HaaTa
 154                         return;
 155
 156                 case 0x09: // Tab
 157                         // Tab completion for the current command
 158                         // TODO
 159                         return;
 160
 161                 case 0x1B: // Esc
 162                         // Check for escape sequence
 163                         // TODO
 164                         return;
 165
 166                 case 0x08:
 167                 case 0x7F: // Backspace
 168                         // TODO - Does not handle case for arrow editing (arrows disabled atm)
 169                         CLILineBufferCurrent--; // Remove the backspace
 170
 171                         // If there are characters in the buffer
 172                         if ( CLILineBufferCurrent > 0 )
 173                         {
 174                                 // Remove character from current position in the line buffer
 175                                 CLILineBufferCurrent--;
 176
 177                                 // Remove character from tty
 178                                 print("\b \b");
 179                         }
 180
 181                         break;
 182
 183                 default:
 184                         // Place a null on the end (to use with string print)
 185                         CLILineBuffer[CLILineBufferCurrent] = '\0';
 186
 187                         // Output buffer to screen
 188                         dPrint( &CLILineBuffer[prev_buf_pos] );
 189
 190                         // Buffer reset
 191                         prev_buf_pos++;
 192
 193                         break;
 194                 }
 195         }
 196 }
 197
 198 // Takes a string, returns two pointers
 199 //  One to the first non-space character
 200 //  The second to the next argument (first NULL if there isn't an argument). delimited by a space
 201 //  Places a NULL at the first space after the first argument
 202 inline void argumentIsolation_cli( char* string, char** first, char** second )
 203 {
 204         // Mark out the first argument
 205         // This is done by finding the first space after a list of non-spaces and setting it NULL
 206         char* cmdPtr = string - 1;
 207         while ( *++cmdPtr == ' ' ); // Skips leading spaces, and points to first character of cmd
 208
 209         // Locates first space delimiter
 210         char* argPtr = cmdPtr + 1;
 211         while ( *argPtr != ' ' && *argPtr != '\0' )
 212                 argPtr++;
 213
 214         // Point to the first character of args or a NULL (no args) and set the space delimiter as a NULL
 215         (++argPtr)[-1] = '\0';
 216
 217         // Set return variables
 218         *first = cmdPtr;
 219         *second = argPtr;
 220 }
 221
 222 // Scans the CLILineBuffer for any valid commands
 223 void commandLookup_cli()
 224 {
 225         // Ignore command if buffer is 0 length
 226         if ( CLILineBufferCurrent == 0 )
 227                 return;
 228
 229         // Set the last+1 character of the buffer to NULL for string processing
 230         CLILineBuffer[CLILineBufferCurrent] = '\0';
 231
 232         // Retrieve pointers to command and beginning of arguments
 233         // Places a NULL at the first space after the command
 234         char* cmdPtr;
 235         char* argPtr;
 236         argumentIsolation_cli( CLILineBuffer, &cmdPtr, &argPtr );
 237
 238         // Scan array of dictionaries for a valid command match
 239         for ( uint8_t dict = 0; dict < CLIDictionariesUsed; dict++ )
 240         {
 241                 // Parse each cmd until a null command entry is found, or an argument match
 242                 for ( uint8_t cmd = 0; CLIDict[dict][cmd].name != 0; cmd++ )
 243                 {
 244                         // Compare the first argument and each command entry
 245                         if ( eqStr( cmdPtr, CLIDict[dict][cmd].name ) )
 246                         {
 247                                 // Run the specified command function pointer
 248                                 //   argPtr is already pointing at the first character of the arguments
 249                                 (*CLIDict[dict][cmd].function)( argPtr );
 250
 251                                 return;
 252                         }
 253                 }
 254         }
 255
 256         // No match for the command...
 257         print( NL );
 258         erro_dPrint("\"", CLILineBuffer, "\" is not a valid command...type \033[35mhelp\033[0m");
 259 }
 260
 261 // Registers a command dictionary with the CLI
 262 inline void registerDictionary_cli( CLIDictItem *cmdDict, char* dictName )
 263 {
 264         // Make sure this max limit of dictionaries hasn't been reached
 265         if ( CLIDictionariesUsed >= CLIMaxDictionaries )
 266         {
 267                 erro_print("Max number of dictionaries defined already...");
 268                 return;
 269         }
 270
 271         // Add dictionary
 272         CLIDictNames[CLIDictionariesUsed] = dictName;
 273         CLIDict[CLIDictionariesUsed++] = cmdDict;
 274 }
 275
 276
 277
 278 // ----- CLI Command Functions -----
 279
 280 void cliFunc_cliDebug( char* args )
 281 {
 282         // Toggle Hex Debug Mode
 283         if ( CLIHexDebugMode )
 284         {
 285                 print( NL );
 286                 info_print("Hex debug mode disabled...");
 287                 CLIHexDebugMode = 0;
 288         }
 289         else
 290         {
 291                 print( NL );
 292                 info_print("Hex debug mode enabled...");
 293                 CLIHexDebugMode = 1;
 294         }
 295 }
 296
 297 void cliFunc_help( char* args )
 298 {
 299         // Scan array of dictionaries and print every description
 300         //  (no alphabetical here, too much processing/memory to sort...)
 301         for ( uint8_t dict = 0; dict < CLIDictionariesUsed; dict++ )
 302         {
 303                 // Print the name of each dictionary as a title
 304                 dPrintStrsNL( NL, "\033[1;32m", CLIDictNames[dict], "\033[0m" );
 305
 306                 // Parse each cmd/description until a null command entry is found
 307                 for ( uint8_t cmd = 0; CLIDict[dict][cmd].name != 0; cmd++ )
 308                 {
 309                         dPrintStrs(" \033[35m", CLIDict[dict][cmd].name, "\033[0m");
 310
 311                         // Determine number of spaces to tab by the length of the command and TabAlign
 312                         uint8_t padLength = CLIEntryTabAlign - lenStr( CLIDict[dict][cmd].name );
 313                         while ( padLength-- > 0 )
 314                                 print(" ");
 315
 316                         dPrintStrNL( CLIDict[dict][cmd].description );
 317                 }
 318         }
 319 }
 320
 321 void cliFunc_led( char* args )
 322 {
 323         CLILEDState ^= 1 << 1; // Toggle between 0 and 1
 324         errorLED( CLILEDState ); // Enable/Disable error LED
 325 }
 326
 327 void cliFunc_reload( char* args )
 328 {
 329         // Request to output module to be set into firmware reload mode
 330         output_firmwareReload();
 331 }
 332
 333 void cliFunc_reset( char* args )
 334 {
 335         print("\033c"); // Resets the terminal
 336 }
 337
 338 void cliFunc_restart( char* args )
 339 {
 340         // Trigger an overall software reset
 341         SOFTWARE_RESET();
 342 }
 343
 344 void cliFunc_version( char* args )
 345 {
 346         print( NL );
 347         print( " \033[1mRevision:\033[0m      " CLI_Revision       NL );
 348         print( " \033[1mBranch:\033[0m        " CLI_Branch         NL );
 349         print( " \033[1mTree Status:\033[0m   " CLI_ModifiedStatus NL );
 350         print( " \033[1mRepo Origin:\033[0m   " CLI_RepoOrigin     NL );
 351         print( " \033[1mCommit Date:\033[0m   " CLI_CommitDate     NL );
 352         print( " \033[1mCommit Author:\033[0m " CLI_CommitAuthor   NL );
 353         print( " \033[1mBuild Date:\033[0m    " CLI_BuildDate      NL );
 354         print( " \033[1mBuild OS:\033[0m      " CLI_BuildOS        NL );
 355         print( " \033[1mArchitecture:\033[0m  " CLI_Arch           NL );
 356         print( " \033[1mChip:\033[0m          " CLI_Chip           NL );
 357         print( " \033[1mCPU:\033[0m           " CLI_CPU            NL );
 358         print( " \033[1mDevice:\033[0m        " CLI_Device         NL );
 359         print( " \033[1mModules:\033[0m       " CLI_Modules        NL );
 360 }
 361