X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=Macro%2FPartialMap%2Fmacro.c;h=7161fbf9e495d92eb9ec5d6c42f50afae355555a;hb=51486bc4e16830c16c30f696b3a4f84c93a5baf8;hp=38d918e56135eb64824362f977be98e6bb22f200;hpb=2f7e3cb117662e89b8f6183b5e4ce27eb4952b9e;p=kiibohd-controller.git diff --git a/Macro/PartialMap/macro.c b/Macro/PartialMap/macro.c index 38d918e..7161fbf 100644 --- a/Macro/PartialMap/macro.c +++ b/Macro/PartialMap/macro.c @@ -1,4 +1,4 @@ -/* Copyright (C) 2014 by Jacob Alexander +/* Copyright (C) 2014-2015 by Jacob Alexander * * This file is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -27,8 +27,12 @@ // Keymaps #include "usb_hid.h" -#include -#include "generatedKeymap.h" // TODO Use actual generated version +#include // Generated using kll at compile time, in build directory + +// Connect Includes +#if defined(ConnectEnabled_define) +#include +#endif // Local Includes #include "macro.h" @@ -39,8 +43,10 @@ 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_layerDebug( char* args ); void cliFunc_layerList ( char* args ); void cliFunc_layerState( char* args ); void cliFunc_macroDebug( char* args ); @@ -55,12 +61,13 @@ void cliFunc_macroStep ( char* args ); // Bit positions are important, passes (correct key) always trump incorrect key votes typedef enum TriggerMacroVote { - TriggerMacroVote_Release = 0x8, // Correct key - TriggerMacroVote_PassRelease = 0xC, // Correct key (both pass and release) - TriggerMacroVote_Pass = 0x4, // Correct key - TriggerMacroVote_DoNothing = 0x2, // Incorrect key - TriggerMacroVote_Fail = 0x1, // Incorrect key - TriggerMacroVote_Invalid = 0x0, // Invalid state + 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 { @@ -80,23 +87,41 @@ typedef enum ResultMacroEval { // ----- Variables ----- // Macro Module command dictionary -char* macroCLIDictName = "Macro Module Commands"; -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 }, - { "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 }, - { "macroList", "List the defined trigger and result macros.", cliFunc_macroList }, - { "macroProc", "Pause/Resume macro processing.", cliFunc_macroProc }, - { "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 }, - { "macroStep", "Do N macro processing steps. Defaults to 1.", cliFunc_macroStep }, +CLIDict_Entry( capList, "Prints an indexed list of all non USB keycode capabilities." ); +CLIDict_Entry( capSelect, "Triggers the specified capabilities. First two args are state and stateType." NL "\t\t\033[35mK11\033[0m Keyboard Capability 0x0B" ); +CLIDict_Entry( keyHold, "Send key-hold events to the macro module. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A" ); +CLIDict_Entry( keyPress, "Send key-press events to the macro module. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A" ); +CLIDict_Entry( keyRelease, "Send key-release event to macro module. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A" ); +CLIDict_Entry( layerDebug, "Layer debug mode. Shows layer stack and any changes." ); +CLIDict_Entry( layerList, "List available layers." ); +CLIDict_Entry( 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" ); +CLIDict_Entry( macroDebug, "Disables/Enables sending USB keycodes to the Output Module and prints U/K codes." ); +CLIDict_Entry( macroList, "List the defined trigger and result macros." ); +CLIDict_Entry( macroProc, "Pause/Resume macro processing." ); +CLIDict_Entry( 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" ); +CLIDict_Entry( macroStep, "Do N macro processing steps. Defaults to 1." ); + +CLIDict_Def( macroCLIDict, "Macro Module Commands" ) = { + CLIDict_Item( capList ), + CLIDict_Item( capSelect ), + CLIDict_Item( keyHold ), + CLIDict_Item( keyPress ), + CLIDict_Item( keyRelease ), + CLIDict_Item( layerDebug ), + CLIDict_Item( layerList ), + CLIDict_Item( layerState ), + CLIDict_Item( macroDebug ), + CLIDict_Item( macroList ), + CLIDict_Item( macroProc ), + CLIDict_Item( macroShow ), + CLIDict_Item( macroStep ), { 0, 0, 0 } // Null entry for dictionary end }; +// Layer debug flag - If set, displays any changes to layers and the full layer stack on change +uint8_t layerDebugMode = 0; + // Macro debug flag - If set, clears the USB Buffers after signalling processing completion uint8_t macroDebugMode = 0; @@ -104,56 +129,54 @@ uint8_t macroDebugMode = 0; uint8_t macroPauseMode = 0; // Macro step counter - If non-zero, the step counter counts down every time the macro module does one processing loop -unsigned int macroStepCounter = 0; +uint16_t macroStepCounter = 0; -// Key Trigger List Buffer +// Key Trigger List Buffer and Layer Cache +// The layer cache is set on press only, hold and release events refer to the value set on press TriggerGuide macroTriggerListBuffer[ MaxScanCode ]; uint8_t macroTriggerListBufferSize = 0; +var_uint_t macroTriggerListLayerCache[ MaxScanCode ]; // Pending Trigger Macro Index List // * Any trigger macros that need processing from a previous macro processing loop // TODO, figure out a good way to scale this array size without wasting too much memory, but not rejecting macros // Possibly could be calculated by the KLL compiler // XXX It may be possible to calculate the worst case using the KLL compiler -unsigned int macroTriggerMacroPendingList[ TriggerMacroNum ] = { 0 }; -unsigned int macroTriggerMacroPendingListSize = 0; +uint16_t macroTriggerMacroPendingList[ TriggerMacroNum ] = { 0 }; +uint16_t 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 macroLayerIndexStackSize = 0; +uint16_t macroLayerIndexStack[ LayerNum + 1 ] = { 0 }; +uint16_t macroLayerIndexStackSize = 0; // Pending Result Macro Index List // * Any result macro that needs processing from a previous macro processing loop -unsigned int macroResultMacroPendingList[ ResultMacroNum ] = { 0 }; -unsigned int macroResultMacroPendingListSize = 0; +uint16_t macroResultMacroPendingList[ ResultMacroNum ] = { 0 }; +uint16_t macroResultMacroPendingListSize = 0; + +// Interconnect ScanCode Cache +#if defined(ConnectEnabled_define) +// TODO This can be shrunk by the size of the max node 0 ScanCode +TriggerGuide macroInterconnectCache[ MaxScanCode ]; +uint8_t macroInterconnectCacheSize = 0; +#endif // ----- Capabilities ----- -// Modifies the specified Layer control byte -// Argument #1: Layer Index -> unsigned int -// Argument #2: Toggle byte -> uint8_t -void Macro_layerStateToggle_capability( uint8_t state, uint8_t stateType, uint8_t *args ) +// Sets the given layer with the specified layerState +void Macro_layerState( uint8_t state, uint8_t stateType, uint16_t layer, uint8_t layerState ) { - // Display capability name - if ( stateType == 0xFF && state == 0xFF ) - { - print("Macro_layerState(layerIndex,toggleByte)"); + // Ignore if layer does not exist + if ( layer >= LayerNum ) return; - } - - // Get layer index from arguments - unsigned int layer = (unsigned int)(&args[0]); - - // Get layer toggle byte - uint8_t toggleByte = args[ sizeof(unsigned int) ]; // Is layer in the LayerIndexStack? uint8_t inLayerIndexStack = 0; - unsigned int stackItem = 0; + uint16_t stackItem = 0; while ( stackItem < macroLayerIndexStackSize ) { // Flag if layer is already in the LayerIndexStack @@ -168,15 +191,15 @@ void Macro_layerStateToggle_capability( uint8_t state, uint8_t stateType, uint8_ } // Toggle Layer State Byte - if ( LayerIndex[ layer ].state & toggleByte ) + if ( LayerState[ layer ] & layerState ) { // Unset - LayerIndex[ layer ].state &= ~toggleByte; + LayerState[ layer ] &= ~layerState; } else { // Set - LayerIndex[ layer ].state |= toggleByte; + LayerState[ layer ] |= layerState; } // If the layer was not in the LayerIndexStack add it @@ -186,7 +209,7 @@ void Macro_layerStateToggle_capability( uint8_t state, uint8_t stateType, uint8_ } // If the layer is in the LayerIndexStack and the state is 0x00, remove - if ( LayerIndex[ layer ].state == 0x00 && inLayerIndexStack ) + if ( LayerState[ layer ] == 0x00 && inLayerIndexStack ) { // Remove the layer from the LayerIndexStack // Using the already positioned stackItem variable from the loop above @@ -199,6 +222,131 @@ void Macro_layerStateToggle_capability( uint8_t state, uint8_t stateType, uint8_ // Reduce LayerIndexStack size macroLayerIndexStackSize--; } + + // Layer Debug Mode + if ( layerDebugMode ) + { + dbug_msg("Layer "); + + // Iterate over each of the layers displaying the state as a hex value + for ( uint16_t index = 0; index < LayerNum; index++ ) + { + printHex_op( LayerState[ index ], 0 ); + } + + // Always show the default layer (it's always 0) + print(" 0"); + + // Iterate over the layer stack starting from the bottom of the stack + for ( uint16_t index = macroLayerIndexStackSize; index > 0; index-- ) + { + print(":"); + printHex_op( macroLayerIndexStack[ index - 1 ], 0 ); + } + + print( NL ); + } +} + +// 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 uint16_t 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 + if ( stateType == 0x00 && state != 0x03 ) // Only on release + return; + + // Get layer index from arguments + // Cast pointer to uint8_t to uint16_t 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 uint16_t 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 uint16_t then access that memory location + uint16_t layer = *(uint16_t*)(&args[0]); + + Macro_layerState( state, stateType, layer, 0x01 ); } @@ -207,52 +355,158 @@ void Macro_layerStateToggle_capability( uint8_t state, uint8_t stateType, uint8_ // 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( TriggerGuide *guide, uint8_t latch_expire ) { + uint8_t scanCode = guide->scanCode; + + // TODO Analog + // If a normal key, and not pressed, do a layer cache lookup + if ( guide->type == 0x00 && guide->state != 0x01 ) + { + // Cached layer + var_uint_t cachedLayer = macroTriggerListLayerCache[ scanCode ]; + + // Lookup map, then layer + nat_ptr_t **map = (nat_ptr_t**)LayerIndex[ cachedLayer ].triggerMap; + const Layer *layer = &LayerIndex[ cachedLayer ]; + + return map[ scanCode - layer->first ]; + } + // If no trigger macro is defined at the given layer, fallthrough to the next layer - for ( unsigned int layerIndex = 0; layerIndex < macroLayerIndexStackSize; layerIndex++ ) + for ( uint16_t layerIndex = macroLayerIndexStackSize; layerIndex != 0xFFFF; layerIndex-- ) { // Lookup Layer - Layer *layer = &LayerIndex[ macroLayerIndexStack[ layerIndex ] ]; + const Layer *layer = &LayerIndex[ macroLayerIndexStack[ layerIndex ] ]; // 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 ) + uint8_t latch = LayerState[ macroLayerIndexStack[ layerIndex ] ] & 0x02; + if ( latch && latch_expire ) { - layer->state &= ~0x02; + Macro_layerState( 0, 0, macroLayerIndexStack[ layerIndex ], 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) ) + if ( (LayerState[ macroLayerIndexStack[ layerIndex ] ] & 0x01) ^ (latch>>1) ^ ((LayerState[ macroLayerIndexStack[ layerIndex ] ] & 0x04)>>2) ) { // Lookup layer - unsigned int **map = layer->triggerMap; + nat_ptr_t **map = (nat_ptr_t**)layer->triggerMap; // Determine if layer has key defined - if ( map != 0 && *map[ scanCode ] != 0 ) - return map[ scanCode ]; + // Make sure scanCode is between layer first and last scancodes + if ( map != 0 + && scanCode <= layer->last + && scanCode >= layer->first + && *map[ scanCode - layer->first ] != 0 ) + { + // Set the layer cache + macroTriggerListLayerCache[ scanCode ] = macroLayerIndexStack[ layerIndex ]; + + return map[ scanCode - layer->first ]; + } } } // Do lookup on default layer - unsigned int **map = LayerIndex[0].triggerMap; + nat_ptr_t **map = (nat_ptr_t**)LayerIndex[0].triggerMap; + + // Lookup default layer + const Layer *layer = &LayerIndex[0]; - // Determine if layer has key defined - if ( map == 0 && *map[ scanCode ] == 0 ) + // Make sure scanCode is between layer first and last scancodes + if ( map != 0 + && scanCode <= layer->last + && scanCode >= layer->first + && *map[ scanCode - layer->first ] != 0 ) { - erro_msg("Scan Code has no defined Trigger Macro: "); - printHex( scanCode ); - return 0; + // Set the layer cache to default map + macroTriggerListLayerCache[ scanCode ] = 0; + + return map[ scanCode - layer->first ]; } - // Return lookup result - return map[ scanCode ]; + // Otherwise no defined Trigger Macro + erro_msg("Scan Code has no defined Trigger Macro: "); + printHex( scanCode ); + print( NL ); + return 0; } +// Add an interconnect ScanCode +// These are handled differently (less information is sent, hold/off states must be assumed) +#if defined(ConnectEnabled_define) +inline void Macro_interconnectAdd( void *trigger_ptr ) +{ + TriggerGuide *trigger = (TriggerGuide*)trigger_ptr; + + // Error checking + uint8_t error = 0; + switch ( trigger->type ) + { + case 0x00: // Normal key + switch ( trigger->state ) + { + case 0x00: + case 0x01: + case 0x02: + case 0x03: + break; + default: + erro_msg("Invalid key state - "); + error = 1; + break; + } + break; + + // Invalid TriggerGuide type + default: + erro_msg("Invalid type - "); + error = 1; + break; + } + + // Check if ScanCode is out of range + if ( trigger->scanCode > MaxScanCode ) + { + warn_msg("ScanCode is out of range/not defined - "); + error = 1; + } + + // Display TriggerGuide + if ( error ) + { + printHex( trigger->type ); + print(" "); + printHex( trigger->state ); + print(" "); + printHex( trigger->scanCode ); + print( NL ); + return; + } + + // Add trigger to the Interconnect Cache + // During each processing loop, a scancode may be re-added depending on it's state + for ( uint8_t c = 0; c < macroInterconnectCacheSize; c++ ) + { + // Check if the same ScanCode + if ( macroInterconnectCache[ c ].scanCode == trigger->scanCode ) + { + // Update the state + macroInterconnectCache[ c ].state = trigger->state; + return; + } + } + + // If not in the list, add it + macroInterconnectCache[ macroInterconnectCacheSize++ ] = *trigger; +} +#endif + + // Update the scancode key state // States: // * 0x00 - Off @@ -262,12 +516,35 @@ unsigned int *Macro_layerLookup( uint8_t scanCode ) // * 0x04 - Unpressed (this is currently ignored) inline void Macro_keyState( uint8_t scanCode, uint8_t state ) { +#if defined(ConnectEnabled_define) + // Only compile in if a Connect node module is available + if ( !Connect_master ) + { + // ScanCodes are only added if there was a state change (on/off) + switch ( state ) + { + case 0x00: // Off + case 0x02: // Held + return; + } + } +#endif + // Only add to macro trigger list if one of three states switch ( state ) { case 0x01: // Pressed case 0x02: // Held case 0x03: // Released + // Check if ScanCode is out of range + if ( scanCode > MaxScanCode ) + { + warn_msg("ScanCode is out of range/not defined: "); + printHex( scanCode ); + print( NL ); + return; + } + macroTriggerListBuffer[ macroTriggerListBufferSize ].scanCode = scanCode; macroTriggerListBuffer[ macroTriggerListBufferSize ].state = state; macroTriggerListBuffer[ macroTriggerListBufferSize ].type = 0x00; // Normal key @@ -285,8 +562,18 @@ inline void Macro_keyState( uint8_t scanCode, uint8_t state ) inline void Macro_analogState( uint8_t scanCode, uint8_t state ) { // Only add to macro trigger list if non-off + // TODO Handle change for interconnect if ( state != 0x00 ) { + // Check if ScanCode is out of range + if ( scanCode > MaxScanCode ) + { + warn_msg("ScanCode is out of range/not defined: "); + printHex( scanCode ); + print( NL ); + return; + } + macroTriggerListBuffer[ macroTriggerListBufferSize ].scanCode = scanCode; macroTriggerListBuffer[ macroTriggerListBufferSize ].state = state; macroTriggerListBuffer[ macroTriggerListBufferSize ].type = 0x02; // Analog key @@ -302,8 +589,12 @@ inline void Macro_analogState( uint8_t scanCode, uint8_t state ) inline void Macro_ledState( uint8_t ledCode, uint8_t state ) { // Only add to macro trigger list if non-off + // TODO Handle change for interconnect if ( state != 0x00 ) { + // Check if LedCode is out of range + // TODO + macroTriggerListBuffer[ macroTriggerListBufferSize ].scanCode = ledCode; macroTriggerListBuffer[ macroTriggerListBufferSize ].state = state; macroTriggerListBuffer[ macroTriggerListBufferSize ].type = 0x01; // LED key @@ -314,10 +605,13 @@ 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( unsigned int resultMacroIndex ) +inline void Macro_appendResultMacroToPendingList( const TriggerMacro *triggerMacro ) { + // Lookup result macro index + var_uint_t 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++ ) + for ( var_uint_t macro = 0; macro < macroResultMacroPendingListSize; macro++ ) { // If duplicate found, do nothing if ( macroResultMacroPendingList[ macro ] == resultMacroIndex ) @@ -326,21 +620,108 @@ inline void Macro_appendResultMacroToPendingList( unsigned int resultMacroIndex // No duplicates found, add to pending list macroResultMacroPendingList[ macroResultMacroPendingListSize++ ] = resultMacroIndex; + + // Lookup scanCode of the last key in the last combo + var_uint_t 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 ) + { + ResultMacroRecordList[ resultMacroIndex ].state = macroTriggerListBuffer[ keyIndex ].state; + ResultMacroRecordList[ resultMacroIndex ].stateType = macroTriggerListBuffer[ keyIndex ].type; + } + } + + // Reset the macro position + ResultMacroRecordList[ resultMacroIndex ].pos = 0; } // Determine if long ResultMacro (more than 1 seqence element) -inline uint8_t Macro_isLongResultMacro( ResultMacro *macro ) +inline uint8_t Macro_isLongResultMacro( const ResultMacro *macro ) +{ + // Check the second sequence combo length + // If non-zero return non-zero (long sequence) + // 0 otherwise (short sequence) + var_uint_t position = 1; + for ( var_uint_t 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( const TriggerMacro *macro ) { // Check the second sequence combo length - // If non-zero return 1 (long sequence) + // If non-zero return non-zero (long sequence) // 0 otherwise (short sequence) - return macro->guide[ macro->guide[0] * ResultGuideSize( (ResultGuide*)macro->guide ) ] > 0 ? 1 : 0; + return macro->guide[ macro->guide[0] * TriggerGuideSize + 1 ]; } -// Votes on the given key vs. guide -inline TriggerMacroVote Macro_evalTriggerMacroVote( TriggerGuide *key, TriggerGuide *guide ) +// 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 ) @@ -357,10 +738,13 @@ inline TriggerMacroVote Macro_evalTriggerMacroVote( TriggerGuide *key, TriggerGu case 0x01: return TriggerMacroVote_Fail; - // Wrong key, held or released, do not pass (no effect) + // Wrong key, held, do not pass (no effect) case 0x02: - case 0x03: return TriggerMacroVote_DoNothing; + + // Wrong key released, fail out if pos == 0 + case 0x03: + return TriggerMacroVote_DoNothing | TriggerMacroVote_DoNothingRelease; } } @@ -407,23 +791,24 @@ inline TriggerMacroVote Macro_evalTriggerMacroVote( TriggerGuide *key, TriggerGu // Evaluate/Update TriggerMacro -inline TriggerMacroEval Macro_evalTriggerMacro( unsigned int triggerMacroIndex ) +TriggerMacroEval Macro_evalTriggerMacro( var_uint_t triggerMacroIndex ) { // Lookup TriggerMacro - TriggerMacro *macro = &TriggerMacroList[ triggerMacroIndex ]; + const TriggerMacro *macro = &TriggerMacroList[ triggerMacroIndex ]; + TriggerMacroRecord *record = &TriggerMacroRecordList[ triggerMacroIndex ]; // Check if macro has finished and should be incremented sequence elements - if ( macro->state == TriggerMacro_Release ) + if ( record->state == TriggerMacro_Release ) { - macro->state = TriggerMacro_Waiting; - macro->pos = macro->pos + macro->guide[ macro->pos ] * TriggerGuideSize; + record->state = TriggerMacro_Waiting; + record->pos = record->pos + macro->guide[ record->pos ] * TriggerGuideSize + 1; } // Current Macro position - unsigned int pos = macro->pos; + var_uint_t pos = record->pos; // Length of the combo being processed - uint8_t comboLength = macro->guide[ pos ]; + uint8_t comboLength = macro->guide[ pos ] * TriggerGuideSize; // If no combo items are left, remove the TriggerMacro from the pending list if ( comboLength == 0 ) @@ -431,7 +816,10 @@ inline TriggerMacroEval Macro_evalTriggerMacro( unsigned int triggerMacroIndex ) return TriggerMacroEval_Remove; } - // Iterate through the key buffer, comparing to each key in the combo + // 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 @@ -443,21 +831,23 @@ inline TriggerMacroEval Macro_evalTriggerMacro( unsigned int triggerMacroIndex ) // 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 key = 0; key < macroTriggerListBufferSize; key++ ) + for ( uint8_t comboItem = pos + 1; comboItem < pos + comboLength + 1; comboItem += TriggerGuideSize ) { - // Lookup key information - TriggerGuide *keyInfo = ¯oTriggerListBuffer[ key ]; + // Assign TriggerGuide element (key type, state and scancode) + TriggerGuide *guide = (TriggerGuide*)(¯o->guide[ comboItem ]); - // Iterate through the items in the combo, voting the on the key state TriggerMacroVote vote = TriggerMacroVote_Invalid; - for ( uint8_t comboItem = pos + 1; comboItem < pos + comboLength + 1; comboItem += TriggerGuideSize ) + // Iterate through the key buffer, comparing to each key in the combo + for ( uint8_t key = 0; key < macroTriggerListBufferSize; key++ ) { - // Assign TriggerGuide element (key type, state and scancode) - TriggerGuide *guide = (TriggerGuide*)(¯o->guide[ comboItem ]); + // 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 |= Macro_evalTriggerMacroVote( keyInfo, guide ); + vote |= longMacro + ? Macro_evalLongTriggerMacroVote( keyInfo, guide ) + : Macro_evalShortTriggerMacroVote( keyInfo, guide ); if ( vote >= TriggerMacroVote_Pass ) { vote &= TriggerMacroVote_Release | TriggerMacroVote_PassRelease | TriggerMacroVote_Pass; @@ -465,10 +855,20 @@ inline TriggerMacroEval Macro_evalTriggerMacro( unsigned int triggerMacroIndex ) } } + // 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; + // Decide new state of macro after voting // Fail macro, remove from pending list if ( overallVote & TriggerMacroVote_Fail ) @@ -476,75 +876,103 @@ inline TriggerMacroEval Macro_evalTriggerMacro( unsigned int triggerMacroIndex ) return TriggerMacroEval_Remove; } // Do nothing, incorrect key is being held or released - else if ( overallVote & TriggerMacroVote_DoNothing ) + else if ( overallVote & TriggerMacroVote_DoNothing && longMacro ) { // Just doing nothing :) } + // 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 && record->state == TriggerMacro_Press ) + { + record->state = TriggerMacro_Release; + + // If this is the last combo in the sequence, remove from the pending list + if ( macro->guide[ record->pos + macro->guide[ record->pos ] * TriggerGuideSize + 1 ] == 0 ) + return TriggerMacroEval_DoResultAndRemove; + } // If passing and in Waiting state, set macro state to Press - else if ( overallVote & TriggerMacroVote_Pass && macro->state == TriggerMacro_Waiting ) + else if ( overallVote & TriggerMacroVote_Pass + && ( record->state == TriggerMacro_Waiting || record->state == TriggerMacro_Press ) ) { - macro->state = TriggerMacro_Press; + record->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 macro repeat rate - if ( macro->guide[ pos + comboLength ] == 0 ) + // TODO Add option to have long macro repeat rate + if ( macro->guide[ pos + comboLength + 1 ] == 0 ) { - // Long Macro, only send once (more than 1 sequence item) - // Short Macro (only 1 sequence item) - return Macro_isLongResultMacro( &ResultMacroList[ macro->result ] ) - ? TriggerMacroEval_DoResult - : TriggerMacroEval_DoResultAndRemove; + // Long result macro (more than 1 combo) + if ( Macro_isLongResultMacro( &ResultMacroList[ macro->result ] ) ) + { + // Only ever trigger result once, on press + if ( overallVote == TriggerMacroVote_Pass ) + { + return TriggerMacroEval_DoResultAndRemove; + } + } + // Short result macro + else + { + // 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 ) + // 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 ) { - macro->state = TriggerMacro_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 -inline ResultMacroEval Macro_evalResultMacro( unsigned int resultMacroIndex ) +inline ResultMacroEval Macro_evalResultMacro( var_uint_t resultMacroIndex ) { // Lookup ResultMacro - ResultMacro *macro = &ResultMacroList[ resultMacroIndex ]; + const ResultMacro *macro = &ResultMacroList[ resultMacroIndex ]; + ResultMacroRecord *record = &ResultMacroRecordList[ resultMacroIndex ]; // Current Macro position - unsigned int pos = macro->pos; + var_uint_t pos = record->pos; // Length of combo being processed uint8_t comboLength = macro->guide[ pos ]; - // If no combo items are left, remove the ResultMacro from the pending list - if ( comboLength == 0 ) - { - return ResultMacroEval_Remove; - } - // Function Counter, used to keep track of the combo items processed - unsigned int funcCount = 0; + var_uint_t funcCount = 0; // Combo Item Position within the guide - unsigned int comboItem = pos + 1; + var_uint_t comboItem = pos + 1; // Iterate through the Result Combo while ( funcCount < comboLength ) { // Assign TriggerGuide element (key type, state and scancode) - ResultGuide *guide = (ResultGuide*)(¯o->guide[ pos ]); + 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 ); + capability( record->state, record->stateType, &guide->args ); // Increment counters funcCount++; @@ -552,35 +980,56 @@ inline ResultMacroEval Macro_evalResultMacro( unsigned int resultMacroIndex ) } // Move to next item in the sequence - macro->pos = comboItem; + record->pos = comboItem; + + // If the ResultMacro is finished, remove + if ( macro->guide[ comboItem ] == 0 ) + { + record->pos = 0; + return ResultMacroEval_Remove; + } - // If the ResultMacro is finished, it will be removed on the next iteration + // Otherwise leave the macro in the list return ResultMacroEval_DoNothing; } // Update pending trigger list -void Macro_updateTriggerMacroPendingList() +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; + + // TODO Analog + // If this is a release case, indicate to layer lookup for possible latch expiry + uint8_t latch_expire = macroTriggerListBuffer[ key ].state == 0x03; + // Lookup Trigger List - unsigned int *triggerList = Macro_layerLookup( macroTriggerListBuffer[ key ].scanCode ); + nat_ptr_t *triggerList = Macro_layerLookup( ¯oTriggerListBuffer[ key ], latch_expire ); + + // If there was an error during lookup, skip + if ( triggerList == 0 ) + continue; // Number of Triggers in list - unsigned int triggerListSize = triggerList[0]; + nat_ptr_t triggerListSize = triggerList[0]; // 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++ ) + for ( var_uint_t macro = 1; macro < triggerListSize + 1; macro++ ) { // Lookup trigger macro index - unsigned int triggerMacroIndex = triggerList[ macro ]; + var_uint_t triggerMacroIndex = triggerList[ macro ]; // Iterate over macroTriggerMacroPendingList to see if any macro in the scancode's // triggerList needs to be added - unsigned int pending = 0; + var_uint_t pending = 0; for ( ; pending < macroTriggerMacroPendingListSize; pending++ ) { // Stop scanning if the trigger macro index is found in the pending list @@ -593,6 +1042,10 @@ void Macro_updateTriggerMacroPendingList() if ( pending == macroTriggerMacroPendingListSize ) { macroTriggerMacroPendingList[ macroTriggerMacroPendingListSize++ ] = triggerMacroIndex; + + // Reset macro position + TriggerMacroRecordList[ triggerMacroIndex ].pos = 0; + TriggerMacroRecordList[ triggerMacroIndex ].state = TriggerMacro_Waiting; } } } @@ -603,10 +1056,59 @@ void Macro_updateTriggerMacroPendingList() // Called once per USB buffer send inline void Macro_process() { +#if defined(ConnectEnabled_define) + // Only compile in if a Connect node module is available + // If this is a interconnect slave node, send all scancodes to master node + if ( !Connect_master ) + { + if ( macroTriggerListBufferSize > 0 ) + { + Connect_send_ScanCode( Connect_id, macroTriggerListBuffer, macroTriggerListBufferSize ); + macroTriggerListBufferSize = 0; + } + return; + } +#endif + // Only do one round of macro processing between Output Module timer sends if ( USBKeys_Sent != 0 ) return; +#if defined(ConnectEnabled_define) + // Check if there are any ScanCodes in the interconnect cache to process + if ( Connect_master && macroInterconnectCacheSize > 0 ) + { + // Iterate over all the cache ScanCodes + uint8_t currentInterconnectCacheSize = macroInterconnectCacheSize; + macroInterconnectCacheSize = 0; + for ( uint8_t c = 0; c < currentInterconnectCacheSize; c++ ) + { + // Add to the trigger list + macroTriggerListBuffer[ macroTriggerListBufferSize++ ] = macroInterconnectCache[ c ]; + + // TODO Handle other TriggerGuide types (e.g. analog) + switch ( macroInterconnectCache[ c ].type ) + { + // Normal (Press/Hold/Release) + case 0x00: + // Decide what to do based on the current state + switch ( macroInterconnectCache[ c ].state ) + { + // Re-add to interconnect cache in hold state + case 0x01: // Press + //case 0x02: // Hold // XXX Why does this not work? -HaaTa + macroInterconnectCache[ c ].state = 0x02; + macroInterconnectCache[ macroInterconnectCacheSize++ ] = macroInterconnectCache[ c ]; + break; + case 0x03: // Remove + break; + // Otherwise, do not re-add + } + } + } + } +#endif + // If the pause flag is set, only process if the step counter is non-zero if ( macroPauseMode ) { @@ -615,6 +1117,7 @@ inline void Macro_process() // Proceed, decrementing the step counter macroStepCounter--; + dbug_print("Macro Step"); } // Update pending trigger list, before processing TriggerMacros @@ -622,19 +1125,18 @@ inline void Macro_process() // Tail pointer for macroTriggerMacroPendingList // Macros must be explicitly re-added - unsigned int macroTriggerMacroPendingListTail = 0; + var_uint_t macroTriggerMacroPendingListTail = 0; // Iterate through the pending TriggerMacros, processing each of them - for ( unsigned int macro = 0; macro < macroTriggerMacroPendingListSize; macro++ ) + for ( var_uint_t macro = 0; macro < macroTriggerMacroPendingListSize; macro++ ) { switch ( Macro_evalTriggerMacro( macroTriggerMacroPendingList[ macro ] ) ) { // Trigger Result Macro (purposely falling through) case TriggerMacroEval_DoResult: // Append ResultMacro to PendingList - Macro_appendResultMacroToPendingList( TriggerMacroList[ macroTriggerMacroPendingList[ macro ] ].result ); + Macro_appendResultMacroToPendingList( &TriggerMacroList[ macroTriggerMacroPendingList[ macro ] ] ); - // Otherwise, just re-add default: macroTriggerMacroPendingList[ macroTriggerMacroPendingListTail++ ] = macroTriggerMacroPendingList[ macro ]; break; @@ -642,7 +1144,7 @@ inline void Macro_process() // Trigger Result Macro and Remove (purposely falling through) case TriggerMacroEval_DoResultAndRemove: // Append ResultMacro to PendingList - Macro_appendResultMacroToPendingList( TriggerMacroList[ macroTriggerMacroPendingList[ macro ] ].result ); + Macro_appendResultMacroToPendingList( &TriggerMacroList[ macroTriggerMacroPendingList[ macro ] ] ); // Remove Macro from Pending List, nothing to do, removing by default case TriggerMacroEval_Remove: @@ -656,10 +1158,10 @@ inline void Macro_process() // Tail pointer for macroResultMacroPendingList // Macros must be explicitly re-added - unsigned int macroResultMacroPendingListTail = 0; + var_uint_t macroResultMacroPendingListTail = 0; // Iterate through the pending ResultMacros, processing each of them - for ( unsigned int macro = 0; macro < macroResultMacroPendingListSize; macro++ ) + for ( var_uint_t macro = 0; macro < macroResultMacroPendingListSize; macro++ ) { switch ( Macro_evalResultMacro( macroResultMacroPendingList[ macro ] ) ) { @@ -711,19 +1213,18 @@ inline void Macro_setup() macroTriggerListBufferSize = 0; // Initialize TriggerMacro states - for ( unsigned int macro = 0; macro < TriggerMacroNum; macro++ ) + for ( var_uint_t macro = 0; macro < TriggerMacroNum; macro++ ) { - TriggerMacroList[ macro ].result = 0; - TriggerMacroList[ macro ].pos = 0; - TriggerMacroList[ macro ].state = TriggerMacro_Waiting; + TriggerMacroRecordList[ macro ].pos = 0; + TriggerMacroRecordList[ macro ].state = TriggerMacro_Waiting; } // Initialize ResultMacro states - for ( unsigned int macro = 0; macro < ResultMacroNum; macro++ ) + for ( var_uint_t macro = 0; macro < ResultMacroNum; macro++ ) { - ResultMacroList[ macro ].pos = 0; - ResultMacroList[ macro ].state = 0; - ResultMacroList[ macro ].stateType = 0; + ResultMacroRecordList[ macro ].pos = 0; + ResultMacroRecordList[ macro ].state = 0; + ResultMacroRecordList[ macro ].stateType = 0; } } @@ -733,10 +1234,11 @@ inline void Macro_setup() void cliFunc_capList( char* args ) { print( NL ); - info_msg("Capabilities List"); + info_msg("Capabilities List "); + printHex( CapabilitiesNum ); // Iterate through all of the capabilities and display them - for ( unsigned int cap = 0; cap < CapabilitiesNum; cap++ ) + for ( var_uint_t cap = 0; cap < CapabilitiesNum; cap++ ) { print( NL "\t" ); printHex( cap ); @@ -756,15 +1258,15 @@ void cliFunc_capSelect( char* args ) char* arg2Ptr = args; // Total number of args to scan (must do a lookup if a keyboard capability is selected) - unsigned int totalArgs = 2; // Always at least two args - unsigned int cap = 0; + var_uint_t totalArgs = 2; // Always at least two args + var_uint_t cap = 0; // Arguments used for keyboard capability function - unsigned int argSetCount = 0; + var_uint_t argSetCount = 0; uint8_t *argSet = (uint8_t*)args; // Process all args - for ( unsigned int c = 0; argSetCount < totalArgs; c++ ) + for ( var_uint_t c = 0; argSetCount < totalArgs; c++ ) { curArgs = arg2Ptr; CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr ); @@ -780,7 +1282,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; @@ -789,7 +1291,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 ) @@ -812,6 +1314,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 @@ -834,7 +1364,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; } } @@ -862,26 +1392,36 @@ 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; } } } +void cliFunc_layerDebug( char *args ) +{ + // Toggle layer debug mode + layerDebugMode = layerDebugMode ? 0 : 1; + + print( NL ); + info_msg("Layer Debug Mode: "); + printInt8( layerDebugMode ); +} + void cliFunc_layerList( char* args ) { print( NL ); info_msg("Layer List"); // Iterate through all of the layers and display them - for ( unsigned int layer = 0; layer < LayerNum; layer++ ) + for ( uint16_t layer = 0; layer < LayerNum; layer++ ) { print( NL "\t" ); printHex( layer ); print(" - "); // Display layer name - dPrint( LayerIndex[ layer ].name ); + dPrint( (char*)LayerIndex[ layer ].name ); // Default map if ( layer == 0 ) @@ -889,11 +1429,13 @@ void cliFunc_layerList( char* args ) // Layer State print( NL "\t\t Layer State: " ); - printHex( LayerIndex[ layer ].state ); + printHex( LayerState[ layer ] ); - // Max Index - print(" Max Index: "); - printHex( LayerIndex[ layer ].max ); + // First -> Last Indices + print(" First -> Last Indices: "); + printHex( LayerIndex[ layer ].first ); + print(" -> "); + printHex( LayerIndex[ layer ].last ); } } @@ -924,11 +1466,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 ); @@ -938,7 +1480,7 @@ void cliFunc_layerState( char* args ) printHex( arg2 ); // Set the layer state - LayerIndex[ arg1 ].state = arg2; + LayerState[ arg1 ] = arg2; break; } } @@ -956,6 +1498,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 ( var_uint_t 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 ( var_uint_t macro = 0; macro < macroResultMacroPendingListSize; macro++ ) + { + printHex( macroResultMacroPendingList[ macro ] ); + print(" "); + } + // Show available trigger macro indices print( NL ); info_msg("Trigger Macros Range: T0 -> T"); @@ -969,7 +1544,7 @@ void cliFunc_macroList( char* args ) // Show Trigger to Result Macro Links print( NL ); info_msg("Trigger : Result Macro Pairs"); - for ( unsigned int macro = 0; macro < TriggerMacroNum; macro++ ) + for ( var_uint_t macro = 0; macro < TriggerMacroNum; macro++ ) { print( NL ); print("\tT"); @@ -989,14 +1564,15 @@ void cliFunc_macroProc( char* args ) printInt8( macroPauseMode ); } -void macroDebugShowTrigger( unsigned int index ) +void macroDebugShowTrigger( var_uint_t index ) { // Only proceed if the macro exists if ( index >= TriggerMacroNum ) return; // Trigger Macro Show - TriggerMacro *macro = &TriggerMacroList[ index ]; + const TriggerMacro *macro = &TriggerMacroList[ index ]; + TriggerMacroRecord *record = &TriggerMacroRecordList[ index ]; print( NL ); info_msg("Trigger Macro Index: "); @@ -1004,14 +1580,14 @@ void macroDebugShowTrigger( unsigned int index ) print( NL ); // Read the comboLength for combo in the sequence (sequence of combos) - unsigned int pos = 0; + var_uint_t pos = 0; uint8_t comboLength = macro->guide[ pos ]; // Iterate through and interpret the guide while ( comboLength != 0 ) { // Initial position of the combo - unsigned int comboPos = ++pos; + var_uint_t comboPos = ++pos; // Iterate through the combo while ( pos < comboLength * TriggerGuideSize + comboPos ) @@ -1044,21 +1620,31 @@ void macroDebugShowTrigger( unsigned int index ) // Display current position print( NL "Position: " ); - printInt16( (uint16_t)macro->pos ); // Hopefully large enough :P (can't assume 32-bit) + printInt16( (uint16_t)record->pos ); // Hopefully large enough :P (can't assume 32-bit) // 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 ( record->state ) + { + case TriggerMacro_Press: print("Press"); break; + case TriggerMacro_Release: print("Release"); break; + case TriggerMacro_Waiting: print("Waiting"); break; + } } -void macroDebugShowResult( unsigned int index ) +void macroDebugShowResult( var_uint_t index ) { // Only proceed if the macro exists if ( index >= ResultMacroNum ) return; // Trigger Macro Show - ResultMacro *macro = &ResultMacroList[ index ]; + const ResultMacro *macro = &ResultMacroList[ index ]; + ResultMacroRecord *record = &ResultMacroRecordList[ index ]; print( NL ); info_msg("Result Macro Index: "); @@ -1066,14 +1652,14 @@ void macroDebugShowResult( unsigned int index ) print( NL ); // Read the comboLength for combo in the sequence (sequence of combos) - unsigned int pos = 0; + var_uint_t pos = 0; uint8_t comboLength = macro->guide[ pos++ ]; // Iterate through and interpret the guide while ( comboLength != 0 ) { // Function Counter, used to keep track of the combos processed - unsigned int funcCount = 0; + var_uint_t funcCount = 0; // Iterate through the combo while ( funcCount < comboLength ) @@ -1086,7 +1672,7 @@ void macroDebugShowResult( unsigned int index ) print("|"); // Display Function Ptr Address - printHex( (unsigned int)CapabilitiesList[ guide->index ].func ); + printHex( (nat_ptr_t)CapabilitiesList[ guide->index ].func ); print("|"); // Display/Lookup Capability Name (utilize debug mode of capability) @@ -1095,7 +1681,7 @@ void macroDebugShowResult( unsigned int index ) // Display Argument(s) print("("); - for ( unsigned int arg = 0; arg < CapabilitiesList[ guide->index ].argCount; arg++ ) + for ( var_uint_t arg = 0; arg < CapabilitiesList[ guide->index ].argCount; arg++ ) { // Arguments are only 8 bit values printHex( (&guide->args)[ arg ] ); @@ -1127,13 +1713,13 @@ void macroDebugShowResult( unsigned int index ) // Display current position print( NL "Position: " ); - printInt16( (uint16_t)macro->pos ); // Hopefully large enough :P (can't assume 32-bit) + printInt16( (uint16_t)record->pos ); // Hopefully large enough :P (can't assume 32-bit) // Display final trigger state/type print( NL "Final Trigger State (State/Type): " ); - printHex( macro->state ); + printHex( record->state ); print("/"); - printHex( macro->stateType ); + printHex( record->stateType ); } void cliFunc_macroShow( char* args ) @@ -1158,11 +1744,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; } } @@ -1176,7 +1762,13 @@ void cliFunc_macroStep( char* args ) char* arg2Ptr; CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr ); + // Default to 1, if no argument given + var_uint_t count = (var_uint_t)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; }