X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=Macro%2FPartialMap%2Fmacro.c;h=b81c76a267d64c93b185c0af20c96879808e09ab;hb=c7934c7224b5289f443b50a0428559f52f986635;hp=50cee843c0e5eb0844143a1f8bab87861c84b958;hpb=d6345c307fa4c64deb3f293fe91760f05c928120;p=kiibohd-controller.git diff --git a/Macro/PartialMap/macro.c b/Macro/PartialMap/macro.c index 50cee84..b81c76a 100644 --- a/Macro/PartialMap/macro.c +++ b/Macro/PartialMap/macro.c @@ -24,12 +24,12 @@ #include #include #include -#include // Keymaps #include "usb_hid.h" #include -#include "generatedKeymap.h" // TODO Use actual generated version +#include "templateKeymap.h" // TODO Use actual generated version +//#include "generatedKeymap.h" // TODO Use actual generated version // Local Includes #include "macro.h" @@ -40,6 +40,7 @@ void cliFunc_capList ( char* args ); void cliFunc_capSelect ( char* args ); +void cliFunc_keyHold ( char* args ); void cliFunc_keyPress ( char* args ); void cliFunc_keyRelease( char* args ); void cliFunc_layerList ( char* args ); @@ -52,15 +53,43 @@ void cliFunc_macroStep ( char* args ); +// ----- Enums ----- + +// Bit positions are important, passes (correct key) always trump incorrect key votes +typedef enum TriggerMacroVote { + TriggerMacroVote_Release = 0x10, // Correct key + TriggerMacroVote_PassRelease = 0x18, // Correct key (both pass and release) + TriggerMacroVote_Pass = 0x8, // Correct key + TriggerMacroVote_DoNothingRelease = 0x4, // Incorrect key + TriggerMacroVote_DoNothing = 0x2, // Incorrect key + TriggerMacroVote_Fail = 0x1, // Incorrect key + TriggerMacroVote_Invalid = 0x0, // Invalid state +} TriggerMacroVote; + +typedef enum TriggerMacroEval { + TriggerMacroEval_DoNothing, + TriggerMacroEval_DoResult, + TriggerMacroEval_DoResultAndRemove, + TriggerMacroEval_Remove, +} TriggerMacroEval; + +typedef enum ResultMacroEval { + ResultMacroEval_DoNothing, + ResultMacroEval_Remove, +} ResultMacroEval; + + + // ----- Variables ----- // Macro Module command dictionary -char* macroCLIDictName = "Macro Module Commands"; -CLIDictItem macroCLIDict[] = { +const char macroCLIDictName[] = "Macro Module Commands"; +const CLIDictItem macroCLIDict[] = { { "capList", "Prints an indexed list of all non USB keycode capabilities.", cliFunc_capList }, { "capSelect", "Triggers the specified capabilities. First two args are state and stateType." NL "\t\t\033[35mK11\033[0m Keyboard Capability 0x0B", cliFunc_capSelect }, - { "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 }, - { "keyRelease", "Release a key-press from the macro module. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A", cliFunc_keyRelease }, + { "keyHold", "Send key-hold events to the macro module. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A", cliFunc_keyHold }, + { "keyPress", "Send key-press events to the macro module. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A", cliFunc_keyPress }, + { "keyRelease", "Send key-release event to macro module. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A", cliFunc_keyRelease }, { "layerList", "List available layers.", cliFunc_layerList }, { "layerState", "Modify specified indexed layer state ." NL "\t\t\033[35mL2\033[0m Indexed Layer 0x02" NL "\t\t0 Off, 1 Shift, 2 Latch, 4 Lock States", cliFunc_layerState }, { "macroDebug", "Disables/Enables sending USB keycodes to the Output Module and prints U/K codes.", cliFunc_macroDebug }, @@ -96,7 +125,7 @@ unsigned int macroTriggerMacroPendingListSize = 0; // Layer Index Stack // * When modifying layer state and the state is non-0x0, the stack must be adjusted -unsigned int macroLayerIndexStack[ LayerNum ] = { 0 }; +unsigned int macroLayerIndexStack[ LayerNum + 1 ] = { 0 }; unsigned int macroLayerIndexStackSize = 0; // Pending Result Macro Index List @@ -106,25 +135,201 @@ unsigned int macroResultMacroPendingListSize = 0; +// ----- Capabilities ----- + +// Sets the given layer with the specified layerState +void Macro_layerState( uint8_t state, uint8_t stateType, uint16_t layer, uint8_t layerState ) +{ + // Is layer in the LayerIndexStack? + uint8_t inLayerIndexStack = 0; + unsigned int stackItem = 0; + while ( stackItem < macroLayerIndexStackSize ) + { + // Flag if layer is already in the LayerIndexStack + if ( macroLayerIndexStack[ stackItem ] == layer ) + { + inLayerIndexStack = 1; + break; + } + + // Increment to next item + stackItem++; + } + + // Toggle Layer State Byte + if ( LayerIndex[ layer ].state & layerState ) + { + // Unset + LayerIndex[ layer ].state &= ~layerState; + } + else + { + // Set + LayerIndex[ layer ].state |= layerState; + } + + // If the layer was not in the LayerIndexStack add it + if ( !inLayerIndexStack ) + { + macroLayerIndexStack[ macroLayerIndexStackSize++ ] = layer; + } + + // If the layer is in the LayerIndexStack and the state is 0x00, remove + if ( LayerIndex[ layer ].state == 0x00 && inLayerIndexStack ) + { + // Remove the layer from the LayerIndexStack + // Using the already positioned stackItem variable from the loop above + while ( stackItem < macroLayerIndexStackSize ) + { + macroLayerIndexStack[ stackItem ] = macroLayerIndexStack[ stackItem + 1 ]; + stackItem++; + } + + // Reduce LayerIndexStack size + macroLayerIndexStackSize--; + } +} + +// Modifies the specified Layer control byte +// Argument #1: Layer Index -> uint16_t +// Argument #2: Layer State -> uint8_t +void Macro_layerState_capability( uint8_t state, uint8_t stateType, uint8_t *args ) +{ + // Display capability name + if ( stateType == 0xFF && state == 0xFF ) + { + print("Macro_layerState(layerIndex,layerState)"); + return; + } + + // Only use capability on press or release + // TODO Analog + // XXX This may cause issues, might be better to implement state table here to decide -HaaTa + if ( stateType == 0x00 && state == 0x02 ) // Hold condition + return; + + // Get layer index from arguments + // Cast pointer to uint8_t to unsigned int then access that memory location + uint16_t layer = *(uint16_t*)(&args[0]); + + // Get layer toggle byte + uint8_t layerState = args[ sizeof(uint16_t) ]; + + Macro_layerState( state, stateType, layer, layerState ); +} + + +// Latches given layer +// Argument #1: Layer Index -> uint16_t +void Macro_layerLatch_capability( uint8_t state, uint8_t stateType, uint8_t *args ) +{ + // Display capability name + if ( stateType == 0xFF && state == 0xFF ) + { + print("Macro_layerLatch(layerIndex)"); + return; + } + + // Only use capability on press + // TODO Analog + // XXX To make sense, this code be on press or release. Or it could even be a sticky shift (why? dunno) -HaaTa + if ( stateType == 0x00 && state != 0x01 ) // All normal key conditions except press + return; + + // Get layer index from arguments + // Cast pointer to uint8_t to unsigned int then access that memory location + uint16_t layer = *(uint16_t*)(&args[0]); + + Macro_layerState( state, stateType, layer, 0x02 ); +} + + +// Locks given layer +// Argument #1: Layer Index -> uint16_t +void Macro_layerLock_capability( uint8_t state, uint8_t stateType, uint8_t *args ) +{ + // Display capability name + if ( stateType == 0xFF && state == 0xFF ) + { + print("Macro_layerLock(layerIndex)"); + return; + } + + // Only use capability on press + // TODO Analog + // XXX Could also be on release, but that's sorta dumb -HaaTa + if ( stateType == 0x00 && state != 0x01 ) // All normal key conditions except press + return; + + // Get layer index from arguments + // Cast pointer to uint8_t to unsigned int then access that memory location + uint16_t layer = *(uint16_t*)(&args[0]); + + Macro_layerState( state, stateType, layer, 0x04 ); +} + + +// Shifts given layer +// Argument #1: Layer Index -> uint16_t +void Macro_layerShift_capability( uint8_t state, uint8_t stateType, uint8_t *args ) +{ + // Display capability name + if ( stateType == 0xFF && state == 0xFF ) + { + print("Macro_layerShift(layerIndex)"); + return; + } + + // Only use capability on press or release + // TODO Analog + if ( stateType == 0x00 && ( state == 0x00 || state == 0x02 ) ) // Only pass press or release conditions + return; + + // Get layer index from arguments + // Cast pointer to uint8_t to unsigned int then access that memory location + uint16_t layer = *(uint16_t*)(&args[0]); + + Macro_layerState( state, stateType, layer, 0x01 ); +} + + + // ----- Functions ----- // Looks up the trigger list for the given scan code (from the active layer) // NOTE: Calling function must handle the NULL pointer case -unsigned int *Macro_layerLookup( uint8_t scanCode ) +nat_ptr_t *Macro_layerLookup( uint8_t scanCode ) { // If no trigger macro is defined at the given layer, fallthrough to the next layer - for ( unsigned int layer = 0; layer < macroLayerIndexStackSize; layer++ ) + for ( unsigned int layerIndex = 0; layerIndex < macroLayerIndexStackSize; layerIndex++ ) { - // Lookup layer - unsigned int **map = LayerIndex[ macroLayerIndexStack[ layer ] ].triggerMap; + // Lookup Layer + Layer *layer = &LayerIndex[ macroLayerIndexStack[ layerIndex ] ]; - // Determine if layer has key defined - if ( map != 0 && *map[ scanCode ] != 0 ) - return map[ scanCode ]; + // Check if latch has been pressed for this layer + // XXX Regardless of whether a key is found, the latch is removed on first lookup + uint8_t latch = layer->state & 0x02; + if ( latch ) + { + layer->state &= ~0x02; + } + + // Only use layer, if state is valid + // XOR each of the state bits + // If only two are enabled, do not use this state + if ( (layer->state & 0x01) ^ (latch>>1) ^ ((layer->state & 0x04)>>2) ) + { + // Lookup layer + nat_ptr_t **map = (nat_ptr_t**)layer->triggerMap; + + // Determine if layer has key defined + if ( map != 0 && *map[ scanCode ] != 0 ) + return map[ scanCode ]; + } } // Do lookup on default layer - unsigned int **map = LayerIndex[0].triggerMap; + nat_ptr_t **map = (nat_ptr_t**)LayerIndex[0].triggerMap; // Determine if layer has key defined if ( map == 0 && *map[ scanCode ] == 0 ) @@ -198,153 +403,528 @@ inline void Macro_ledState( uint8_t ledCode, uint8_t state ) } +// Append result macro to pending list, checking for duplicates +// Do nothing if duplicate +inline void Macro_appendResultMacroToPendingList( TriggerMacro *triggerMacro ) +{ + // Lookup result macro index + unsigned int resultMacroIndex = triggerMacro->result; + + // Iterate through result macro pending list, making sure this macro hasn't been added yet + for ( unsigned int macro = 0; macro < macroResultMacroPendingListSize; macro++ ) + { + // If duplicate found, do nothing + if ( macroResultMacroPendingList[ macro ] == resultMacroIndex ) + return; + } + + // No duplicates found, add to pending list + macroResultMacroPendingList[ macroResultMacroPendingListSize++ ] = resultMacroIndex; + + // Lookup scanCode of the last key in the last combo + unsigned int pos = 0; + for ( uint8_t comboLength = triggerMacro->guide[0]; comboLength > 0; ) + { + pos += TriggerGuideSize * comboLength + 1; + comboLength = triggerMacro->guide[ pos ]; + } + + uint8_t scanCode = ((TriggerGuide*)&triggerMacro->guide[ pos - TriggerGuideSize ])->scanCode; + + // Lookup scanCode in buffer list for the current state and stateType + for ( uint8_t keyIndex = 0; keyIndex < macroTriggerListBufferSize; keyIndex++ ) + { + if ( macroTriggerListBuffer[ keyIndex ].scanCode == scanCode ) + { + ResultMacroList[ resultMacroIndex ].state = macroTriggerListBuffer[ keyIndex ].state; + ResultMacroList[ resultMacroIndex ].stateType = macroTriggerListBuffer[ keyIndex ].type; + } + } + + // Reset the macro position + ResultMacroList[ resultMacroIndex ].pos = 0; +} + + +// Determine if long ResultMacro (more than 1 seqence element) +inline uint8_t Macro_isLongResultMacro( ResultMacro *macro ) +{ + // Check the second sequence combo length + // If non-zero return non-zero (long sequence) + // 0 otherwise (short sequence) + unsigned int position = 1; + for ( unsigned int result = 0; result < macro->guide[0]; result++ ) + position += ResultGuideSize( (ResultGuide*)¯o->guide[ position ] ); + return macro->guide[ position ]; +} + + +// Determine if long TriggerMacro (more than 1 sequence element) +inline uint8_t Macro_isLongTriggerMacro( TriggerMacro *macro ) +{ + // Check the second sequence combo length + // If non-zero return non-zero (long sequence) + // 0 otherwise (short sequence) + return macro->guide[ macro->guide[0] * TriggerGuideSize + 1 ]; +} + + +// Votes on the given key vs. guide, short macros +inline TriggerMacroVote Macro_evalShortTriggerMacroVote( TriggerGuide *key, TriggerGuide *guide ) +{ + // Depending on key type + switch ( guide->type ) + { + // Normal State Type + case 0x00: + // For short TriggerMacros completely ignore incorrect keys + if ( guide->scanCode == key->scanCode ) + { + switch ( key->state ) + { + // Correct key, pressed, possible passing + case 0x01: + return TriggerMacroVote_Pass; + + // Correct key, held, possible passing or release + case 0x02: + return TriggerMacroVote_PassRelease; + + // Correct key, released, possible release + case 0x03: + return TriggerMacroVote_Release; + } + } + + return TriggerMacroVote_DoNothing; + + // LED State Type + case 0x01: + erro_print("LED State Type - Not implemented..."); + break; + + // Analog State Type + case 0x02: + erro_print("Analog State Type - Not implemented..."); + break; + + // Invalid State Type + default: + erro_print("Invalid State Type. This is a bug."); + break; + } + + // XXX Shouldn't reach here + return TriggerMacroVote_Invalid; +} + + +// Votes on the given key vs. guide, long macros +// A long macro is defined as a guide with more than 1 combo +inline TriggerMacroVote Macro_evalLongTriggerMacroVote( TriggerGuide *key, TriggerGuide *guide ) +{ + // Depending on key type + switch ( guide->type ) + { + // Normal State Type + case 0x00: + // Depending on the state of the buffered key, make voting decision + // Incorrect key + if ( guide->scanCode != key->scanCode ) + { + switch ( key->state ) + { + // Wrong key, pressed, fail + case 0x01: + return TriggerMacroVote_Fail; + + // Wrong key, held, do not pass (no effect) + case 0x02: + return TriggerMacroVote_DoNothing; + + // Wrong key released, fail out if pos == 0 + case 0x03: + return TriggerMacroVote_DoNothing | TriggerMacroVote_DoNothingRelease; + } + } + + // Correct key + else + { + switch ( key->state ) + { + // Correct key, pressed, possible passing + case 0x01: + return TriggerMacroVote_Pass; + + // Correct key, held, possible passing or release + case 0x02: + return TriggerMacroVote_PassRelease; + + // Correct key, released, possible release + case 0x03: + return TriggerMacroVote_Release; + } + } + + break; + + // LED State Type + case 0x01: + erro_print("LED State Type - Not implemented..."); + break; + + // Analog State Type + case 0x02: + erro_print("Analog State Type - Not implemented..."); + break; + + // Invalid State Type + default: + erro_print("Invalid State Type. This is a bug."); + break; + } + + // XXX Shouldn't reach here + return TriggerMacroVote_Invalid; +} + + // Evaluate/Update TriggerMacro -void Macro_evalTriggerMacro( TriggerMacro *triggerMacro ) +inline TriggerMacroEval Macro_evalTriggerMacro( unsigned int triggerMacroIndex ) { - // Which combo in the sequence is being evaluated - unsigned int comboPos = triggerMacro->pos; + // Lookup TriggerMacro + TriggerMacro *macro = &TriggerMacroList[ triggerMacroIndex ]; + + // Check if macro has finished and should be incremented sequence elements + if ( macro->state == TriggerMacro_Release ) + { + macro->state = TriggerMacro_Waiting; + macro->pos = macro->pos + macro->guide[ macro->pos ] * TriggerGuideSize + 1; + } + + // Current Macro position + unsigned int pos = macro->pos; + + // Length of the combo being processed + uint8_t comboLength = macro->guide[ pos ] * TriggerGuideSize; - // If combo length is more than 1, cancel trigger macro if an incorrect key is found - uint8_t comboLength = triggerMacro->guide[ comboPos ]; + // If no combo items are left, remove the TriggerMacro from the pending list + if ( comboLength == 0 ) + { + return TriggerMacroEval_Remove; + } - // Iterate over list of keys currently pressed - for ( uint8_t keyPressed = 0; keyPressed < macroTriggerListBufferSize; keyPressed++ ) + // Check if this is a long Trigger Macro + uint8_t longMacro = Macro_isLongTriggerMacro( macro ); + + // Iterate through the items in the combo, voting the on the key state + // If any of the pressed keys do not match, fail the macro + // + // The macro is waiting for input when in the TriggerMacro_Waiting state + // Once all keys have been pressed/held (only those keys), entered TriggerMacro_Press state (passing) + // Transition to the next combo (if it exists) when a single key is released (TriggerMacro_Release state) + // On scan after position increment, change to TriggerMacro_Waiting state + // TODO Add support for system LED states (NumLock, CapsLock, etc.) + // TODO Add support for analog key states + // TODO Add support for 0x00 Key state (not pressing a key, not all that useful in general) + // TODO Add support for Press/Hold/Release differentiation when evaluating (not sure if useful) + TriggerMacroVote overallVote = TriggerMacroVote_Invalid; + for ( uint8_t comboItem = pos + 1; comboItem < pos + comboLength + 1; comboItem += TriggerGuideSize ) { - // Compare with keys in combo - for ( unsigned int comboKey = 0; comboKey < comboLength; comboKey++ ) + // Assign TriggerGuide element (key type, state and scancode) + TriggerGuide *guide = (TriggerGuide*)(¯o->guide[ comboItem ]); + + TriggerMacroVote vote = TriggerMacroVote_Invalid; + // Iterate through the key buffer, comparing to each key in the combo + for ( uint8_t key = 0; key < macroTriggerListBufferSize; key++ ) { - // Lookup key in combo - uint8_t guideKey = triggerMacro->guide[ comboPos + comboKey + 2 ]; // TODO Only Press/Hold/Release atm + // Lookup key information + TriggerGuide *keyInfo = ¯oTriggerListBuffer[ key ]; + + // If vote is a pass (>= 0x08, no more keys in the combo need to be looked at) + // Also mask all of the non-passing votes + vote |= longMacro + ? Macro_evalLongTriggerMacroVote( keyInfo, guide ) + : Macro_evalShortTriggerMacroVote( keyInfo, guide ); + if ( vote >= TriggerMacroVote_Pass ) + { + vote &= TriggerMacroVote_Release | TriggerMacroVote_PassRelease | TriggerMacroVote_Pass; + break; + } + } + + // If no pass vote was found after scanning all of the keys + // Fail the combo, if this is a short macro (long macros already will have a fail vote) + if ( !longMacro && vote < TriggerMacroVote_Pass ) + vote |= TriggerMacroVote_Fail; + + // After voting, append to overall vote + overallVote |= vote; + } + + // If no pass vote was found after scanning the entire combo + // And this is the first position in the combo, just remove it (nothing important happened) + if ( longMacro && overallVote & TriggerMacroVote_DoNothingRelease && pos == 0 ) + overallVote |= TriggerMacroVote_Fail; - // Sequence Case - if ( comboLength == 1 ) + // Decide new state of macro after voting + // Fail macro, remove from pending list + if ( overallVote & TriggerMacroVote_Fail ) + { + return TriggerMacroEval_Remove; + } + // Do nothing, incorrect key is being held or released + else if ( overallVote & TriggerMacroVote_DoNothing && longMacro ) + { + // Just doing nothing :) + } + // If passing and in Waiting state, set macro state to Press + else if ( overallVote & TriggerMacroVote_Pass + && ( macro->state == TriggerMacro_Waiting || macro->state == TriggerMacro_Press ) ) + { + macro->state = TriggerMacro_Press; + + // If in press state, and this is the final combo, send request for ResultMacro + // Check to see if the result macro only has a single element + // If this result macro has more than 1 key, only send once + // TODO Add option to have long macro repeat rate + if ( macro->guide[ pos + comboLength + 1 ] == 0 ) + { + // Long result macro (more than 1 combo) + if ( Macro_isLongResultMacro( &ResultMacroList[ macro->result ] ) ) { - // If key matches and only 1 key pressed, increment the TriggerMacro combo position - if ( guideKey == macroTriggerListBuffer[ keyPressed ].scanCode && macroTriggerListBufferSize == 1 ) + // Only ever trigger result once, on press + if ( overallVote == TriggerMacroVote_Pass ) { - triggerMacro->pos += comboLength * 2 + 1; - // TODO check if TriggerMacro is finished, register ResultMacro - return; + return TriggerMacroEval_DoResultAndRemove; } - - // If key does not match or more than 1 key pressed, reset the TriggerMacro combo position - triggerMacro->pos = 0; - return; } - // Combo Case + // Short result macro else { - // TODO + // Only trigger result once, on press, if long trigger (more than 1 combo) + if ( Macro_isLongTriggerMacro( macro ) ) + { + return TriggerMacroEval_DoResultAndRemove; + } + // Otherwise, trigger result continuously + else + { + return TriggerMacroEval_DoResult; + } } } } + // If ready for transition and in Press state, set to Waiting and increment combo position + // Position is incremented (and possibly remove the macro from the pending list) on the next iteration + else if ( overallVote & TriggerMacroVote_Release && macro->state == TriggerMacro_Press ) + { + macro->state = TriggerMacro_Release; + + // If this is the last combo in the sequence, remove from the pending list + if ( macro->guide[ macro->pos + macro->guide[ macro->pos ] * TriggerGuideSize + 1 ] == 0 ) + return TriggerMacroEval_Remove; + } + // Otherwise, just remove the macro on key release + // One more result has to be called to indicate to the ResultMacro that the key transitioned to the release state + else if ( overallVote & TriggerMacroVote_Release ) + { + return TriggerMacroEval_DoResultAndRemove; + } + + // If this is a short macro, just remove it + // The state can be rebuilt on the next iteration + if ( !longMacro ) + return TriggerMacroEval_Remove; + + return TriggerMacroEval_DoNothing; } // Evaluate/Update ResultMacro -void Macro_evalResultMacro( ResultMacro *resultMacro ) +inline ResultMacroEval Macro_evalResultMacro( unsigned int resultMacroIndex ) { - // TODO -} + // Lookup ResultMacro + ResultMacro *macro = &ResultMacroList[ resultMacroIndex ]; + // Current Macro position + unsigned int pos = macro->pos; -// Macro Procesing Loop -// Called once per USB buffer send -inline void Macro_process() -{ - // Only do one round of macro processing between Output Module timer sends - if ( USBKeys_Sent != 0 ) - return; + // Length of combo being processed + uint8_t comboLength = macro->guide[ pos ]; - // If the pause flag is set, only process if the step counter is non-zero - if ( macroPauseMode && macroStepCounter == 0 ) + // Function Counter, used to keep track of the combo items processed + unsigned int funcCount = 0; + + // Combo Item Position within the guide + unsigned int comboItem = pos + 1; + + // Iterate through the Result Combo + while ( funcCount < comboLength ) { - return; + // Assign TriggerGuide element (key type, state and scancode) + ResultGuide *guide = (ResultGuide*)(¯o->guide[ comboItem ]); + + // Do lookup on capability function + void (*capability)(uint8_t, uint8_t, uint8_t*) = (void(*)(uint8_t, uint8_t, uint8_t*))(CapabilitiesList[ guide->index ].func); + + // Call capability + capability( macro->state, macro->stateType, &guide->args ); + + // Increment counters + funcCount++; + comboItem += ResultGuideSize( (ResultGuide*)(¯o->guide[ comboItem ]) ); } - // Proceed, decrementing the step counter - else + + // Move to next item in the sequence + macro->pos = comboItem; + + // If the ResultMacro is finished, remove + if ( macro->guide[ comboItem ] == 0 ) { - macroStepCounter--; + return ResultMacroEval_Remove; } - // Loop through macro trigger buffer - for ( uint8_t index = 0; index < macroTriggerListBufferSize; index++ ) - { - // Get scanCode, first item of macroTriggerListBuffer pairs - uint8_t scanCode = macroTriggerListBuffer[ index ].scanCode; + // Otherwise leave the macro in the list + return ResultMacroEval_DoNothing; +} - // Lookup trigger list for this key - unsigned int *triggerList = Macro_layerLookup( scanCode ); - // Skip, if no trigger list - if ( triggerList == 0 ) +// Update pending trigger list +inline void Macro_updateTriggerMacroPendingList() +{ + // Iterate over the macroTriggerListBuffer to add any new Trigger Macros to the pending list + for ( uint8_t key = 0; key < macroTriggerListBufferSize; key++ ) + { + // TODO LED States + // TODO Analog Switches + // Only add TriggerMacro to pending list if key was pressed (not held, released or off) + if ( macroTriggerListBuffer[ key ].state == 0x00 && macroTriggerListBuffer[ key ].state != 0x01 ) continue; - // The first element is the length of the trigger list - unsigned int triggerListSize = triggerList[0]; + // Lookup Trigger List + nat_ptr_t *triggerList = Macro_layerLookup( macroTriggerListBuffer[ key ].scanCode ); + + // Number of Triggers in list + nat_ptr_t triggerListSize = triggerList[0]; - // Loop through the trigger list - for ( unsigned int trigger = 0; trigger < triggerListSize; trigger++ ) + // Iterate over triggerList to see if any TriggerMacros need to be added + // First item is the number of items in the TriggerList + for ( unsigned int macro = 1; macro < triggerListSize + 1; macro++ ) { - // Lookup TriggerMacro - TriggerMacro *triggerMacro = (TriggerMacro*)triggerList[ trigger + 1 ]; + // Lookup trigger macro index + unsigned int triggerMacroIndex = triggerList[ macro ]; - // Get triggered state of scan code, second item of macroTriggerListBuffer pairs - uint8_t state = macroTriggerListBuffer[ index ].state; + // Iterate over macroTriggerMacroPendingList to see if any macro in the scancode's + // triggerList needs to be added + unsigned int pending = 0; + for ( ; pending < macroTriggerMacroPendingListSize; pending++ ) + { + // Stop scanning if the trigger macro index is found in the pending list + if ( macroTriggerMacroPendingList[ pending ] == triggerMacroIndex ) + break; + } - // Evaluate Macro - Macro_evalTriggerMacro( triggerMacro ); + // If the triggerMacroIndex (macro) was not found in the macroTriggerMacroPendingList + // Add it to the list + if ( pending == macroTriggerMacroPendingListSize ) + { + macroTriggerMacroPendingList[ macroTriggerMacroPendingListSize++ ] = triggerMacroIndex; + + // Reset macro position + TriggerMacroList[ triggerMacroIndex ].pos = 0; + TriggerMacroList[ triggerMacroIndex ].state = TriggerMacro_Waiting; + } } } +} + + +// Macro Procesing Loop +// Called once per USB buffer send +inline void Macro_process() +{ + // Only do one round of macro processing between Output Module timer sends + if ( USBKeys_Sent != 0 ) + return; + // If the pause flag is set, only process if the step counter is non-zero + if ( macroPauseMode ) + { + if ( macroStepCounter == 0 ) + return; + // Proceed, decrementing the step counter + macroStepCounter--; + dbug_print("Macro Step"); + } + // Update pending trigger list, before processing TriggerMacros + Macro_updateTriggerMacroPendingList(); + // Tail pointer for macroTriggerMacroPendingList + // Macros must be explicitly re-added + unsigned int macroTriggerMacroPendingListTail = 0; - /* TODO - // Loop through input buffer - for ( uint8_t index = 0; index < KeyIndex_BufferUsed && !macroDebugMode; index++ ) + // Iterate through the pending TriggerMacros, processing each of them + for ( unsigned int macro = 0; macro < macroTriggerMacroPendingListSize; macro++ ) { - //print(" KEYS: "); - //printInt8( KeyIndex_BufferUsed ); - // Get the keycode from the buffer - uint8_t key = KeyIndex_Buffer[index]; - - // Set the modifier bit if this key is a modifier - if ( (key & KEY_LCTRL) == KEY_LCTRL ) // AND with 0xE0 + switch ( Macro_evalTriggerMacro( macroTriggerMacroPendingList[ macro ] ) ) { - USBKeys_Modifiers |= 1 << (key ^ KEY_LCTRL); // Left shift 1 by key XOR 0xE0 + // Trigger Result Macro (purposely falling through) + case TriggerMacroEval_DoResult: + // Append ResultMacro to PendingList + Macro_appendResultMacroToPendingList( &TriggerMacroList[ macroTriggerMacroPendingList[ macro ] ] ); - // Modifier processed, move on to the next key - continue; - } + default: + macroTriggerMacroPendingList[ macroTriggerMacroPendingListTail++ ] = macroTriggerMacroPendingList[ macro ]; + break; - // Too many keys - if ( USBKeys_Sent >= USBKeys_MaxSize ) - { - warn_msg("USB Key limit reached"); - errorLED( 1 ); + // Trigger Result Macro and Remove (purposely falling through) + case TriggerMacroEval_DoResultAndRemove: + // Append ResultMacro to PendingList + Macro_appendResultMacroToPendingList( &TriggerMacroList[ macroTriggerMacroPendingList[ macro ] ] ); + + // Remove Macro from Pending List, nothing to do, removing by default + case TriggerMacroEval_Remove: break; } + } - // Allow ignoring keys with 0's - if ( key != 0 ) - { - USBKeys_Array[USBKeys_Sent++] = key; - } - else + // Update the macroTriggerMacroPendingListSize with the tail pointer + macroTriggerMacroPendingListSize = macroTriggerMacroPendingListTail; + + + // Tail pointer for macroResultMacroPendingList + // Macros must be explicitly re-added + unsigned int macroResultMacroPendingListTail = 0; + + // Iterate through the pending ResultMacros, processing each of them + for ( unsigned int macro = 0; macro < macroResultMacroPendingListSize; macro++ ) + { + switch ( Macro_evalResultMacro( macroResultMacroPendingList[ macro ] ) ) { - // Key was not mapped - erro_msg( "Key not mapped... - " ); - printHex( key ); - errorLED( 1 ); + // Re-add macros to pending list + case ResultMacroEval_DoNothing: + default: + macroResultMacroPendingList[ macroResultMacroPendingListTail++ ] = macroResultMacroPendingList[ macro ]; + break; + + // Remove Macro from Pending List, nothing to do, removing by default + case ResultMacroEval_Remove: + break; } } - */ - // Signal buffer that we've used it TODO - Scan_finishedWithMacro( 0 ); - //Scan_finishedWithBuffer( KeyIndex_BufferUsed ); + // Update the macroResultMacroPendingListSize with the tail pointer + macroResultMacroPendingListSize = macroResultMacroPendingListTail; + + // Signal buffer that we've used it + Scan_finishedWithMacro( macroTriggerListBufferSize ); + + // Reset TriggerList buffer + macroTriggerListBufferSize = 0; // If Macro debug mode is set, clear the USB Buffer if ( macroDebugMode ) @@ -371,6 +951,21 @@ inline void Macro_setup() // Make sure macro trigger buffer is empty macroTriggerListBufferSize = 0; + + // Initialize TriggerMacro states + for ( unsigned int macro = 0; macro < TriggerMacroNum; macro++ ) + { + TriggerMacroList[ macro ].pos = 0; + TriggerMacroList[ macro ].state = TriggerMacro_Waiting; + } + + // Initialize ResultMacro states + for ( unsigned int macro = 0; macro < ResultMacroNum; macro++ ) + { + ResultMacroList[ macro ].pos = 0; + ResultMacroList[ macro ].state = 0; + ResultMacroList[ macro ].stateType = 0; + } } @@ -380,6 +975,7 @@ void cliFunc_capList( char* args ) { print( NL ); info_msg("Capabilities List"); + printHex( CapabilitiesNum ); // Iterate through all of the capabilities and display them for ( unsigned int cap = 0; cap < CapabilitiesNum; cap++ ) @@ -426,7 +1022,7 @@ void cliFunc_capSelect( char* args ) // Keyboard Capability case 'K': // Determine capability index - cap = decToInt( &arg1Ptr[1] ); + cap = numToInt( &arg1Ptr[1] ); // Lookup the number of args totalArgs += CapabilitiesList[ cap ].argCount; @@ -435,7 +1031,7 @@ void cliFunc_capSelect( char* args ) // Because allocating memory isn't doable, and the argument count is arbitrary // The argument pointer is repurposed as the argument list (much smaller anyways) - argSet[ argSetCount++ ] = (uint8_t)decToInt( arg1Ptr ); + argSet[ argSetCount++ ] = (uint8_t)numToInt( arg1Ptr ); // Once all the arguments are prepared, call the keyboard capability function if ( argSetCount == totalArgs ) @@ -458,6 +1054,34 @@ void cliFunc_capSelect( char* args ) } } +void cliFunc_keyHold( char* args ) +{ + // Parse codes from arguments + char* curArgs; + char* arg1Ptr; + char* arg2Ptr = args; + + // Process all args + for ( ;; ) + { + curArgs = arg2Ptr; + CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr ); + + // Stop processing args if no more are found + if ( *arg1Ptr == '\0' ) + break; + + // Ignore non-Scancode numbers + switch ( arg1Ptr[0] ) + { + // Scancode + case 'S': + Macro_keyState( (uint8_t)numToInt( &arg1Ptr[1] ), 0x02 ); // Hold scancode + break; + } + } +} + void cliFunc_keyPress( char* args ) { // Parse codes from arguments @@ -480,7 +1104,7 @@ void cliFunc_keyPress( char* args ) { // Scancode case 'S': - Macro_keyState( (uint8_t)decToInt( &arg1Ptr[1] ), 0x01 ); // Press scancode + Macro_keyState( (uint8_t)numToInt( &arg1Ptr[1] ), 0x01 ); // Press scancode break; } } @@ -508,7 +1132,7 @@ void cliFunc_keyRelease( char* args ) { // Scancode case 'S': - Macro_keyState( (uint8_t)decToInt( &arg1Ptr[1] ), 0x03 ); // Release scancode + Macro_keyState( (uint8_t)numToInt( &arg1Ptr[1] ), 0x03 ); // Release scancode break; } } @@ -527,7 +1151,7 @@ void cliFunc_layerList( char* args ) print(" - "); // Display layer name - dPrint( LayerIndex[ layer ].name ); + dPrint( (char*)LayerIndex[ layer ].name ); // Default map if ( layer == 0 ) @@ -570,11 +1194,11 @@ void cliFunc_layerState( char* args ) if ( arg1Ptr[0] != 'L' ) return; - arg1 = (uint8_t)decToInt( &arg1Ptr[1] ); + arg1 = (uint8_t)numToInt( &arg1Ptr[1] ); break; // Second argument (e.g. 4) case 1: - arg2 = (uint8_t)decToInt( arg1Ptr ); + arg2 = (uint8_t)numToInt( arg1Ptr ); // Display operation (to indicate that it worked) print( NL ); @@ -602,6 +1226,39 @@ void cliFunc_macroDebug( char* args ) void cliFunc_macroList( char* args ) { + // Show pending key events + print( NL ); + info_msg("Pending Key Events: "); + printInt16( (uint16_t)macroTriggerListBufferSize ); + print(" : "); + for ( uint8_t key = 0; key < macroTriggerListBufferSize; key++ ) + { + printHex( macroTriggerListBuffer[ key ].scanCode ); + print(" "); + } + + // Show pending trigger macros + print( NL ); + info_msg("Pending Trigger Macros: "); + printInt16( (uint16_t)macroTriggerMacroPendingListSize ); + print(" : "); + for ( unsigned int macro = 0; macro < macroTriggerMacroPendingListSize; macro++ ) + { + printHex( macroTriggerMacroPendingList[ macro ] ); + print(" "); + } + + // Show pending result macros + print( NL ); + info_msg("Pending Result Macros: "); + printInt16( (uint16_t)macroResultMacroPendingListSize ); + print(" : "); + for ( unsigned int macro = 0; macro < macroResultMacroPendingListSize; macro++ ) + { + printHex( macroResultMacroPendingList[ macro ] ); + print(" "); + } + // Show available trigger macro indices print( NL ); info_msg("Trigger Macros Range: T0 -> T"); @@ -695,6 +1352,15 @@ void macroDebugShowTrigger( unsigned int index ) // Display result macro index print( NL "Result Macro Index: " ); printInt16( (uint16_t)macro->result ); // Hopefully large enough :P (can't assume 32-bit) + + // Display trigger macro state + print( NL "Trigger Macro State: " ); + switch ( macro->state ) + { + case TriggerMacro_Press: print("Press"); break; + case TriggerMacro_Release: print("Release"); break; + case TriggerMacro_Waiting: print("Waiting"); break; + } } void macroDebugShowResult( unsigned int index ) @@ -804,11 +1470,11 @@ void cliFunc_macroShow( char* args ) { // Indexed Trigger Macro case 'T': - macroDebugShowTrigger( decToInt( &arg1Ptr[1] ) ); + macroDebugShowTrigger( numToInt( &arg1Ptr[1] ) ); break; // Indexed Result Macro case 'R': - macroDebugShowResult( decToInt( &arg1Ptr[1] ) ); + macroDebugShowResult( numToInt( &arg1Ptr[1] ) ); break; } } @@ -822,7 +1488,13 @@ void cliFunc_macroStep( char* args ) char* arg2Ptr; CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr ); + // Default to 1, if no argument given + unsigned int count = (unsigned int)numToInt( arg1Ptr ); + + if ( count == 0 ) + count = 1; + // Set the macro step counter, negative int's are cast to uint - macroStepCounter = (unsigned int)decToInt( arg1Ptr ); + macroStepCounter = count; }