di0ib
/
controller
Seguir 1
Destacar 0
Fork 0
Código Lanzamientos 0 Actividad
Explorar el Código

Updating PartialLayer code to support varying counter widths. 

- For both uC architecture differences and RAM saving
simple
Jacob Alexander hace 9 años
padre
3a07b4bdcd
commit
cb37c82330
Se han modificado 2 ficheros con 54 adiciones y 54 borrados
Unificar vista Mostrar estadísticas de diff
  1. 2
    2
      Macro/PartialMap/kll.h
  2. 52
    52
      Macro/PartialMap/macro.c

+ 2
- 2
Macro/PartialMap/kll.h Ver fichero

// Or to allow for nearly infinite states. // Or to allow for nearly infinite states.
// TODO Make selectable from layout variable // TODO Make selectable from layout variable
//typedef uint32_t var_uint_t; //typedef uint32_t var_uint_t;
typedef uint16_t var_uint_t;
//typedef uint8_t var_uint_t;
//typedef uint16_t var_uint_t;
typedef uint8_t var_uint_t;


// - NOTE - // - NOTE -
// Native pointer length // Native pointer length

+ 52
- 52
Macro/PartialMap/macro.c Ver fichero



// Keymaps // Keymaps
#include "usb_hid.h" #include "usb_hid.h"
#include <defaultMap.h>
//#include <defaultMap.h>
#include "templateKeymap.h" // TODO Use actual generated version #include "templateKeymap.h" // TODO Use actual generated version
//#include "generatedKeymap.h" // TODO Use actual generated version //#include "generatedKeymap.h" // TODO Use actual generated version


uint8_t macroPauseMode = 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 // 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
// TODO, figure out a good way to scale this array size without wasting too much memory, but not rejecting macros // 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 // Possibly could be calculated by the KLL compiler
// XXX It may be possible to calculate the worst case using 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 // Layer Index Stack
// * When modifying layer state and the state is non-0x0, the stack must be adjusted // * When modifying layer state and the state is non-0x0, the stack must be adjusted
unsigned int macroLayerIndexStack[ LayerNum + 1 ] = { 0 };
unsigned int macroLayerIndexStackSize = 0;
uint16_t macroLayerIndexStack[ LayerNum + 1 ] = { 0 };
uint16_t macroLayerIndexStackSize = 0;


// Pending Result Macro Index List // Pending Result Macro Index List
// * Any result macro that needs processing from a previous macro processing loop // * 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;






