Archived
1
0
This repo is archived. You can view files and clone it, but cannot push or open issues or pull requests.
controller/Macro/PartialMap/macro.c

448 lines
11 KiB
C
Raw Normal View History

/* Copyright (C) 2014 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
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This file is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this file. If not, see <http://www.gnu.org/licenses/>.
*/
// ----- Includes -----
// Compiler Includes
#include <Lib/MacroLib.h>
// Project Includes
#include <cli.h>
#include <led.h>
#include <print.h>
#include <scan_loop.h>
#include <output_com.h>
// Keymaps
#include "usb_hid.h"
#include <defaultMap.h>
#include "generatedKeymap.h" // TODO Use actual generated version
// Local Includes
#include "macro.h"
// ----- Function Declarations -----
void cliFunc_capList ( char* args );
void cliFunc_capSelect ( char* args );
void cliFunc_lookComb ( char* args );
void cliFunc_lookDefault( char* args );
void cliFunc_lookPartial( char* args );
void cliFunc_macroDebug ( char* args );
// ----- Variables -----
// Macro Module command dictionary
char* macroCLIDictName = "Macro Module Commands (Not all commands fully work yet...)";
CLIDictItem macroCLIDict[] = {
{ "capList", "Prints an indexed list of all non USB keycode capabilities.", cliFunc_capList },
2014-04-19 18:31:43 +00:00
{ "capSelect", "Triggers the specified capability." NL "\t\t\033[35mU10\033[0m USB Code 0x0A, \033[35mK11\033[0m Keyboard Capability 0x0B, \033[35mS12\033[0m Scancode 0x0C", cliFunc_capSelect },
{ "lookComb", "Do a lookup on the Combined map." NL "\t\t\033[35mS10\033[0m Scancode 0x0A, \033[35mU11\033[0m USB Code 0x0B", cliFunc_lookComb },
{ "lookDefault", "Do a lookup on the Default map." NL "\t\t\033[35mS10\033[0m Scancode 0x0A", cliFunc_lookDefault },
{ "lookPartial", "Do a lookup on the layered Partial maps." NL "\t\t\033[35mS10\033[0m Scancode 0x0A, \033[35mU11\033[0m USB Code 0x0B", cliFunc_lookPartial },
{ "macroDebug", "Disables/Enables sending USB keycodes to the Output Module and prints U/K codes.", cliFunc_macroDebug },
{ 0, 0, 0 } // Null entry for dictionary end
};
// Macro debug flag - If set, clears the USB Buffers after signalling processing completion
uint8_t macroDebugMode = 0;
// Key Trigger List Buffer
// * Item 1: scan code
// * Item 2: state
// ...
uint8_t macroTriggerListBuffer[0xFF * 2] = { 0 }; // Each key has a state to be cached (this can be decreased to save RAM)
uint8_t macroTriggerListBufferSize = 0;
// 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
TriggerMacro *triggerMacroPendingList[30];
// ----- Functions -----
// Looks up the trigger list for the given scan code (from the active layer)
unsigned int *Macro_layerLookup( uint8_t scanCode )
2014-06-14 18:00:29 +00:00
{
// TODO - No layer fallthrough lookup
return default_scanMap[ scanCode ];
2014-06-14 18:00:29 +00:00
}
// Update the scancode key state
// States:
// * 0x00 - Reserved
// * 0x01 - Pressed
// * 0x02 - Held
// * 0x03 - Released
// * 0x04 - Unpressed (this is currently ignored)
inline void Macro_keyState( uint8_t scanCode, uint8_t state )
2014-06-14 18:00:29 +00:00
{
// Only add to macro trigger list if one of three states
switch ( state )
{
case 0x01: // Pressed
case 0x02: // Held
case 0x03: // Released
macroTriggerListBuffer[ macroTriggerListBufferSize++ ] = scanCode;
macroTriggerListBuffer[ macroTriggerListBufferSize++ ] = state;
break;
}
2014-06-14 18:00:29 +00:00
}
// Update the scancode analog state
// States:
// * 0x00 - Reserved
// * 0x01 - Released
// * 0x02-0xFF - Analog value (low to high)
inline void Macro_analogState( uint8_t scanCode, uint8_t state )
{
// TODO
}
2014-06-14 18:00:29 +00:00
// Update led state
// States:
// * 0x00 - Reserved
// * 0x01 - On
// * 0x02 - Off
inline void Macro_ledState( uint8_t ledCode, uint8_t state )
{
// TODO
}
2014-06-14 18:00:29 +00:00
// Evaluate/Update the TriggerMacro
void Macro_evalTriggerMacro( TriggerMacro *triggerMacro )
{
// Which combo in the sequence is being evaluated
unsigned int comboPos = triggerMacro->pos;
2014-06-14 18:00:29 +00:00
// If combo length is more than 1, cancel trigger macro if an incorrect key is found
uint8_t comboLength = triggerMacro->guide[ comboPos ];
2014-06-14 18:00:29 +00:00
// Iterate over list of keys currently pressed
for ( uint8_t keyPressed = 0; keyPressed < macroTriggerListBufferSize; keyPressed += 2 )
{
// Compare with keys in combo
for ( unsigned int comboKey = 0; comboKey < comboLength; comboKey++ )
{
// Lookup key in combo
uint8_t guideKey = triggerMacro->guide[ comboPos + comboKey + 2 ]; // TODO Only Press/Hold/Release atm
// Sequence Case
if ( comboLength == 1 )
{
// If key matches and only 1 key pressed, increment the TriggerMacro combo position
if ( guideKey == macroTriggerListBuffer[ keyPressed ] && macroTriggerListBufferSize == 1 )
{
triggerMacro->pos += comboLength * 2 + 1;
// TODO check if TriggerMacro is finished, register ResultMacro
return;
}
// If key does not match or more than 1 key pressed, reset the TriggerMacro combo position
triggerMacro->pos = 0;
return;
}
// Combo Case
else
{
// TODO
}
}
}
}
2014-06-14 18:00:29 +00:00
inline void Macro_bufferAdd( uint8_t byte )
{
// Make sure we haven't overflowed the key buffer
// Default function for adding keys to the KeyIndex_Buffer, does a DefaultMap_Lookup
if ( KeyIndex_BufferUsed < KEYBOARD_BUFFER )
{
uint8_t key = DefaultMap_Lookup[byte];
for ( uint8_t c = 0; c < KeyIndex_BufferUsed; c++ )
{
// Key already in the buffer
if ( KeyIndex_Buffer[c] == key )
return;
}
// Add to the buffer
KeyIndex_Buffer[KeyIndex_BufferUsed++] = key;
}
}
inline void Macro_bufferRemove( uint8_t byte )
{
uint8_t key = DefaultMap_Lookup[byte];
// Check for the released key, and shift the other keys lower on the buffer
for ( uint8_t c = 0; c < KeyIndex_BufferUsed; c++ )
{
// Key to release found
if ( KeyIndex_Buffer[c] == key )
{
// Shift keys from c position
for ( uint8_t k = c; k < KeyIndex_BufferUsed - 1; k++ )
KeyIndex_Buffer[k] = KeyIndex_Buffer[k + 1];
// Decrement Buffer
KeyIndex_BufferUsed--;
return;
}
}
// Error case (no key to release)
erro_msg("Could not find key to release: ");
printHex( key );
}
inline void Macro_finishWithUSBBuffer( uint8_t sentKeys )
{
}
inline void Macro_process()
{
// Only do one round of macro processing between Output Module timer sends
if ( USBKeys_Sent != 0 )
return;
// Loop through macro trigger buffer
for ( uint8_t index = 0; index < macroTriggerListBufferSize; index += 2 )
{
// Get scanCode, first item of macroTriggerListBuffer pairs
uint8_t scanCode = macroTriggerListBuffer[ index ];
// Lookup trigger list for this key
unsigned int *triggerList = Macro_layerLookup( scanCode );
// The first element is the length of the trigger list
unsigned int triggerListSize = triggerList[0];
// Loop through the trigger list
for ( unsigned int trigger = 0; trigger < triggerListSize; trigger++ )
{
// Lookup TriggerMacro
TriggerMacro *triggerMacro = (TriggerMacro*)triggerList[ trigger + 1 ];
// Get triggered state of scan code, second item of macroTriggerListBuffer pairs
uint8_t state = macroTriggerListBuffer[ index + 1 ];
// Evaluate Macro
Macro_evalTriggerMacro( triggerMacro );
}
}
/* TODO
// Loop through input buffer
2014-06-14 18:00:29 +00:00
for ( uint8_t index = 0; index < KeyIndex_BufferUsed && !macroDebugMode; index++ )
{
//print(" KEYS: ");
//printInt8( KeyIndex_BufferUsed );
// Get the keycode from the buffer
uint8_t key = KeyIndex_Buffer[index];
// Set the modifier bit if this key is a modifier
if ( (key & KEY_LCTRL) == KEY_LCTRL ) // AND with 0xE0
{
USBKeys_Modifiers |= 1 << (key ^ KEY_LCTRL); // Left shift 1 by key XOR 0xE0
// Modifier processed, move on to the next key
continue;
}
// Too many keys
if ( USBKeys_Sent >= USBKeys_MaxSize )
{
warn_msg("USB Key limit reached");
errorLED( 1 );
break;
}
// Allow ignoring keys with 0's
if ( key != 0 )
{
USBKeys_Array[USBKeys_Sent++] = key;
}
else
{
// Key was not mapped
erro_msg( "Key not mapped... - " );
printHex( key );
errorLED( 1 );
}
}
*/
// Signal buffer that we've used it
Scan_finishedWithBuffer( KeyIndex_BufferUsed );
// If Macro debug mode is set, clear the USB Buffer
if ( macroDebugMode )
{
USBKeys_Modifiers = 0;
USBKeys_Sent = 0;
}
}
inline void Macro_setup()
{
// Register Macro CLI dictionary
CLI_registerDictionary( macroCLIDict, macroCLIDictName );
// Disable Macro debug mode
macroDebugMode = 0;
// Make sure macro trigger buffer is empty
macroTriggerListBufferSize = 0;
}
// ----- CLI Command Functions -----
void cliFunc_capList( char* args )
{
// TODO
}
void cliFunc_capSelect( char* args )
{
// Parse code from argument
// NOTE: Only first argument is used
char* arg1Ptr;
char* arg2Ptr;
CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr );
// Depending on the first character, the lookup changes
switch ( arg1Ptr[0] )
{
// Keyboard Capability
case 'K':
// TODO
break;
// Scancode
case 'S':
// Add to the USB Buffer using the DefaultMap lookup
Macro_bufferAdd( decToInt( &arg1Ptr[1] ) );
break;
// USB Code
case 'U':
// Just add the key to the USB Buffer
if ( KeyIndex_BufferUsed < KEYBOARD_BUFFER )
{
KeyIndex_Buffer[KeyIndex_BufferUsed++] = decToInt( &arg1Ptr[1] );
}
break;
}
}
void cliFunc_lookComb( char* args )
{
// Parse code from argument
// NOTE: Only first argument is used
char* arg1Ptr;
char* arg2Ptr;
CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr );
// Depending on the first character, the lookup changes
switch ( arg1Ptr[0] )
{
// Scancode
case 'S':
// TODO
break;
// USB Code
case 'U':
// TODO
break;
}
}
void cliFunc_lookDefault( char* args )
{
// Parse code from argument
// NOTE: Only first argument is used
char* arg1Ptr;
char* arg2Ptr;
CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr );
// Depending on the first character, the lookup changes
switch ( arg1Ptr[0] )
{
// Scancode
case 'S':
print( NL );
printInt8( DefaultMap_Lookup[decToInt( &arg1Ptr[1] )] );
print(" ");
printHex( DefaultMap_Lookup[decToInt( &arg1Ptr[1] )] );
break;
}
}
void cliFunc_lookPartial( char* args )
{
// Parse code from argument
// NOTE: Only first argument is used
char* arg1Ptr;
char* arg2Ptr;
CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr );
// Depending on the first character, the lookup changes
switch ( arg1Ptr[0] )
{
// Scancode
case 'S':
// TODO
break;
// USB Code
case 'U':
// TODO
break;
}
}
void cliFunc_macroDebug( char* args )
{
// Toggle macro debug mode
macroDebugMode = macroDebugMode ? 0 : 1;
print( NL );
info_msg("Macro Debug Mode: ");
printInt8( macroDebugMode );
}