di0ib/controller
Archived
1
0
Fork 0
Code Releases Activity

Adding more RAM optimizations

Browse Source 
- Split up TriggerMacro and ResultMacro to help the compiler optimize better
- Static RAM usage did not decrease, total flash usage did
This commit is contained in:
Jacob Alexander 2014-09-16 23:29:21 -07:00
parent 37b36fe011
commit 9b1e19017f
3 changed files with 59 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -94,6 +94,7 @@ set( BaseMap "kishsaver" )
##| Layer additonal .kll maps on the BaseMap, layers are in order from 1st to nth ##| Layer additonal .kll maps on the BaseMap, layers are in order from 1st to nth
##| Can be set to "" ##| Can be set to ""
#set( DefaultMap "colemak stdFuncMap" )
set( DefaultMap "colemak kishsaver_unix1 stdFuncMap" ) set( DefaultMap "colemak kishsaver_unix1 stdFuncMap" )
##| ParitalMaps available on top of the BaseMap. See above for syntax on specifying multiple layers vs. layering ##| ParitalMaps available on top of the BaseMap. See above for syntax on specifying multiple layers vs. layering

28
Macro/PartialMap/kll.h
View File

@ -58,23 +58,28 @@ typedef uint16_t nat_ptr_t;
// -- Result Macro // -- Result Macro
// Defines the sequence of combinations to as the Result of Trigger 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 // Capability + args per USB send
// Default Args (always sent): key state/analog of last key // Default Args (always sent): key state/analog of last key
// Combo Length of 0 signifies end of sequence // Combo Length of 0 signifies end of sequence
// //
// ResultMacro.guide -> [<combo length>|<capability index>|<arg1>|<argn>|<capability index>|...|<combo length>|...|0] // ResultMacro.guide -> [<combo length>|<capability index>|<arg1>|<argn>|<capability index>|...|<combo length>|...|0]
// ResultMacro.pos -> <current combo position> //
// ResultMacro.state -> <last key state> // ResultMacroRecord.pos -> <current combo position>
// ResultMacro.stateType -> <last key state type> // ResultMacroRecord.state -> <last key state>
// ResultMacroRecord.stateType -> <last key state type>
// ResultMacro struct, one is created per ResultMacro, no duplicates // ResultMacro struct, one is created per ResultMacro, no duplicates
typedef struct ResultMacro { typedef struct ResultMacro {
const uint8_t *guide; const uint8_t *guide;
} ResultMacro;
typedef struct ResultMacroRecord {
var_uint_t pos; var_uint_t pos;
uint8_t state; uint8_t state;
uint8_t stateType; uint8_t stateType;
} ResultMacro; } ResultMacroRecord;
// Guide, key element // Guide, key element
#define ResultGuideSize( guidePtr ) sizeof( ResultGuide ) - 1 + CapabilitiesList[ (guidePtr)->index ].argCount #define ResultGuideSize( guidePtr ) sizeof( ResultGuide ) - 1 + CapabilitiesList[ (guidePtr)->index ].argCount
@ -87,6 +92,7 @@ typedef struct ResultGuide {
// -- Trigger Macro // -- Trigger Macro
// Defines the sequence of combinations to Trigger a Result 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: // Key Types:
// * 0x00 Normal (Press/Hold/Release) // * 0x00 Normal (Press/Hold/Release)
// * 0x01 LED State (On/Off) // * 0x01 LED State (On/Off)
@ -105,8 +111,9 @@ typedef struct ResultGuide {
// //
// TriggerMacro.guide -> [<combo length>|<key1 type>|<key1 state>|<key1>...<keyn type>|<keyn state>|<keyn>|<combo length>...|0] // TriggerMacro.guide -> [<combo length>|<key1 type>|<key1 state>|<key1>...<keyn type>|<keyn state>|<keyn>|<combo length>...|0]
// TriggerMacro.result -> <index to result macro> // TriggerMacro.result -> <index to result macro>
// TriggerMacro.pos -> <current combo position> //
// TriggerMacro.state -> <status of the macro pos> // TriggerMacroRecord.pos -> <current combo position>
// TriggerMacroRecord.state -> <status of the macro pos>
// TriggerMacro states // TriggerMacro states
typedef enum TriggerMacroState { typedef enum TriggerMacroState {
@ -119,9 +126,12 @@ typedef enum TriggerMacroState {
typedef struct TriggerMacro { typedef struct TriggerMacro {
const uint8_t *guide; const uint8_t *guide;
const var_uint_t result; const var_uint_t result;
} TriggerMacro;
typedef struct TriggerMacroRecord {
var_uint_t pos; var_uint_t pos;
TriggerMacroState state; TriggerMacroState state;
} TriggerMacro; } TriggerMacroRecord;
// Guide, key element // Guide, key element
#define TriggerGuideSize sizeof( TriggerGuide ) #define TriggerGuideSize sizeof( TriggerGuide )
@ -155,7 +165,7 @@ typedef struct Capability {
// * index - Result Macro index number // * index - Result Macro index number
// Must be used after Guide_RM // Must be used after Guide_RM
#define Guide_RM( index ) const uint8_t rm##index##_guide[] #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 // -- Result Macro List
@ -175,7 +185,7 @@ typedef struct Capability {
// * index - Trigger Macro index number // * index - Trigger Macro index number
// * result - Result Macro index number which is triggered by this Trigger Macro // * result - Result Macro index number which is triggered by this Trigger Macro
#define Guide_TM( index ) const uint8_t tm##index##_guide[] #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 // -- Trigger Macro List

74
Macro/PartialMap/macro.c
View File

@ -415,7 +415,7 @@ inline void Macro_ledState( uint8_t ledCode, uint8_t state )
// Append result macro to pending list, checking for duplicates // Append result macro to pending list, checking for duplicates
// Do nothing if duplicate // Do nothing if duplicate
inline void Macro_appendResultMacroToPendingList( TriggerMacro *triggerMacro ) inline void Macro_appendResultMacroToPendingList( const TriggerMacro *triggerMacro )
{ {
// Lookup result macro index // Lookup result macro index
var_uint_t resultMacroIndex = triggerMacro->result; var_uint_t resultMacroIndex = triggerMacro->result;
@ -446,18 +446,18 @@ inline void Macro_appendResultMacroToPendingList( TriggerMacro *triggerMacro )
{ {
if ( macroTriggerListBuffer[ keyIndex ].scanCode == scanCode ) if ( macroTriggerListBuffer[ keyIndex ].scanCode == scanCode )
{ {
ResultMacroList[ resultMacroIndex ].state = macroTriggerListBuffer[ keyIndex ].state; ResultMacroRecordList[ resultMacroIndex ].state = macroTriggerListBuffer[ keyIndex ].state;
ResultMacroList[ resultMacroIndex ].stateType = macroTriggerListBuffer[ keyIndex ].type; ResultMacroRecordList[ resultMacroIndex ].stateType = macroTriggerListBuffer[ keyIndex ].type;
} }
} }
// Reset the macro position // Reset the macro position
ResultMacroList[ resultMacroIndex ].pos = 0; ResultMacroRecordList[ resultMacroIndex ].pos = 0;
} }
// Determine if long ResultMacro (more than 1 seqence element) // 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 // Check the second sequence combo length
// If non-zero return non-zero (long sequence) // 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) // 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 // Check the second sequence combo length
// If non-zero return non-zero (long sequence) // 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 ) inline TriggerMacroEval Macro_evalTriggerMacro( var_uint_t triggerMacroIndex )
{ {
// Lookup TriggerMacro // 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 // 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; record->state = TriggerMacro_Waiting;
macro->pos = macro->pos + macro->guide[ macro->pos ] * TriggerGuideSize + 1; record->pos = record->pos + macro->guide[ record->pos ] * TriggerGuideSize + 1;
} }
// Current Macro position // Current Macro position
var_uint_t pos = macro->pos; var_uint_t pos = record->pos;
// Length of the combo being processed // Length of the combo being processed
uint8_t comboLength = macro->guide[ pos ] * TriggerGuideSize; 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 // 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 // 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 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; return TriggerMacroEval_DoResultAndRemove;
} }
// If passing and in Waiting state, set macro state to Press // If passing and in Waiting state, set macro state to Press
else if ( overallVote & TriggerMacroVote_Pass 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 // 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 // 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 ) inline ResultMacroEval Macro_evalResultMacro( var_uint_t resultMacroIndex )
{ {
// Lookup ResultMacro // Lookup ResultMacro
ResultMacro *macro = &ResultMacroList[ resultMacroIndex ]; const ResultMacro *macro = &ResultMacroList[ resultMacroIndex ];
ResultMacroRecord *record = &ResultMacroRecordList[ resultMacroIndex ];
// Current Macro position // Current Macro position
var_uint_t pos = macro->pos; var_uint_t pos = record->pos;
// Length of combo being processed // Length of combo being processed
uint8_t comboLength = macro->guide[ pos ]; 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); void (*capability)(uint8_t, uint8_t, uint8_t*) = (void(*)(uint8_t, uint8_t, uint8_t*))(CapabilitiesList[ guide->index ].func);
// Call capability // Call capability
capability( macro->state, macro->stateType, &guide->args ); capability( record->state, record->stateType, &guide->args );
// Increment counters // Increment counters
funcCount++; funcCount++;
@ -788,12 +790,12 @@ inline ResultMacroEval Macro_evalResultMacro( var_uint_t resultMacroIndex )
} }
// Move to next item in the sequence // Move to next item in the sequence
macro->pos = comboItem; record->pos = comboItem;
// If the ResultMacro is finished, remove // If the ResultMacro is finished, remove
if ( macro->guide[ comboItem ] == 0 ) if ( macro->guide[ comboItem ] == 0 )
{ {
macro->pos = 0; record->pos = 0;
return ResultMacroEval_Remove; return ResultMacroEval_Remove;
} }
@ -844,8 +846,8 @@ inline void Macro_updateTriggerMacroPendingList()
macroTriggerMacroPendingList[ macroTriggerMacroPendingListSize++ ] = triggerMacroIndex; macroTriggerMacroPendingList[ macroTriggerMacroPendingListSize++ ] = triggerMacroIndex;
// Reset macro position // Reset macro position
TriggerMacroList[ triggerMacroIndex ].pos = 0; TriggerMacroRecordList[ triggerMacroIndex ].pos = 0;
TriggerMacroList[ triggerMacroIndex ].state = TriggerMacro_Waiting; TriggerMacroRecordList[ triggerMacroIndex ].state = TriggerMacro_Waiting;
} }
} }
} }
@ -966,16 +968,16 @@ inline void Macro_setup()
// Initialize TriggerMacro states // Initialize TriggerMacro states
for ( var_uint_t macro = 0; macro < TriggerMacroNum; macro++ ) for ( var_uint_t macro = 0; macro < TriggerMacroNum; macro++ )
{ {
TriggerMacroList[ macro ].pos = 0; TriggerMacroRecordList[ macro ].pos = 0;
TriggerMacroList[ macro ].state = TriggerMacro_Waiting; TriggerMacroRecordList[ macro ].state = TriggerMacro_Waiting;
} }
// Initialize ResultMacro states // Initialize ResultMacro states
for ( var_uint_t macro = 0; macro < ResultMacroNum; macro++ ) for ( var_uint_t macro = 0; macro < ResultMacroNum; macro++ )
{ {
ResultMacroList[ macro ].pos = 0; ResultMacroRecordList[ macro ].pos = 0;
ResultMacroList[ macro ].state = 0; ResultMacroRecordList[ macro ].state = 0;
ResultMacroList[ macro ].stateType = 0; ResultMacroRecordList[ macro ].stateType = 0;
} }
} }
@ -1312,7 +1314,8 @@ void macroDebugShowTrigger( var_uint_t index )
return; return;
// Trigger Macro Show // Trigger Macro Show
TriggerMacro *macro = &TriggerMacroList[ index ]; const TriggerMacro *macro = &TriggerMacroList[ index ];
TriggerMacroRecord *record = &TriggerMacroRecordList[ index ];
print( NL ); print( NL );
info_msg("Trigger Macro Index: "); info_msg("Trigger Macro Index: ");
@ -1360,7 +1363,7 @@ void macroDebugShowTrigger( var_uint_t index )
// Display current position // Display current position
print( NL "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 // Display result macro index
print( NL "Result Macro Index: " ); print( NL "Result Macro Index: " );
@ -1368,7 +1371,7 @@ void macroDebugShowTrigger( var_uint_t index )
// Display trigger macro state // Display trigger macro state
print( NL "Trigger Macro State: " ); print( NL "Trigger Macro State: " );
switch ( macro->state ) switch ( record->state )
{ {
case TriggerMacro_Press: print("Press"); break; case TriggerMacro_Press: print("Press"); break;
case TriggerMacro_Release: print("Release"); break; case TriggerMacro_Release: print("Release"); break;
@ -1383,7 +1386,8 @@ void macroDebugShowResult( var_uint_t index )
return; return;
// Trigger Macro Show // Trigger Macro Show
ResultMacro *macro = &ResultMacroList[ index ]; const ResultMacro *macro = &ResultMacroList[ index ];
ResultMacroRecord *record = &ResultMacroRecordList[ index ];
print( NL ); print( NL );
info_msg("Result Macro Index: "); info_msg("Result Macro Index: ");
@ -1452,13 +1456,13 @@ void macroDebugShowResult( var_uint_t index )
// Display current position // Display current position
print( NL "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 // Display final trigger state/type
print( NL "Final Trigger State (State/Type): " ); print( NL "Final Trigger State (State/Type): " );
printHex( macro->state ); printHex( record->state );
print("/"); print("/");
printHex( macro->stateType ); printHex( record->stateType );
} }
void cliFunc_macroShow( char* args ) void cliFunc_macroShow( char* args )