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

Merge branch 'test'

simple
Jacob Alexander 9 years ago
parent
28df956007 c7934c7224
commit
3a07b4bdcd
3 changed files with 61 additions and 12 deletions
Unified View Show Diff Stats
  1. 26
    5
      Macro/PartialMap/kll.h
  2. 30
    7
      Macro/PartialMap/macro.c
  3. 5
    0
      Output/pjrcUSB/output_com.c

+ 26
- 5
Macro/PartialMap/kll.h View File







// ----- Types -----

// - NOTE -
// It is possible to change the maximum state and indexing positions of the state machine.
// This usually affects the SRAM usage quite a bit, so it can be used to fit the code on smaller uCs
// Or to allow for nearly infinite states.
// TODO Make selectable from layout variable
//typedef uint32_t var_uint_t;
typedef uint16_t var_uint_t;
//typedef uint8_t var_uint_t;

// - NOTE -
// Native pointer length
// This needs to be defined per microcontroller
// e.g. mk20s -> 32 bit
// atmega -> 16 bit
typedef uint32_t nat_ptr_t;
//typedef uint16_t nat_ptr_t;



// ----- Structs ----- // ----- Structs -----


// -- Result Macro // -- Result Macro
// 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;
unsigned int pos;
var_uint_t pos;
uint8_t state; uint8_t state;
uint8_t stateType; uint8_t stateType;
} ResultMacro; } ResultMacro;
// 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;
unsigned int result;
unsigned int pos;
var_uint_t result;
var_uint_t pos;
TriggerMacroState state; TriggerMacroState state;
} TriggerMacro; } TriggerMacro;


// * layer - basename of the layer // * layer - basename of the layer
// * scanCode - Hex value of the scanCode // * scanCode - Hex value of the scanCode
// * triggerList - Trigger List (see Trigger Lists) // * triggerList - Trigger List (see Trigger Lists)
#define Define_TL( layer, scanCode ) const unsigned int layer##_tl_##scanCode[]
#define Define_TL( layer, scanCode ) const nat_ptr_t layer##_tl_##scanCode[]






// 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 unsigned int **triggerMap;
const nat_ptr_t **triggerMap;
const char *name; const char *name;
const uint8_t max; const uint8_t max;
uint8_t state; uint8_t state;

+ 30
- 7
Macro/PartialMap/macro.c View File

return; return;
} }


// Only use capability on press or release
// TODO Analog
// XXX This may cause issues, might be better to implement state table here to decide -HaaTa
if ( stateType == 0x00 && state == 0x02 ) // Hold condition
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 unsigned int then access that memory location
uint16_t layer = *(uint16_t*)(&args[0]); uint16_t layer = *(uint16_t*)(&args[0]);
return; return;
} }


// 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
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 unsigned int then access that memory location
uint16_t layer = *(uint16_t*)(&args[0]); uint16_t layer = *(uint16_t*)(&args[0]);
return; return;
} }


// Only use capability on press
// TODO Analog
// XXX Could also be on release, but that's sorta dumb -HaaTa
if ( stateType == 0x00 && state != 0x01 ) // All normal key conditions except press
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 unsigned int then access that memory location
uint16_t layer = *(uint16_t*)(&args[0]); uint16_t layer = *(uint16_t*)(&args[0]);
return; return;
} }


// Only use capability on press or release
// TODO Analog
if ( stateType == 0x00 && ( state == 0x00 || state == 0x02 ) ) // Only pass press or release conditions
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 unsigned int then access that memory location
uint16_t layer = *(uint16_t*)(&args[0]); uint16_t layer = *(uint16_t*)(&args[0]);


// Looks up the trigger list for the given scan code (from the active layer) // Looks up the trigger list for the given scan code (from the active layer)
// NOTE: Calling function must handle the NULL pointer case // NOTE: Calling function must handle the NULL pointer case
unsigned int *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 ( unsigned int layerIndex = 0; layerIndex < macroLayerIndexStackSize; layerIndex++ )
if ( (layer->state & 0x01) ^ (latch>>1) ^ ((layer->state & 0x04)>>2) ) if ( (layer->state & 0x01) ^ (latch>>1) ^ ((layer->state & 0x04)>>2) )
{ {
// Lookup layer // Lookup layer
unsigned int **map = (unsigned int**)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 ) if ( map != 0 && *map[ scanCode ] != 0 )
} }


// Do lookup on default layer // Do lookup on default layer
unsigned int **map = (unsigned int**)LayerIndex[0].triggerMap;
nat_ptr_t **map = (nat_ptr_t**)LayerIndex[0].triggerMap;


// Determine if layer has key defined // Determine if layer has key defined
if ( map == 0 && *map[ scanCode ] == 0 ) if ( map == 0 && *map[ scanCode ] == 0 )
return TriggerMacroEval_Remove; return TriggerMacroEval_Remove;
} }
// Otherwise, just remove the macro on key release // Otherwise, just remove the macro on key release
// XXX Might cause some issues
// 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 ) else if ( overallVote & TriggerMacroVote_Release )
{ {
return TriggerMacroEval_Remove;
return TriggerMacroEval_DoResultAndRemove;
} }


// If this is a short macro, just remove it // If this is a short macro, just remove it
continue; continue;


// Lookup Trigger List // Lookup Trigger List
unsigned int *triggerList = Macro_layerLookup( macroTriggerListBuffer[ key ].scanCode );
nat_ptr_t *triggerList = Macro_layerLookup( macroTriggerListBuffer[ key ].scanCode );


// Number of Triggers in list // Number of Triggers in list
unsigned int triggerListSize = triggerList[0];
nat_ptr_t triggerListSize = triggerList[0];


// 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

+ 5
- 0
Output/pjrcUSB/output_com.c View File

return; return;
} }


// TODO Analog inputs
// Only send keypresses if press or hold state
if ( stateType == 0x00 && state == 0x03 ) // Release state
return;

// Get the keycode from arguments // Get the keycode from arguments
uint8_t key = args[0]; uint8_t key = args[0];