Macro/PartialMap/macro.c

   1 /* Copyright (C) 2014 by Jacob Alexander
   2  *
   3  * This file is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This file is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this file.  If not, see <http://www.gnu.org/licenses/>.
  15  */
  16
  17 // ----- Includes -----
  18
  19 // Compiler Includes
  20 #include <Lib/MacroLib.h>
  21
  22 // Project Includes
  23 #include <cli.h>
  24 #include <led.h>
  25 #include <print.h>
  26 #include <scan_loop.h>
  27 #include <output_com.h>
  28
  29 // Keymaps
  30 #include "usb_hid.h"
  31 #include <defaultMap.h>
  32 #include "generatedKeymap.h" // TODO Use actual generated version
  33
  34 // Local Includes
  35 #include "macro.h"
  36
  37
  38
  39 // ----- Function Declarations -----
  40
  41 void cliFunc_capList   ( char* args );
  42 void cliFunc_capSelect ( char* args );
  43 void cliFunc_keyPress  ( char* args );
  44 void cliFunc_keyRelease( char* args );
  45 void cliFunc_layerLatch( char* args );
  46 void cliFunc_layerList ( char* args );
  47 void cliFunc_layerLock ( char* args );
  48 void cliFunc_macroDebug( char* args );
  49 void cliFunc_macroList ( char* args );
  50 void cliFunc_macroProc ( char* args );
  51 void cliFunc_macroShow ( char* args );
  52 void cliFunc_macroStep ( char* args );
  53
  54
  55
  56 // ----- Variables -----
  57
  58 // Macro Module command dictionary
  59 char*       macroCLIDictName = "Macro Module Commands";
  60 CLIDictItem macroCLIDict[] = {
  61         { "capList",     "Prints an indexed list of all non USB keycode capabilities.", cliFunc_capList },
  62         { "capSelect",   "Triggers the specified capabilities. First two args are state and stateType." NL "\t\t\033[35mK11\033[0m Keyboard Capability 0x0B", cliFunc_capSelect },
  63         { "keyPress",    "Send key-presses to the macro module. Held until released. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A", cliFunc_keyPress },
  64         { "keyRelease",  "Release a key-press from the macro module. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A", cliFunc_keyRelease },
  65         { "layerLatch",  "Latch the specified indexed layer." NL "\t\t\033[35mL15\033[0m Indexed Layer 0x0F", cliFunc_layerLatch },
  66         { "layerList",   "List available layers.", cliFunc_layerList },
  67         { "layerLock",   "Lock the specified indexed layer." NL "\t\t\033[35mL2\033[0m Indexed Layer 0x02", cliFunc_layerLock },
  68         { "macroDebug",  "Disables/Enables sending USB keycodes to the Output Module and prints U/K codes.", cliFunc_macroDebug },
  69         { "macroList",   "List the defined trigger and result macros.", cliFunc_macroList },
  70         { "macroProc",   "Pause/Resume macro processing.", cliFunc_macroProc },
  71         { "macroShow",   "Show the macro corresponding to the given index." NL "\t\t\033[35mT16\033[0m Indexed Trigger Macro 0x10, \033[35mR12\033[0m Indexed Result Macro 0x0C", cliFunc_macroShow },
  72         { "macroStep",   "Do N macro processing steps. Defaults to 1.", cliFunc_macroStep },
  73         { 0, 0, 0 } // Null entry for dictionary end
  74 };
  75
  76
  77 // Macro debug flag - If set, clears the USB Buffers after signalling processing completion
  78 uint8_t macroDebugMode = 0;
  79
  80 // Macro pause flag - If set, the macro module pauses processing, unless unset, or the step counter is non-zero
  81 uint8_t macroPauseMode = 0;
  82
  83 // Macro step counter - If non-zero, the step counter counts down every time the macro module does one processing loop
  84 unsigned int macroStepCounter = 0;
  85
  86
  87 // Key Trigger List Buffer
  88 //  * Item 1: scan code
  89 //  * Item 2: state
  90 //    ...
  91 uint8_t macroTriggerListBuffer[MaxScanCode * 2] = { 0 }; // Each key has a state to be cached
  92 uint8_t macroTriggerListBufferSize = 0;
  93
  94 // TODO, figure out a good way to scale this array size without wasting too much memory, but not rejecting macros
  95 //       Possibly could be calculated by the KLL compiler
  96 // XXX It may be possible to calculate the worst case using the KLL compiler
  97 TriggerMacro *triggerMacroPendingList[TriggerMacroNum];
  98
  99
 100
 101 // ----- Functions -----
 102
 103 // Looks up the trigger list for the given scan code (from the active layer)
 104 unsigned int *Macro_layerLookup( uint8_t scanCode )
 105 {
 106         // TODO - No layer fallthrough lookup
 107         return default_scanMap[ scanCode ];
 108 }
 109
 110
 111 // Update the scancode key state
 112 // States:
 113 //   * 0x00 - Reserved
 114 //   * 0x01 - Pressed
 115 //   * 0x02 - Held
 116 //   * 0x03 - Released
 117 //   * 0x04 - Unpressed (this is currently ignored)
 118 inline void Macro_keyState( uint8_t scanCode, uint8_t state )
 119 {
 120         // Only add to macro trigger list if one of three states
 121         switch ( state )
 122         {
 123         case 0x01: // Pressed
 124         case 0x02: // Held
 125         case 0x03: // Released
 126                 macroTriggerListBuffer[ macroTriggerListBufferSize++ ] = scanCode;
 127                 macroTriggerListBuffer[ macroTriggerListBufferSize++ ] = state;
 128                 break;
 129         }
 130 }
 131
 132
 133 // Update the scancode analog state
 134 // States:
 135 //   * 0x00      - Reserved
 136 //   * 0x01      - Released
 137 //   * 0x02-0xFF - Analog value (low to high)
 138 inline void Macro_analogState( uint8_t scanCode, uint8_t state )
 139 {
 140         // TODO
 141 }
 142
 143
 144 // Update led state
 145 // States:
 146 //   * 0x00 - Reserved
 147 //   * 0x01 - On
 148 //   * 0x02 - Off
 149 inline void Macro_ledState( uint8_t ledCode, uint8_t state )
 150 {
 151         // TODO
 152 }
 153
 154
 155 // Evaluate/Update the TriggerMacro
 156 void Macro_evalTriggerMacro( TriggerMacro *triggerMacro )
 157 {
 158         // Which combo in the sequence is being evaluated
 159         unsigned int comboPos = triggerMacro->pos;
 160
 161         // If combo length is more than 1, cancel trigger macro if an incorrect key is found
 162         uint8_t comboLength = triggerMacro->guide[ comboPos ];
 163
 164         // Iterate over list of keys currently pressed
 165         for ( uint8_t keyPressed = 0; keyPressed < macroTriggerListBufferSize; keyPressed += 2 )
 166         {
 167                 // Compare with keys in combo
 168                 for ( unsigned int comboKey = 0; comboKey < comboLength; comboKey++ )
 169                 {
 170                         // Lookup key in combo
 171                         uint8_t guideKey = triggerMacro->guide[ comboPos + comboKey + 2 ]; // TODO Only Press/Hold/Release atm
 172
 173                         // Sequence Case
 174                         if ( comboLength == 1 )
 175                         {
 176                                 // If key matches and only 1 key pressed, increment the TriggerMacro combo position
 177                                 if ( guideKey == macroTriggerListBuffer[ keyPressed ] && macroTriggerListBufferSize == 1 )
 178                                 {
 179                                         triggerMacro->pos += comboLength * 2 + 1;
 180                                         // TODO check if TriggerMacro is finished, register ResultMacro
 181                                         return;
 182                                 }
 183
 184                                 // If key does not match or more than 1 key pressed, reset the TriggerMacro combo position
 185                                 triggerMacro->pos = 0;
 186                                 return;
 187                         }
 188                         // Combo Case
 189                         else
 190                         {
 191                                 // TODO
 192                         }
 193                 }
 194         }
 195 }
 196
 197
 198
 199
 200 /*
 201 inline void Macro_bufferAdd( uint8_t byte )
 202 {
 203         // Make sure we haven't overflowed the key buffer
 204         // Default function for adding keys to the KeyIndex_Buffer, does a DefaultMap_Lookup
 205         if ( KeyIndex_BufferUsed < KEYBOARD_BUFFER )
 206         {
 207                 uint8_t key = DefaultMap_Lookup[byte];
 208                 for ( uint8_t c = 0; c < KeyIndex_BufferUsed; c++ )
 209                 {
 210                         // Key already in the buffer
 211                         if ( KeyIndex_Buffer[c] == key )
 212                                 return;
 213                 }
 214
 215                 // Add to the buffer
 216                 KeyIndex_Buffer[KeyIndex_BufferUsed++] = key;
 217         }
 218 }
 219
 220 inline void Macro_bufferRemove( uint8_t byte )
 221 {
 222         uint8_t key = DefaultMap_Lookup[byte];
 223
 224         // Check for the released key, and shift the other keys lower on the buffer
 225         for ( uint8_t c = 0; c < KeyIndex_BufferUsed; c++ )
 226         {
 227                 // Key to release found
 228                 if ( KeyIndex_Buffer[c] == key )
 229                 {
 230                         // Shift keys from c position
 231                         for ( uint8_t k = c; k < KeyIndex_BufferUsed - 1; k++ )
 232                                 KeyIndex_Buffer[k] = KeyIndex_Buffer[k + 1];
 233
 234                         // Decrement Buffer
 235                         KeyIndex_BufferUsed--;
 236
 237                         return;
 238                 }
 239         }
 240
 241         // Error case (no key to release)
 242         erro_msg("Could not find key to release: ");
 243         printHex( key );
 244 }
 245 */
 246
 247 inline void Macro_finishWithUSBBuffer( uint8_t sentKeys )
 248 {
 249 }
 250
 251 inline void Macro_process()
 252 {
 253         // Only do one round of macro processing between Output Module timer sends
 254         if ( USBKeys_Sent != 0 )
 255                 return;
 256
 257         // If the pause flag is set, only process if the step counter is non-zero
 258         if ( macroPauseMode && macroStepCounter == 0 )
 259         {
 260                 return;
 261         }
 262         // Proceed, decrementing the step counter
 263         else
 264         {
 265                 macroStepCounter--;
 266         }
 267
 268         // Loop through macro trigger buffer
 269         for ( uint8_t index = 0; index < macroTriggerListBufferSize; index += 2 )
 270         {
 271                 // Get scanCode, first item of macroTriggerListBuffer pairs
 272                 uint8_t scanCode = macroTriggerListBuffer[ index ];
 273
 274                 // Lookup trigger list for this key
 275                 unsigned int *triggerList = Macro_layerLookup( scanCode );
 276
 277                 // The first element is the length of the trigger list
 278                 unsigned int triggerListSize = triggerList[0];
 279
 280                 // Loop through the trigger list
 281                 for ( unsigned int trigger = 0; trigger < triggerListSize; trigger++ )
 282                 {
 283                         // Lookup TriggerMacro
 284                         TriggerMacro *triggerMacro = (TriggerMacro*)triggerList[ trigger + 1 ];
 285
 286                         // Get triggered state of scan code, second item of macroTriggerListBuffer pairs
 287                         uint8_t state = macroTriggerListBuffer[ index + 1 ];
 288
 289                         // Evaluate Macro
 290                         Macro_evalTriggerMacro( triggerMacro );
 291                 }
 292         }
 293
 294
 295
 296
 297
 298         /* TODO
 299         // Loop through input buffer
 300         for ( uint8_t index = 0; index < KeyIndex_BufferUsed && !macroDebugMode; index++ )
 301         {
 302                 //print(" KEYS: ");
 303                 //printInt8( KeyIndex_BufferUsed );
 304                 // Get the keycode from the buffer
 305                 uint8_t key = KeyIndex_Buffer[index];
 306
 307                 // Set the modifier bit if this key is a modifier
 308                 if ( (key & KEY_LCTRL) == KEY_LCTRL ) // AND with 0xE0
 309                 {
 310                         USBKeys_Modifiers |= 1 << (key ^ KEY_LCTRL); // Left shift 1 by key XOR 0xE0
 311
 312                         // Modifier processed, move on to the next key
 313                         continue;
 314                 }
 315
 316                 // Too many keys
 317                 if ( USBKeys_Sent >= USBKeys_MaxSize )
 318                 {
 319                         warn_msg("USB Key limit reached");
 320                         errorLED( 1 );
 321                         break;
 322                 }
 323
 324                 // Allow ignoring keys with 0's
 325                 if ( key != 0 )
 326                 {
 327                         USBKeys_Array[USBKeys_Sent++] = key;
 328                 }
 329                 else
 330                 {
 331                         // Key was not mapped
 332                         erro_msg( "Key not mapped... - " );
 333                         printHex( key );
 334                         errorLED( 1 );
 335                 }
 336         }
 337         */
 338
 339         // Signal buffer that we've used it
 340         Scan_finishedWithBuffer( KeyIndex_BufferUsed );
 341
 342         // If Macro debug mode is set, clear the USB Buffer
 343         if ( macroDebugMode )
 344         {
 345                 USBKeys_Modifiers = 0;
 346                 USBKeys_Sent = 0;
 347         }
 348 }
 349
 350 inline void Macro_setup()
 351 {
 352         // Register Macro CLI dictionary
 353         CLI_registerDictionary( macroCLIDict, macroCLIDictName );
 354
 355         // Disable Macro debug mode
 356         macroDebugMode = 0;
 357
 358         // Disable Macro pause flag
 359         macroPauseMode = 0;
 360
 361         // Set Macro step counter to zero
 362         macroStepCounter = 0;
 363
 364         // Make sure macro trigger buffer is empty
 365         macroTriggerListBufferSize = 0;
 366 }
 367
 368
 369 // ----- CLI Command Functions -----
 370
 371 void cliFunc_capList( char* args )
 372 {
 373         print( NL );
 374         info_msg("Capabilities List");
 375
 376         // Iterate through all of the capabilities and display them
 377         for ( unsigned int cap = 0; cap < CapabilitiesNum; cap++ )
 378         {
 379                 print( NL "\t" );
 380                 printHex( cap );
 381                 print(" - ");
 382
 383                 // Display/Lookup Capability Name (utilize debug mode of capability)
 384                 void (*capability)(uint8_t, uint8_t, uint8_t*) = (void(*)(uint8_t, uint8_t, uint8_t*))(CapabilitiesList[ cap ].func);
 385                 capability( 0xFF, 0xFF, 0 );
 386         }
 387 }
 388
 389 void cliFunc_capSelect( char* args )
 390 {
 391         // Parse code from argument
 392         char* curArgs;
 393         char* arg1Ptr;
 394         char* arg2Ptr = args;
 395
 396         // Total number of args to scan (must do a lookup if a keyboard capability is selected)
 397         unsigned int totalArgs = 2; // Always at least two args
 398         unsigned int cap = 0;
 399
 400         // Arguments used for keyboard capability function
 401         unsigned int argSetCount = 0;
 402         uint8_t *argSet = (uint8_t*)args;
 403
 404         // Process all args
 405         for ( unsigned int c = 0; argSetCount < totalArgs; c++ )
 406         {
 407                 curArgs = arg2Ptr;
 408                 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
 409
 410                 // Stop processing args if no more are found
 411                 // Extra arguments are ignored
 412                 if ( *arg1Ptr == '\0' )
 413                         break;
 414
 415                 // For the first argument, choose the capability
 416                 if ( c == 0 ) switch ( arg1Ptr[0] )
 417                 {
 418                 // Keyboard Capability
 419                 case 'K':
 420                         // Determine capability index
 421                         cap = decToInt( &arg1Ptr[1] );
 422
 423                         // Lookup the number of args
 424                         totalArgs += CapabilitiesList[ cap ].argCount;
 425                         continue;
 426                 }
 427
 428                 // Because allocating memory isn't doable, and the argument count is arbitrary
 429                 // The argument pointer is repurposed as the argument list (much smaller anyways)
 430                 argSet[ argSetCount++ ] = (uint8_t)decToInt( arg1Ptr );
 431
 432                 // Once all the arguments are prepared, call the keyboard capability function
 433                 if ( argSetCount == totalArgs )
 434                 {
 435                         // Indicate that the capability was called
 436                         print( NL );
 437                         info_msg("K");
 438                         printInt8( cap );
 439                         print(" - ");
 440                         printHex( argSet[0] );
 441                         print(" - ");
 442                         printHex( argSet[1] );
 443                         print(" - ");
 444                         printHex( argSet[2] );
 445                         print( "..." NL );
 446
 447                         void (*capability)(uint8_t, uint8_t, uint8_t*) = (void(*)(uint8_t, uint8_t, uint8_t*))(CapabilitiesList[ cap ].func);
 448                         capability( argSet[0], argSet[1], &argSet[2] );
 449                 }
 450         }
 451 }
 452
 453 void cliFunc_keyPress( char* args )
 454 {
 455         // Parse codes from arguments
 456         char* curArgs;
 457         char* arg1Ptr;
 458         char* arg2Ptr = args;
 459
 460         // Process all args
 461         for ( ;; )
 462         {
 463                 curArgs = arg2Ptr;
 464                 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
 465
 466                 // Stop processing args if no more are found
 467                 if ( *arg1Ptr == '\0' )
 468                         break;
 469
 470                 // Ignore non-Scancode numbers
 471                 switch ( arg1Ptr[0] )
 472                 {
 473                 // Scancode
 474                 case 'S':
 475                         Macro_keyState( (uint8_t)decToInt( &arg1Ptr[1] ), 0x01 ); // Press scancode
 476                         break;
 477                 }
 478         }
 479 }
 480
 481 void cliFunc_keyRelease( char* args )
 482 {
 483         // Parse codes from arguments
 484         char* curArgs;
 485         char* arg1Ptr;
 486         char* arg2Ptr = args;
 487
 488         // Process all args
 489         for ( ;; )
 490         {
 491                 curArgs = arg2Ptr;
 492                 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
 493
 494                 // Stop processing args if no more are found
 495                 if ( *arg1Ptr == '\0' )
 496                         break;
 497
 498                 // Ignore non-Scancode numbers
 499                 switch ( arg1Ptr[0] )
 500                 {
 501                 // Scancode
 502                 case 'S':
 503                         Macro_keyState( (uint8_t)decToInt( &arg1Ptr[1] ), 0x03 ); // Release scancode
 504                         break;
 505                 }
 506         }
 507 }
 508
 509 void cliFunc_layerLatch( char* args )
 510 {
 511         // TODO
 512 }
 513
 514 void cliFunc_layerList( char* args )
 515 {
 516         // TODO
 517 }
 518
 519 void cliFunc_layerLock( char* args )
 520 {
 521         // TODO
 522 }
 523
 524 void cliFunc_macroDebug( char* args )
 525 {
 526         // Toggle macro debug mode
 527         macroDebugMode = macroDebugMode ? 0 : 1;
 528
 529         print( NL );
 530         info_msg("Macro Debug Mode: ");
 531         printInt8( macroDebugMode );
 532 }
 533
 534 void cliFunc_macroList( char* args )
 535 {
 536         // Show available trigger macro indices
 537         print( NL );
 538         info_msg("Trigger Macros Range: T0 -> T");
 539         printInt16( (uint16_t)TriggerMacroNum - 1 ); // Hopefully large enough :P (can't assume 32-bit)
 540
 541         // Show available result macro indices
 542         print( NL );
 543         info_msg("Result  Macros Range: R0 -> R");
 544         printInt16( (uint16_t)ResultMacroNum - 1 ); // Hopefully large enough :P (can't assume 32-bit)
 545
 546         // Show Trigger to Result Macro Links
 547         print( NL );
 548         info_msg("Trigger : Result Macro Pairs");
 549         for ( unsigned int macro = 0; macro < TriggerMacroNum; macro++ )
 550         {
 551                 print( NL );
 552                 print("\tT");
 553                 printInt16( (uint16_t)macro ); // Hopefully large enough :P (can't assume 32-bit)
 554                 print(" : R");
 555                 printInt16( (uint16_t)TriggerMacroList[ macro ].result ); // Hopefully large enough :P (can't assume 32-bit)
 556         }
 557 }
 558
 559 void cliFunc_macroProc( char* args )
 560 {
 561         // Toggle macro pause mode
 562         macroPauseMode = macroPauseMode ? 0 : 1;
 563
 564         print( NL );
 565         info_msg("Macro Processing Mode: ");
 566         printInt8( macroPauseMode );
 567 }
 568
 569 void macroDebugShowTrigger( unsigned int index )
 570 {
 571         // Only proceed if the macro exists
 572         if ( index >= TriggerMacroNum )
 573                 return;
 574
 575         // Trigger Macro Show
 576         TriggerMacro *macro = &TriggerMacroList[ index ];
 577
 578         print( NL );
 579         info_msg("Trigger Macro Index: ");
 580         printInt16( (uint16_t)index ); // Hopefully large enough :P (can't assume 32-bit)
 581         print( NL );
 582
 583         // Read the comboLength for combo in the sequence (sequence of combos)
 584         unsigned int pos = 0;
 585         uint8_t comboLength = macro->guide[ pos ];
 586
 587         // Iterate through and interpret the guide
 588         while ( comboLength != 0 )
 589         {
 590                 // Initial position of the combo
 591                 unsigned int comboPos = ++pos;
 592
 593                 // Iterate through the combo
 594                 while ( pos < comboLength * TriggerGuideSize + comboPos )
 595                 {
 596                         // Assign TriggerGuide element (key type, state and scancode)
 597                         TriggerGuide *guide = (TriggerGuide*)(&macro->guide[ pos ]);
 598
 599                         // Display guide information about trigger key
 600                         printHex( guide->scancode );
 601                         print("|");
 602                         printHex( guide->type );
 603                         print("|");
 604                         printHex( guide->state );
 605
 606                         // Increment position
 607                         pos += TriggerGuideSize;
 608
 609                         // Only show combo separator if there are combos left in the sequence element
 610                         if ( pos < comboLength * TriggerGuideSize + comboPos )
 611                                 print("+");
 612                 }
 613
 614                 // Read the next comboLength
 615                 comboLength = macro->guide[ pos ];
 616
 617                 // Only show sequence separator if there is another combo to process
 618                 if ( comboLength != 0 )
 619                         print(";");
 620         }
 621
 622         // Display current position
 623         print( NL "Position: " );
 624         printInt16( (uint16_t)macro->pos ); // Hopefully large enough :P (can't assume 32-bit)
 625
 626         // Display result macro index
 627         print( NL "Result Macro Index: " );
 628         printInt16( (uint16_t)macro->result ); // Hopefully large enough :P (can't assume 32-bit)
 629 }
 630
 631 void macroDebugShowResult( unsigned int index )
 632 {
 633         // Only proceed if the macro exists
 634         if ( index >= ResultMacroNum )
 635                 return;
 636
 637         // Trigger Macro Show
 638         ResultMacro *macro = &ResultMacroList[ index ];
 639
 640         print( NL );
 641         info_msg("Result Macro Index: ");
 642         printInt16( (uint16_t)index ); // Hopefully large enough :P (can't assume 32-bit)
 643         print( NL );
 644
 645         // Read the comboLength for combo in the sequence (sequence of combos)
 646         unsigned int pos = 0;
 647         uint8_t comboLength = macro->guide[ pos++ ];
 648
 649         // Iterate through and interpret the guide
 650         while ( comboLength != 0 )
 651         {
 652                 // Function Counter, used to keep track of the combos processed
 653                 unsigned int funcCount = 0;
 654
 655                 // Iterate through the combo
 656                 while ( funcCount < comboLength )
 657                 {
 658                         // Assign TriggerGuide element (key type, state and scancode)
 659                         ResultGuide *guide = (ResultGuide*)(&macro->guide[ pos ]);
 660
 661                         // Display Function Index
 662                         printHex( guide->index );
 663                         print("|");
 664
 665                         // Display Function Ptr Address
 666                         printHex( (unsigned int)CapabilitiesList[ guide->index ].func );
 667                         print("|");
 668
 669                         // Display/Lookup Capability Name (utilize debug mode of capability)
 670                         void (*capability)(uint8_t, uint8_t, uint8_t*) = (void(*)(uint8_t, uint8_t, uint8_t*))(CapabilitiesList[ guide->index ].func);
 671                         capability( 0xFF, 0xFF, 0 );
 672
 673                         // Display Argument(s)
 674                         print("(");
 675                         for ( unsigned int arg = 0; arg < CapabilitiesList[ guide->index ].argCount; arg++ )
 676                         {
 677                                 // Arguments are only 8 bit values
 678                                 printHex( (&guide->args)[ arg ] );
 679
 680                                 // Only show arg separator if there are args left
 681                                 if ( arg + 1 < CapabilitiesList[ guide->index ].argCount )
 682                                         print(",");
 683                         }
 684                         print(")");
 685
 686                         // Increment position
 687                         pos += ResultGuideSize( guide );
 688
 689                         // Increment function count
 690                         funcCount++;
 691
 692                         // Only show combo separator if there are combos left in the sequence element
 693                         if ( funcCount < comboLength )
 694                                 print("+");
 695                 }
 696
 697                 // Read the next comboLength
 698                 comboLength = macro->guide[ pos++ ];
 699
 700                 // Only show sequence separator if there is another combo to process
 701                 if ( comboLength != 0 )
 702                         print(";");
 703         }
 704
 705         // Display current position
 706         print( NL "Position: " );
 707         printInt16( (uint16_t)macro->pos ); // Hopefully large enough :P (can't assume 32-bit)
 708
 709         // Display final trigger state/type
 710         print( NL "Final Trigger State (State/Type): " );
 711         printHex( macro->state );
 712         print("/");
 713         printHex( macro->stateType );
 714 }
 715
 716 void cliFunc_macroShow( char* args )
 717 {
 718         // Parse codes from arguments
 719         char* curArgs;
 720         char* arg1Ptr;
 721         char* arg2Ptr = args;
 722
 723         // Process all args
 724         for ( ;; )
 725         {
 726                 curArgs = arg2Ptr;
 727                 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
 728
 729                 // Stop processing args if no more are found
 730                 if ( *arg1Ptr == '\0' )
 731                         break;
 732
 733                 // Ignore invalid codes
 734                 switch ( arg1Ptr[0] )
 735                 {
 736                 // Indexed Trigger Macro
 737                 case 'T':
 738                         macroDebugShowTrigger( decToInt( &arg1Ptr[1] ) );
 739                         break;
 740                 // Indexed Result Macro
 741                 case 'R':
 742                         macroDebugShowResult( decToInt( &arg1Ptr[1] ) );
 743                         break;
 744                 }
 745         }
 746 }
 747
 748 void cliFunc_macroStep( char* args )
 749 {
 750         // Parse number from argument
 751         //  NOTE: Only first argument is used
 752         char* arg1Ptr;
 753         char* arg2Ptr;
 754         CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr );
 755
 756         // Set the macro step counter, negative int's are cast to uint
 757         macroStepCounter = (unsigned int)decToInt( arg1Ptr );
 758 }
 759