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 capability." NL "\t\t\033[35mU10\033[0m USB Code 0x0A, \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 ]);
 385                 capability( 0xFF, 0xFF, 0 );
 386         }
 387 }
 388
 389 void cliFunc_capSelect( char* args )
 390 {
 391         // Parse code from argument
 392         //  NOTE: Only first argument is used
 393         char* arg1Ptr;
 394         char* arg2Ptr;
 395         CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr );
 396
 397         // Depending on the first character, the lookup changes
 398         switch ( arg1Ptr[0] )
 399         {
 400         // Keyboard Capability
 401         case 'K':
 402                 // TODO
 403                 break;
 404
 405         // USB Code
 406         case 'U':
 407                 // Just add the key to the USB Buffer
 408                 if ( KeyIndex_BufferUsed < KEYBOARD_BUFFER )
 409                 {
 410                         KeyIndex_Buffer[KeyIndex_BufferUsed++] = decToInt( &arg1Ptr[1] );
 411                 }
 412                 break;
 413         }
 414 }
 415
 416 void cliFunc_keyPress( char* args )
 417 {
 418         // Parse codes from arguments
 419         char* curArgs;
 420         char* arg1Ptr;
 421         char* arg2Ptr = args;
 422
 423         // Process all args
 424         for ( ;; )
 425         {
 426                 curArgs = arg2Ptr;
 427                 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
 428
 429                 // Stop processing args if no more are found
 430                 if ( *arg1Ptr == '\0' )
 431                         break;
 432
 433                 // Ignore non-Scancode numbers
 434                 switch ( arg1Ptr[0] )
 435                 {
 436                 // Scancode
 437                 case 'S':
 438                         Macro_keyState( (uint8_t)decToInt( &arg1Ptr[1] ), 0x01 ); // Press scancode
 439                         break;
 440                 }
 441         }
 442 }
 443
 444 void cliFunc_keyRelease( char* args )
 445 {
 446         // Parse codes from arguments
 447         char* curArgs;
 448         char* arg1Ptr;
 449         char* arg2Ptr = args;
 450
 451         // Process all args
 452         for ( ;; )
 453         {
 454                 curArgs = arg2Ptr;
 455                 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
 456
 457                 // Stop processing args if no more are found
 458                 if ( *arg1Ptr == '\0' )
 459                         break;
 460
 461                 // Ignore non-Scancode numbers
 462                 switch ( arg1Ptr[0] )
 463                 {
 464                 // Scancode
 465                 case 'S':
 466                         Macro_keyState( (uint8_t)decToInt( &arg1Ptr[1] ), 0x03 ); // Release scancode
 467                         break;
 468                 }
 469         }
 470 }
 471
 472 void cliFunc_layerLatch( char* args )
 473 {
 474         // TODO
 475 }
 476
 477 void cliFunc_layerList( char* args )
 478 {
 479         // TODO
 480 }
 481
 482 void cliFunc_layerLock( char* args )
 483 {
 484         // TODO
 485 }
 486
 487 void cliFunc_macroDebug( char* args )
 488 {
 489         // Toggle macro debug mode
 490         macroDebugMode = macroDebugMode ? 0 : 1;
 491
 492         print( NL );
 493         info_msg("Macro Debug Mode: ");
 494         printInt8( macroDebugMode );
 495 }
 496
 497 void cliFunc_macroList( char* args )
 498 {
 499         // Show available trigger macro indices
 500         print( NL );
 501         info_msg("Trigger Macros Range: T0 -> T");
 502         printInt16( (uint16_t)TriggerMacroNum - 1 ); // Hopefully large enough :P (can't assume 32-bit)
 503
 504         // Show available result macro indices
 505         print( NL );
 506         info_msg("Result  Macros Range: R0 -> R");
 507         printInt16( (uint16_t)ResultMacroNum - 1 ); // Hopefully large enough :P (can't assume 32-bit)
 508
 509         // Show Trigger to Result Macro Links
 510         print( NL );
 511         info_msg("Trigger : Result Macro Pairs");
 512         for ( unsigned int macro = 0; macro < TriggerMacroNum; macro++ )
 513         {
 514                 print( NL );
 515                 print("\tT");
 516                 printInt16( (uint16_t)macro ); // Hopefully large enough :P (can't assume 32-bit)
 517                 print(" : R");
 518                 printInt16( (uint16_t)TriggerMacroList[ macro ].result ); // Hopefully large enough :P (can't assume 32-bit)
 519         }
 520 }
 521
 522 void cliFunc_macroProc( char* args )
 523 {
 524         // Toggle macro pause mode
 525         macroPauseMode = macroPauseMode ? 0 : 1;
 526
 527         print( NL );
 528         info_msg("Macro Processing Mode: ");
 529         printInt8( macroPauseMode );
 530 }
 531
 532 void macroDebugShowTrigger( unsigned int index )
 533 {
 534         // Only proceed if the macro exists
 535         if ( index >= TriggerMacroNum )
 536                 return;
 537
 538         // Trigger Macro Show
 539         TriggerMacro *macro = &TriggerMacroList[ index ];
 540
 541         print( NL );
 542         info_msg("Trigger Macro Index: ");
 543         printInt16( (uint16_t)index ); // Hopefully large enough :P (can't assume 32-bit)
 544         print( NL );
 545
 546         // Read the comboLength for combo in the sequence (sequence of combos)
 547         unsigned int pos = 0;
 548         uint8_t comboLength = macro->guide[ pos ];
 549
 550         // Iterate through and interpret the guide
 551         while ( comboLength != 0 )
 552         {
 553                 // Initial position of the combo
 554                 unsigned int comboPos = ++pos;
 555
 556                 // Iterate through the combo
 557                 while ( pos < comboLength * TriggerGuideSize + comboPos )
 558                 {
 559                         // Assign TriggerGuide element (key type, state and scancode)
 560                         TriggerGuide *guide = (TriggerGuide*)(&macro->guide[ pos ]);
 561
 562                         // Display guide information about trigger key
 563                         printHex( guide->scancode );
 564                         print("|");
 565                         printHex( guide->type );
 566                         print("|");
 567                         printHex( guide->state );
 568
 569                         // Increment position
 570                         pos += TriggerGuideSize;
 571
 572                         // Only show combo separator if there are combos left in the sequence element
 573                         if ( pos < comboLength * TriggerGuideSize + comboPos )
 574                                 print("+");
 575                 }
 576
 577                 // Read the next comboLength
 578                 comboLength = macro->guide[ pos ];
 579
 580                 // Only show sequence separator if there is another combo to process
 581                 if ( comboLength != 0 )
 582                         print(";");
 583         }
 584
 585         // Display current position
 586         print( NL "Position: " );
 587         printInt16( (uint16_t)macro->pos ); // Hopefully large enough :P (can't assume 32-bit)
 588
 589         // Display result macro index
 590         print( NL "Result Macro Index: " );
 591         printInt16( (uint16_t)macro->result ); // Hopefully large enough :P (can't assume 32-bit)
 592 }
 593
 594 void macroDebugShowResult( unsigned int index )
 595 {
 596         // Only proceed if the macro exists
 597         if ( index >= ResultMacroNum )
 598                 return;
 599
 600         // Trigger Macro Show
 601         ResultMacro *macro = &ResultMacroList[ index ];
 602
 603         print( NL );
 604         info_msg("Result Macro Index: ");
 605         printInt16( (uint16_t)index ); // Hopefully large enough :P (can't assume 32-bit)
 606         print( NL );
 607
 608         // Read the comboLength for combo in the sequence (sequence of combos)
 609         unsigned int pos = 0;
 610         uint8_t comboLength = macro->guide[ pos++ ];
 611
 612         // Iterate through and interpret the guide
 613         while ( comboLength != 0 )
 614         {
 615                 // Function Counter, used to keep track of the combos processed
 616                 unsigned int funcCount = 0;
 617
 618                 // Iterate through the combo
 619                 while ( funcCount < comboLength )
 620                 {
 621                         // Assign TriggerGuide element (key type, state and scancode)
 622                         ResultGuide *guide = (ResultGuide*)(&macro->guide[ pos ]);
 623
 624                         // Display Function Index
 625                         printHex( guide->index );
 626                         print("|");
 627
 628                         // Display Function Ptr Address
 629                         printHex( (unsigned int)CapabilitiesList[ guide->index ] );
 630                         print("|");
 631
 632                         // Display/Lookup Capability Name (utilize debug mode of capability)
 633                         void (*capability)(uint8_t, uint8_t, uint8_t*) = (void(*)(uint8_t, uint8_t, uint8_t*))(CapabilitiesList[ guide->index ]);
 634                         capability( 0xFF, 0xFF, 0 );
 635
 636                         // Display Argument(s)
 637                         print("(");
 638                         for ( unsigned int arg = 0; arg < guide->argCount; arg++ )
 639                         {
 640                                 // Arguments are only 8 bit values
 641                                 printHex( (&guide->args)[ arg ] );
 642
 643                                 // Only show arg separator if there are args left
 644                                 if ( arg + 1 < guide->argCount )
 645                                         print(",");
 646                         }
 647                         print(")");
 648
 649                         // Increment position
 650                         pos += ResultGuideSize( guide );
 651
 652                         // Increment function count
 653                         funcCount++;
 654
 655                         // Only show combo separator if there are combos left in the sequence element
 656                         if ( funcCount < comboLength )
 657                                 print("+");
 658                 }
 659
 660                 // Read the next comboLength
 661                 comboLength = macro->guide[ pos++ ];
 662
 663                 // Only show sequence separator if there is another combo to process
 664                 if ( comboLength != 0 )
 665                         print(";");
 666         }
 667
 668         // Display current position
 669         print( NL "Position: " );
 670         printInt16( (uint16_t)macro->pos ); // Hopefully large enough :P (can't assume 32-bit)
 671
 672         // Display final trigger state/type
 673         print( NL "Final Trigger State (State/Type): " );
 674         printHex( macro->state );
 675         print("/");
 676         printHex( macro->stateType );
 677 }
 678
 679 void cliFunc_macroShow( char* args )
 680 {
 681         // Parse codes from arguments
 682         char* curArgs;
 683         char* arg1Ptr;
 684         char* arg2Ptr = args;
 685
 686         // Process all args
 687         for ( ;; )
 688         {
 689                 curArgs = arg2Ptr;
 690                 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
 691
 692                 // Stop processing args if no more are found
 693                 if ( *arg1Ptr == '\0' )
 694                         break;
 695
 696                 // Ignore invalid codes
 697                 switch ( arg1Ptr[0] )
 698                 {
 699                 // Indexed Trigger Macro
 700                 case 'T':
 701                         macroDebugShowTrigger( decToInt( &arg1Ptr[1] ) );
 702                         break;
 703                 // Indexed Result Macro
 704                 case 'R':
 705                         macroDebugShowResult( decToInt( &arg1Ptr[1] ) );
 706                         break;
 707                 }
 708         }
 709 }
 710
 711 void cliFunc_macroStep( char* args )
 712 {
 713         // Parse number from argument
 714         //  NOTE: Only first argument is used
 715         char* arg1Ptr;
 716         char* arg2Ptr;
 717         CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr );
 718
 719         // Set the macro step counter, negative int's are cast to uint
 720         macroStepCounter = (unsigned int)decToInt( arg1Ptr );
 721 }
 722