X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=Macro%2FPartialMap%2Fmacro.c;h=bc2d7d68643078ae25f04d55869398e0948c2baa;hb=216b1513026e45e44794f15cfa4d02ff1c9d49f4;hp=9d107da35d30981581585a8c6072e31808b815bb;hpb=e0a2a4806b28e54c58f43b57b34749d73073c1db;p=kiibohd-controller.git diff --git a/Macro/PartialMap/macro.c b/Macro/PartialMap/macro.c index 9d107da..bc2d7d6 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 @@ -41,6 +41,7 @@ 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 ); @@ -81,24 +82,41 @@ typedef enum ResultMacroEval { // ----- Variables ----- // Macro Module command dictionary -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 }, - { "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 }, - { "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; @@ -109,9 +127,11 @@ uint8_t macroPauseMode = 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 @@ -138,6 +158,10 @@ uint16_t macroResultMacroPendingListSize = 0; // Sets the given layer with the specified layerState void Macro_layerState( uint8_t state, uint8_t stateType, uint16_t layer, uint8_t layerState ) { + // Ignore if layer does not exist + if ( layer >= LayerNum ) + return; + // Is layer in the LayerIndexStack? uint8_t inLayerIndexStack = 0; uint16_t stackItem = 0; @@ -155,15 +179,15 @@ void Macro_layerState( uint8_t state, uint8_t stateType, uint16_t layer, uint8_t } // Toggle Layer State Byte - if ( LayerIndex[ layer ].state & layerState ) + if ( LayerState[ layer ] & layerState ) { // Unset - LayerIndex[ layer ].state &= ~layerState; + LayerState[ layer ] &= ~layerState; } else { // Set - LayerIndex[ layer ].state |= layerState; + LayerState[ layer ] |= layerState; } // If the layer was not in the LayerIndexStack add it @@ -173,7 +197,7 @@ void Macro_layerState( uint8_t state, uint8_t stateType, uint16_t layer, uint8_t } // 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 @@ -186,6 +210,30 @@ void Macro_layerState( uint8_t state, uint8_t stateType, uint16_t layer, uint8_t // 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 @@ -230,8 +278,7 @@ void Macro_layerLatch_capability( uint8_t state, uint8_t stateType, uint8_t *arg // 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 + if ( stateType == 0x00 && state != 0x03 ) // Only on release return; // Get layer index from arguments @@ -296,49 +343,93 @@ void Macro_layerShift_capability( uint8_t state, uint8_t stateType, uint8_t *arg // Looks up the trigger list for the given scan code (from the active layer) // NOTE: Calling function must handle the NULL pointer case -nat_ptr_t *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 ( uint16_t layerIndex = 0; layerIndex < macroLayerIndexStackSize; 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 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 nat_ptr_t **map = (nat_ptr_t**)LayerIndex[0].triggerMap; - // Determine if layer has key defined - if ( map == 0 && *map[ scanCode ] == 0 ) + // Lookup default layer + const Layer *layer = &LayerIndex[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 ); + return 0; +} + + +// Update the scancode using a list of TriggerGuides +// TODO Handle led state and analog +inline void Macro_triggerState( void *triggers, uint8_t num ) +{ + // Copy each of the TriggerGuides to the TriggerListBuffer + for ( uint8_t c = 0; c < num; c++ ) + macroTriggerListBuffer[ macroTriggerListBufferSize++ ] = ((TriggerGuide*)triggers)[ c ]; } @@ -403,7 +494,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; @@ -434,18 +525,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) @@ -458,7 +549,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) @@ -589,20 +680,21 @@ inline TriggerMacroVote Macro_evalLongTriggerMacroVote( TriggerGuide *key, Trigg // Evaluate/Update TriggerMacro -inline TriggerMacroEval Macro_evalTriggerMacro( var_uint_t 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 + 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; @@ -677,11 +769,21 @@ inline TriggerMacroEval Macro_evalTriggerMacro( var_uint_t triggerMacroIndex ) { // 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 || 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 @@ -714,16 +816,6 @@ 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 ) - { - 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 ) @@ -744,10 +836,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 ]; @@ -768,7 +861,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++; @@ -776,11 +869,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 ) { + record->pos = 0; return ResultMacroEval_Remove; } @@ -801,8 +895,12 @@ inline void Macro_updateTriggerMacroPendingList() 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 - nat_ptr_t *triggerList = Macro_layerLookup( macroTriggerListBuffer[ key ].scanCode ); + nat_ptr_t *triggerList = Macro_layerLookup( ¯oTriggerListBuffer[ key ], latch_expire ); // Number of Triggers in list nat_ptr_t triggerListSize = triggerList[0]; @@ -831,8 +929,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; } } } @@ -953,16 +1051,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; } } @@ -972,7 +1070,7 @@ 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 @@ -1136,6 +1234,16 @@ void cliFunc_keyRelease( char* args ) } } +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 ); @@ -1157,11 +1265,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 ); } } @@ -1206,7 +1316,7 @@ void cliFunc_layerState( char* args ) printHex( arg2 ); // Set the layer state - LayerIndex[ arg1 ].state = arg2; + LayerState[ arg1 ] = arg2; break; } } @@ -1297,7 +1407,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: "); @@ -1345,7 +1456,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: " ); @@ -1353,7 +1464,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; @@ -1368,7 +1479,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: "); @@ -1437,13 +1549,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 )