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