{ {
// Is layer in the LayerIndexStack? // Is layer in the LayerIndexStack?
uint8_t inLayerIndexStack = 0; uint8_t inLayerIndexStack = 0;
unsigned int stackItem = 0;
uint16_t stackItem = 0;
while ( stackItem < macroLayerIndexStackSize ) while ( stackItem < macroLayerIndexStackSize )
{ {
// Flag if layer is already in the LayerIndexStack // Flag if layer is already in the LayerIndexStack
return; return;


// Get layer index from arguments // Get layer index from arguments
// Cast pointer to uint8_t to unsigned int then access that memory location
// Cast pointer to uint8_t to uint16_t then access that memory location
uint16_t layer = *(uint16_t*)(&args[0]); uint16_t layer = *(uint16_t*)(&args[0]);


// Get layer toggle byte // Get layer toggle byte
return; return;


// Get layer index from arguments // Get layer index from arguments
// Cast pointer to uint8_t to unsigned int then access that memory location
// Cast pointer to uint8_t to uint16_t then access that memory location
uint16_t layer = *(uint16_t*)(&args[0]); uint16_t layer = *(uint16_t*)(&args[0]);


Macro_layerState( state, stateType, layer, 0x02 ); Macro_layerState( state, stateType, layer, 0x02 );
return; return;


// Get layer index from arguments // Get layer index from arguments
// Cast pointer to uint8_t to unsigned int then access that memory location
// Cast pointer to uint8_t to uint16_t then access that memory location
uint16_t layer = *(uint16_t*)(&args[0]); uint16_t layer = *(uint16_t*)(&args[0]);


Macro_layerState( state, stateType, layer, 0x04 ); Macro_layerState( state, stateType, layer, 0x04 );
return; return;


// Get layer index from arguments // Get layer index from arguments
// Cast pointer to uint8_t to unsigned int then access that memory location
// Cast pointer to uint8_t to uint16_t then access that memory location
uint16_t layer = *(uint16_t*)(&args[0]); uint16_t layer = *(uint16_t*)(&args[0]);


Macro_layerState( state, stateType, layer, 0x01 ); Macro_layerState( state, stateType, layer, 0x01 );
nat_ptr_t *Macro_layerLookup( uint8_t scanCode ) nat_ptr_t *Macro_layerLookup( uint8_t scanCode )
{ {
// If no trigger macro is defined at the given layer, fallthrough to the next layer // 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 = 0; layerIndex < macroLayerIndexStackSize; layerIndex++ )
{ {
// Lookup Layer // Lookup Layer
Layer *layer = &LayerIndex[ macroLayerIndexStack[ layerIndex ] ]; Layer *layer = &LayerIndex[ macroLayerIndexStack[ layerIndex ] ];
inline void Macro_appendResultMacroToPendingList( TriggerMacro *triggerMacro ) inline void Macro_appendResultMacroToPendingList( TriggerMacro *triggerMacro )
{ {
// Lookup result macro index // Lookup result macro index
unsigned int resultMacroIndex = triggerMacro->result;
var_uint_t resultMacroIndex = triggerMacro->result;


// Iterate through result macro pending list, making sure this macro hasn't been added yet // 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 duplicate found, do nothing
if ( macroResultMacroPendingList[ macro ] == resultMacroIndex ) if ( macroResultMacroPendingList[ macro ] == resultMacroIndex )
macroResultMacroPendingList[ macroResultMacroPendingListSize++ ] = resultMacroIndex; macroResultMacroPendingList[ macroResultMacroPendingListSize++ ] = resultMacroIndex;


// Lookup scanCode of the last key in the last combo // Lookup scanCode of the last key in the last combo
unsigned int pos = 0;
var_uint_t pos = 0;
for ( uint8_t comboLength = triggerMacro->guide[0]; comboLength > 0; ) for ( uint8_t comboLength = triggerMacro->guide[0]; comboLength > 0; )
{ {
pos += TriggerGuideSize * comboLength + 1; pos += TriggerGuideSize * comboLength + 1;
// 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)
// 0 otherwise (short sequence) // 0 otherwise (short sequence)
unsigned int position = 1;
for ( unsigned int result = 0; result < macro->guide[0]; result++ )
var_uint_t position = 1;
for ( var_uint_t result = 0; result < macro->guide[0]; result++ )
position += ResultGuideSize( (ResultGuide*)&macro->guide[ position ] ); position += ResultGuideSize( (ResultGuide*)&macro->guide[ position ] );
return macro->guide[ position ]; return macro->guide[ position ];
} }




// Evaluate/Update TriggerMacro // Evaluate/Update TriggerMacro
inline TriggerMacroEval Macro_evalTriggerMacro( unsigned int triggerMacroIndex )
inline TriggerMacroEval Macro_evalTriggerMacro( var_uint_t triggerMacroIndex )
{ {
// Lookup TriggerMacro // Lookup TriggerMacro
TriggerMacro *macro = &TriggerMacroList[ triggerMacroIndex ]; TriggerMacro *macro = &TriggerMacroList[ triggerMacroIndex ];
} }


// Current Macro position // Current Macro position
unsigned int pos = macro->pos;
var_uint_t pos = macro->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;




// Evaluate/Update ResultMacro // Evaluate/Update ResultMacro
inline ResultMacroEval Macro_evalResultMacro( unsigned int resultMacroIndex )
inline ResultMacroEval Macro_evalResultMacro( var_uint_t resultMacroIndex )
{ {
// Lookup ResultMacro // Lookup ResultMacro
ResultMacro *macro = &ResultMacroList[ resultMacroIndex ]; ResultMacro *macro = &ResultMacroList[ resultMacroIndex ];


// Current Macro position // Current Macro position
unsigned int pos = macro->pos;
var_uint_t pos = macro->pos;


// Length of combo being processed // Length of combo being processed
uint8_t comboLength = macro->guide[ pos ]; uint8_t comboLength = macro->guide[ pos ];


// Function Counter, used to keep track of the combo items processed // 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 // Combo Item Position within the guide
unsigned int comboItem = pos + 1;
var_uint_t comboItem = pos + 1;


// Iterate through the Result Combo // Iterate through the Result Combo
while ( funcCount < comboLength ) while ( funcCount < comboLength )


// Iterate over triggerList to see if any TriggerMacros need to be added // Iterate over triggerList to see if any TriggerMacros need to be added
// First item is the number of items in the TriggerList // 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 // 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 // Iterate over macroTriggerMacroPendingList to see if any macro in the scancode's
// triggerList needs to be added // triggerList needs to be added
unsigned int pending = 0;
var_uint_t pending = 0;
for ( ; pending < macroTriggerMacroPendingListSize; pending++ ) for ( ; pending < macroTriggerMacroPendingListSize; pending++ )
{ {
// Stop scanning if the trigger macro index is found in the pending list // Stop scanning if the trigger macro index is found in the pending list


// Tail pointer for macroTriggerMacroPendingList // Tail pointer for macroTriggerMacroPendingList
// Macros must be explicitly re-added // Macros must be explicitly re-added
unsigned int macroTriggerMacroPendingListTail = 0;
var_uint_t macroTriggerMacroPendingListTail = 0;


// Iterate through the pending TriggerMacros, processing each of them // 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 ] ) ) switch ( Macro_evalTriggerMacro( macroTriggerMacroPendingList[ macro ] ) )
{ {


// Tail pointer for macroResultMacroPendingList // Tail pointer for macroResultMacroPendingList
// Macros must be explicitly re-added // Macros must be explicitly re-added
unsigned int macroResultMacroPendingListTail = 0;
var_uint_t macroResultMacroPendingListTail = 0;


// Iterate through the pending ResultMacros, processing each of them // 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 ] ) ) switch ( Macro_evalResultMacro( macroResultMacroPendingList[ macro ] ) )
{ {
macroTriggerListBufferSize = 0; macroTriggerListBufferSize = 0;


// Initialize TriggerMacro states // Initialize TriggerMacro states
for ( unsigned int macro = 0; macro < TriggerMacroNum; macro++ )
for ( var_uint_t macro = 0; macro < TriggerMacroNum; macro++ )
{ {
TriggerMacroList[ macro ].pos = 0; TriggerMacroList[ macro ].pos = 0;
TriggerMacroList[ macro ].state = TriggerMacro_Waiting; TriggerMacroList[ macro ].state = TriggerMacro_Waiting;
} }


// Initialize ResultMacro states // 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 ].pos = 0;
ResultMacroList[ macro ].state = 0; ResultMacroList[ macro ].state = 0;
printHex( CapabilitiesNum ); printHex( CapabilitiesNum );


// Iterate through all of the capabilities and display them // 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" ); print( NL "\t" );
printHex( cap ); printHex( cap );
char* arg2Ptr = args; char* arg2Ptr = args;


// Total number of args to scan (must do a lookup if a keyboard capability is selected) // 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 // Arguments used for keyboard capability function
unsigned int argSetCount = 0;
var_uint_t argSetCount = 0;
uint8_t *argSet = (uint8_t*)args; uint8_t *argSet = (uint8_t*)args;


// Process all args // Process all args
for ( unsigned int c = 0; argSetCount < totalArgs; c++ )
for ( var_uint_t c = 0; argSetCount < totalArgs; c++ )
{ {
curArgs = arg2Ptr; curArgs = arg2Ptr;
CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr ); CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
info_msg("Layer List"); info_msg("Layer List");


// Iterate through all of the layers and display them // 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" ); print( NL "\t" );
printHex( layer ); printHex( layer );
info_msg("Pending Trigger Macros: "); info_msg("Pending Trigger Macros: ");
printInt16( (uint16_t)macroTriggerMacroPendingListSize ); printInt16( (uint16_t)macroTriggerMacroPendingListSize );
print(" : "); print(" : ");
for ( unsigned int macro = 0; macro < macroTriggerMacroPendingListSize; macro++ )
for ( var_uint_t macro = 0; macro < macroTriggerMacroPendingListSize; macro++ )
{ {
printHex( macroTriggerMacroPendingList[ macro ] ); printHex( macroTriggerMacroPendingList[ macro ] );
print(" "); print(" ");
info_msg("Pending Result Macros: "); info_msg("Pending Result Macros: ");
printInt16( (uint16_t)macroResultMacroPendingListSize ); printInt16( (uint16_t)macroResultMacroPendingListSize );
print(" : "); print(" : ");
for ( unsigned int macro = 0; macro < macroResultMacroPendingListSize; macro++ )
for ( var_uint_t macro = 0; macro < macroResultMacroPendingListSize; macro++ )
{ {
printHex( macroResultMacroPendingList[ macro ] ); printHex( macroResultMacroPendingList[ macro ] );
print(" "); print(" ");
// Show Trigger to Result Macro Links // Show Trigger to Result Macro Links
print( NL ); print( NL );
info_msg("Trigger : Result Macro Pairs"); 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( NL );
print("\tT"); print("\tT");
printInt8( macroPauseMode ); printInt8( macroPauseMode );
} }


void macroDebugShowTrigger( unsigned int index )
void macroDebugShowTrigger( var_uint_t index )
{ {
// Only proceed if the macro exists // Only proceed if the macro exists
if ( index >= TriggerMacroNum ) if ( index >= TriggerMacroNum )
print( NL ); print( NL );


// Read the comboLength for combo in the sequence (sequence of combos) // 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 ]; uint8_t comboLength = macro->guide[ pos ];


// Iterate through and interpret the guide // Iterate through and interpret the guide
while ( comboLength != 0 ) while ( comboLength != 0 )
{ {
// Initial position of the combo // Initial position of the combo
unsigned int comboPos = ++pos;
var_uint_t comboPos = ++pos;


// Iterate through the combo // Iterate through the combo
while ( pos < comboLength * TriggerGuideSize + comboPos ) while ( pos < comboLength * TriggerGuideSize + comboPos )
} }
} }


void macroDebugShowResult( unsigned int index )
void macroDebugShowResult( var_uint_t index )
{ {
// Only proceed if the macro exists // Only proceed if the macro exists
if ( index >= ResultMacroNum ) if ( index >= ResultMacroNum )
print( NL ); print( NL );


// Read the comboLength for combo in the sequence (sequence of combos) // 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++ ]; uint8_t comboLength = macro->guide[ pos++ ];


// Iterate through and interpret the guide // Iterate through and interpret the guide
while ( comboLength != 0 ) while ( comboLength != 0 )
{ {
// Function Counter, used to keep track of the combos processed // Function Counter, used to keep track of the combos processed
unsigned int funcCount = 0;
var_uint_t funcCount = 0;


// Iterate through the combo // Iterate through the combo
while ( funcCount < comboLength ) while ( funcCount < comboLength )
print("|"); print("|");


// Display Function Ptr Address // Display Function Ptr Address
printHex( (unsigned int)CapabilitiesList[ guide->index ].func );
printHex( (nat_ptr_t)CapabilitiesList[ guide->index ].func );
print("|"); print("|");


// Display/Lookup Capability Name (utilize debug mode of capability) // Display/Lookup Capability Name (utilize debug mode of capability)


// Display Argument(s) // Display Argument(s)
print("("); 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 // Arguments are only 8 bit values
printHex( (&guide->args)[ arg ] ); printHex( (&guide->args)[ arg ] );
CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr ); CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr );


// Default to 1, if no argument given // Default to 1, if no argument given
unsigned int count = (unsigned int)numToInt( arg1Ptr );
var_uint_t count = (var_uint_t)numToInt( arg1Ptr );


if ( count == 0 ) if ( count == 0 )
count = 1; count = 1;