diff --git a/CMakeLists.txt b/CMakeLists.txt index d5cebf4..15acbf7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -94,6 +94,7 @@ set( BaseMap "kishsaver" ) ##| Layer additonal .kll maps on the BaseMap, layers are in order from 1st to nth ##| Can be set to "" +#set( DefaultMap "colemak stdFuncMap" ) set( DefaultMap "colemak kishsaver_unix1 stdFuncMap" ) ##| ParitalMaps available on top of the BaseMap. See above for syntax on specifying multiple layers vs. layering diff --git a/Macro/PartialMap/kll.h b/Macro/PartialMap/kll.h index e9e6c3d..6db5219 100644 --- a/Macro/PartialMap/kll.h +++ b/Macro/PartialMap/kll.h @@ -58,23 +58,28 @@ typedef uint16_t nat_ptr_t; // -- Result Macro // Defines the sequence of combinations to as the Result of Trigger Macro +// For RAM optimization reasons, ResultMacro has been split into ResultMacro and ResultMacroRecord structures // // Capability + args per USB send // Default Args (always sent): key state/analog of last key // Combo Length of 0 signifies end of sequence // // ResultMacro.guide -> [|||||...||...|0] -// ResultMacro.pos -> -// ResultMacro.state -> -// ResultMacro.stateType -> +// +// ResultMacroRecord.pos -> +// ResultMacroRecord.state -> +// ResultMacroRecord.stateType -> // ResultMacro struct, one is created per ResultMacro, no duplicates typedef struct ResultMacro { const uint8_t *guide; +} ResultMacro; + +typedef struct ResultMacroRecord { var_uint_t pos; uint8_t state; uint8_t stateType; -} ResultMacro; +} ResultMacroRecord; // Guide, key element #define ResultGuideSize( guidePtr ) sizeof( ResultGuide ) - 1 + CapabilitiesList[ (guidePtr)->index ].argCount @@ -87,6 +92,7 @@ typedef struct ResultGuide { // -- Trigger Macro // Defines the sequence of combinations to Trigger a Result Macro +// For RAM optimization reasons TriggerMacro has been split into TriggerMacro and TriggerMacroRecord // Key Types: // * 0x00 Normal (Press/Hold/Release) // * 0x01 LED State (On/Off) @@ -105,8 +111,9 @@ typedef struct ResultGuide { // // TriggerMacro.guide -> [|||...|||...|0] // TriggerMacro.result -> -// TriggerMacro.pos -> -// TriggerMacro.state -> +// +// TriggerMacroRecord.pos -> +// TriggerMacroRecord.state -> // TriggerMacro states typedef enum TriggerMacroState { @@ -119,9 +126,12 @@ typedef enum TriggerMacroState { typedef struct TriggerMacro { const uint8_t *guide; const var_uint_t result; +} TriggerMacro; + +typedef struct TriggerMacroRecord { var_uint_t pos; TriggerMacroState state; -} TriggerMacro; +} TriggerMacroRecord; // Guide, key element #define TriggerGuideSize sizeof( TriggerGuide ) @@ -155,7 +165,7 @@ typedef struct Capability { // * index - Result Macro index number // Must be used after Guide_RM #define Guide_RM( index ) const uint8_t rm##index##_guide[] -#define Define_RM( index ) { rm##index##_guide, 0, 0, 0 } +#define Define_RM( index ) { rm##index##_guide } // -- Result Macro List @@ -175,7 +185,7 @@ typedef struct Capability { // * index - Trigger Macro index number // * result - Result Macro index number which is triggered by this Trigger Macro #define Guide_TM( index ) const uint8_t tm##index##_guide[] -#define Define_TM( index, result ) { tm##index##_guide, result, 0, TriggerMacro_Waiting } +#define Define_TM( index, result ) { tm##index##_guide, result } // -- Trigger Macro List diff --git a/Macro/PartialMap/macro.c b/Macro/PartialMap/macro.c index a86efb0..73e643a 100644 --- a/Macro/PartialMap/macro.c +++ b/Macro/PartialMap/macro.c @@ -415,7 +415,7 @@ 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 ) +inline void Macro_appendResultMacroToPendingList( const TriggerMacro *triggerMacro ) { // Lookup result macro index var_uint_t resultMacroIndex = triggerMacro->result; @@ -446,18 +446,18 @@ inline void Macro_appendResultMacroToPendingList( TriggerMacro *triggerMacro ) { if ( macroTriggerListBuffer[ keyIndex ].scanCode == scanCode ) { - ResultMacroList[ resultMacroIndex ].state = macroTriggerListBuffer[ keyIndex ].state; - ResultMacroList[ resultMacroIndex ].stateType = macroTriggerListBuffer[ keyIndex ].type; + ResultMacroRecordList[ resultMacroIndex ].state = macroTriggerListBuffer[ keyIndex ].state; + ResultMacroRecordList[ resultMacroIndex ].stateType = macroTriggerListBuffer[ keyIndex ].type; } } // Reset the macro position - ResultMacroList[ resultMacroIndex ].pos = 0; + 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) @@ -470,7 +470,7 @@ inline uint8_t Macro_isLongResultMacro( ResultMacro *macro ) // Determine if long TriggerMacro (more than 1 sequence element) -inline uint8_t Macro_isLongTriggerMacro( TriggerMacro *macro ) +inline uint8_t Macro_isLongTriggerMacro( const TriggerMacro *macro ) { // Check the second sequence combo length // If non-zero return non-zero (long sequence) @@ -604,17 +604,18 @@ inline TriggerMacroVote Macro_evalLongTriggerMacroVote( TriggerGuide *key, Trigg inline 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 + 1; + record->state = TriggerMacro_Waiting; + record->pos = record->pos + macro->guide[ record->pos ] * TriggerGuideSize + 1; } // Current Macro position - var_uint_t pos = macro->pos; + var_uint_t pos = record->pos; // Length of the combo being processed uint8_t comboLength = macro->guide[ pos ] * TriggerGuideSize; @@ -691,19 +692,19 @@ inline TriggerMacroEval Macro_evalTriggerMacro( var_uint_t triggerMacroIndex ) } // 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 ) + else if ( overallVote & TriggerMacroVote_Release && record->state == TriggerMacro_Press ) { - macro->state = TriggerMacro_Release; + record->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 ) + 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 || macro->state == TriggerMacro_Press ) ) + && ( 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 @@ -756,10 +757,11 @@ inline TriggerMacroEval Macro_evalTriggerMacro( var_uint_t triggerMacroIndex ) 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 - var_uint_t pos = macro->pos; + var_uint_t pos = record->pos; // Length of combo being processed uint8_t comboLength = macro->guide[ pos ]; @@ -780,7 +782,7 @@ inline ResultMacroEval Macro_evalResultMacro( var_uint_t resultMacroIndex ) 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++; @@ -788,12 +790,12 @@ inline ResultMacroEval Macro_evalResultMacro( var_uint_t 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 ) { - macro->pos = 0; + record->pos = 0; return ResultMacroEval_Remove; } @@ -844,8 +846,8 @@ inline void Macro_updateTriggerMacroPendingList() macroTriggerMacroPendingList[ macroTriggerMacroPendingListSize++ ] = triggerMacroIndex; // Reset macro position - TriggerMacroList[ triggerMacroIndex ].pos = 0; - TriggerMacroList[ triggerMacroIndex ].state = TriggerMacro_Waiting; + TriggerMacroRecordList[ triggerMacroIndex ].pos = 0; + TriggerMacroRecordList[ triggerMacroIndex ].state = TriggerMacro_Waiting; } } } @@ -966,16 +968,16 @@ inline void Macro_setup() // Initialize TriggerMacro states for ( var_uint_t macro = 0; macro < TriggerMacroNum; macro++ ) { - TriggerMacroList[ macro ].pos = 0; - TriggerMacroList[ macro ].state = TriggerMacro_Waiting; + TriggerMacroRecordList[ macro ].pos = 0; + TriggerMacroRecordList[ macro ].state = TriggerMacro_Waiting; } // Initialize ResultMacro states 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; } } @@ -1312,7 +1314,8 @@ void macroDebugShowTrigger( var_uint_t index ) return; // Trigger Macro Show - TriggerMacro *macro = &TriggerMacroList[ index ]; + const TriggerMacro *macro = &TriggerMacroList[ index ]; + TriggerMacroRecord *record = &TriggerMacroRecordList[ index ]; print( NL ); info_msg("Trigger Macro Index: "); @@ -1360,7 +1363,7 @@ void macroDebugShowTrigger( var_uint_t 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: " ); @@ -1368,7 +1371,7 @@ void macroDebugShowTrigger( var_uint_t index ) // Display trigger macro state print( NL "Trigger Macro State: " ); - switch ( macro->state ) + switch ( record->state ) { case TriggerMacro_Press: print("Press"); break; case TriggerMacro_Release: print("Release"); break; @@ -1383,7 +1386,8 @@ void macroDebugShowResult( var_uint_t index ) return; // Trigger Macro Show - ResultMacro *macro = &ResultMacroList[ index ]; + const ResultMacro *macro = &ResultMacroList[ index ]; + ResultMacroRecord *record = &ResultMacroRecordList[ index ]; print( NL ); info_msg("Result Macro Index: "); @@ -1452,13 +1456,13 @@ void macroDebugShowResult( var_uint_t 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 )