di0ib
/
controller
Watch 1
Star 0
Fork 0
Code Releases 0 Activity
Browse Source

Adding support for layer packing 

- Only keep state for the scan code that are available for the layer
- Also properly implemented scan code range checking (was not done before, only worked because the KLL compiler was well behaved)
simple
Jacob Alexander 9 years ago
parent
12295e8362
commit
df82ffeff7
2 changed files with 50 additions and 33 deletions
Unified View Show Diff Stats
  1. 14
    11
      Macro/PartialMap/kll.h
  2. 36
    22
      Macro/PartialMap/macro.c

+ 14
- 11
Macro/PartialMap/kll.h View File

// TriggerMacro struct, one is created per TriggerMacro, no duplicates // TriggerMacro struct, one is created per TriggerMacro, no duplicates
typedef struct TriggerMacro { typedef struct TriggerMacro {
const uint8_t *guide; const uint8_t *guide;
var_uint_t result;
const var_uint_t result;
var_uint_t pos; var_uint_t pos;
TriggerMacroState state; TriggerMacroState state;
} TriggerMacro; } TriggerMacro;


// Capability // Capability
typedef struct Capability { typedef struct Capability {
void *func;
uint8_t argCount;
const void *func;
const uint8_t argCount;
} Capability; } Capability;


// Total Number of Capabilities // Total Number of Capabilities
// * Shift - 0x01 // * Shift - 0x01
// * Latch - 0x02 // * Latch - 0x02
// * Lock - 0x04 // * Lock - 0x04
// Layer states are stored in the LayerState array
// //
// Except for Off, all states an exist simultaneously for each layer // Except for Off, all states an exist simultaneously for each layer
// For example: // For example:
// state -> 0x04 + 0x01 = 0x05 (Shift + Lock), which is effectively Off (0x00) // state -> 0x04 + 0x01 = 0x05 (Shift + Lock), which is effectively Off (0x00)
// //
// Max defines the maximum number of keys in the map, maximum of 0xFF
// First defines the first used scan code (most keyboards start at 0, some start higher e.g. 0x40)
// - Compiler calculates this // - Compiler calculates this
// //
// Last defines the last scan code used (helps reduce RAM usage)
//
// The name is defined for cli debugging purposes (Null terminated string) // The name is defined for cli debugging purposes (Null terminated string)


typedef struct Layer { typedef struct Layer {
const nat_ptr_t **triggerMap; const nat_ptr_t **triggerMap;
const char *name; const char *name;
const uint8_t max;
uint8_t state;
const uint8_t first;
const uint8_t last;
} Layer; } Layer;


// Layer_IN( map, name );
// * map - Trigger map
// * name - Name of the trigger map
#define Layer_IN( map, name ) { map, name, sizeof( map ) / sizeof( nat_ptr_t ) - 1, 0 }
// Layer_IN( map, name, first );
// * map - Trigger map
// * name - Name of the trigger map
// * first - First scan code used (most keyboards start at 0, some start higher e.g. 0x40)
#define Layer_IN( map, name, first ) { map, name, first, sizeof( map ) / sizeof( nat_ptr_t ) - 1 + first }


// Total number of layers // Total number of layers
#define LayerNum sizeof( LayerIndex ) / sizeof( Layer ) #define LayerNum sizeof( LayerIndex ) / sizeof( Layer )

+ 36
- 22
Macro/PartialMap/macro.c View File

} }


// Toggle Layer State Byte // Toggle Layer State Byte
if ( LayerIndex[ layer ].state & layerState )
if ( LayerState[ layer ] & layerState )
{ {
// Unset // Unset
LayerIndex[ layer ].state &= ~layerState;
LayerState[ layer ] &= ~layerState;
} }
else else
{ {
// Set // Set
LayerIndex[ layer ].state |= layerState;
LayerState[ layer ] |= layerState;
} }


// If the layer was not in the LayerIndexStack add it // If the layer was not in the LayerIndexStack add it
} }


// If the layer is in the LayerIndexStack and the state is 0x00, remove // 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 // Remove the layer from the LayerIndexStack
// Using the already positioned stackItem variable from the loop above // Using the already positioned stackItem variable from the loop above
for ( uint16_t layerIndex = 0; layerIndex < macroLayerIndexStackSize; layerIndex++ ) for ( uint16_t layerIndex = 0; layerIndex < macroLayerIndexStackSize; layerIndex++ )
{ {
// Lookup Layer // Lookup Layer
Layer *layer = &LayerIndex[ macroLayerIndexStack[ layerIndex ] ];
const Layer *layer = &LayerIndex[ macroLayerIndexStack[ layerIndex ] ];


// Check if latch has been pressed for this layer // Check if latch has been pressed for this layer
// XXX Regardless of whether a key is found, the latch is removed on first lookup // XXX Regardless of whether a key is found, the latch is removed on first lookup
uint8_t latch = layer->state & 0x02;
uint8_t latch = LayerState[ layerIndex ] & 0x02;
if ( latch ) if ( latch )
{ {
layer->state &= ~0x02;
LayerState[ layerIndex ] &= ~0x02;
} }


// Only use layer, if state is valid // Only use layer, if state is valid
// XOR each of the state bits // XOR each of the state bits
// If only two are enabled, do not use this state // If only two are enabled, do not use this state
if ( (layer->state & 0x01) ^ (latch>>1) ^ ((layer->state & 0x04)>>2) )
if ( (LayerState[ layerIndex ] & 0x01) ^ (latch>>1) ^ ((LayerState[ layerIndex ] & 0x04)>>2) )
{ {
// Lookup layer // Lookup layer
nat_ptr_t **map = (nat_ptr_t**)layer->triggerMap; nat_ptr_t **map = (nat_ptr_t**)layer->triggerMap;


// Determine if layer has key defined // 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 )
{
return map[ scanCode - layer->first ];
}
} }
} }


// Do lookup on default layer // Do lookup on default layer
nat_ptr_t **map = (nat_ptr_t**)LayerIndex[0].triggerMap; 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[ macroLayerIndexStack[ 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;
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;
} }






// Layer State // Layer State
print( NL "\t\t 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 );
} }
} }


printHex( arg2 ); printHex( arg2 );


// Set the layer state // Set the layer state
LayerIndex[ arg1 ].state = arg2;
LayerState[ arg1 ] = arg2;
break; break;
} }
} }