1 /* Copyright (C) 2014 by Jacob Alexander
3 * Permission is hereby granted, free of charge, to any person obtaining a copy
4 * of this software and associated documentation files (the "Software"), to deal
5 * in the Software without restriction, including without limitation the rights
6 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 * copies of the Software, and to permit persons to whom the Software is
8 * furnished to do so, subject to the following conditions:
10 * The above copyright notice and this permission notice shall be included in
11 * all copies or substantial portions of the Software.
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 // ----- Includes -----
25 #include <Lib/MacroLib.h>
31 #include <scan_loop.h>
32 #include <output_com.h>
36 #include <defaultMap.h>
43 // ----- Function Declarations -----
45 void cliFunc_capList ( char* args );
46 void cliFunc_capSelect ( char* args );
47 void cliFunc_lookComb ( char* args );
48 void cliFunc_lookDefault( char* args );
49 void cliFunc_lookPartial( char* args );
50 void cliFunc_macroDebug ( char* args );
54 // ----- Variables -----
56 // Macro Module command dictionary
57 char* macroCLIDictName = "Macro Module Commands (Not all commands fully work yet...)";
58 CLIDictItem macroCLIDict[] = {
59 { "capList", "Prints an indexed list of all non USB keycode capabilities.", cliFunc_capList },
60 { "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 },
61 { "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 },
62 { "lookDefault", "Do a lookup on the Default map." NL "\t\t\033[35mS10\033[0m Scancode 0x0A", cliFunc_lookDefault },
63 { "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 },
64 { "macroDebug", "Disables/Enables sending USB keycodes to the Output Module and prints U/K codes.", cliFunc_macroDebug },
65 { 0, 0, 0 } // Null entry for dictionary end
69 // Macro debug flag - If set, clears the USB Buffers after signalling processing completion
70 uint8_t macroDebugMode = 0;
74 // ----- Functions -----
76 // Looks up the start of the function ptr list for the active layer, by scan code
77 inline void *Macro_layerLookup( uint8_t scanCode )
84 // Called for each key from the Scan Module for one of three cases:
85 // 1. Key is pressed (PRESSED)
86 // 2. Key is being held down (HELD)
87 // 3. Key is released (RELEASED)
88 // If Scan Module is for an analog sense keyboard, do not use the defined keystates
89 // This function should not be called if not pressed (depressed) or at 0%
90 inline void Macro_keyUpdate( uint8_t scanCode, uint8_t state )
92 // Do layer lookup to find which capabilities to map
93 void *capabilities = Macro_layerLookup( scanCode );
114 inline void Macro_bufferAdd( uint8_t byte )
116 // Make sure we haven't overflowed the key buffer
117 // Default function for adding keys to the KeyIndex_Buffer, does a DefaultMap_Lookup
118 if ( KeyIndex_BufferUsed < KEYBOARD_BUFFER )
120 uint8_t key = DefaultMap_Lookup[byte];
121 for ( uint8_t c = 0; c < KeyIndex_BufferUsed; c++ )
123 // Key already in the buffer
124 if ( KeyIndex_Buffer[c] == key )
129 KeyIndex_Buffer[KeyIndex_BufferUsed++] = key;
133 inline void Macro_bufferRemove( uint8_t byte )
135 uint8_t key = DefaultMap_Lookup[byte];
137 // Check for the released key, and shift the other keys lower on the buffer
138 for ( uint8_t c = 0; c < KeyIndex_BufferUsed; c++ )
140 // Key to release found
141 if ( KeyIndex_Buffer[c] == key )
143 // Shift keys from c position
144 for ( uint8_t k = c; k < KeyIndex_BufferUsed - 1; k++ )
145 KeyIndex_Buffer[k] = KeyIndex_Buffer[k + 1];
148 KeyIndex_BufferUsed--;
154 // Error case (no key to release)
155 erro_msg("Could not find key to release: ");
159 inline void Macro_finishWithUSBBuffer( uint8_t sentKeys )
163 inline void Macro_process()
165 // Only do one round of macro processing between Output Module timer sends
166 if ( USBKeys_Sent != 0 )
169 // Loop through input buffer
170 for ( uint8_t index = 0; index < KeyIndex_BufferUsed && !macroDebugMode; index++ )
173 //printInt8( KeyIndex_BufferUsed );
174 // Get the keycode from the buffer
175 uint8_t key = KeyIndex_Buffer[index];
177 // Set the modifier bit if this key is a modifier
178 if ( (key & KEY_LCTRL) == KEY_LCTRL ) // AND with 0xE0
180 USBKeys_Modifiers |= 1 << (key ^ KEY_LCTRL); // Left shift 1 by key XOR 0xE0
182 // Modifier processed, move on to the next key
187 if ( USBKeys_Sent >= USBKeys_MaxSize )
189 warn_msg("USB Key limit reached");
194 // Allow ignoring keys with 0's
197 USBKeys_Array[USBKeys_Sent++] = key;
201 // Key was not mapped
202 erro_msg( "Key not mapped... - " );
208 // Signal buffer that we've used it
209 Scan_finishedWithBuffer( KeyIndex_BufferUsed );
211 // If Macro debug mode is set, clear the USB Buffer
212 if ( macroDebugMode )
214 USBKeys_Modifiers = 0;
219 inline void Macro_setup()
221 // Register Macro CLI dictionary
222 CLI_registerDictionary( macroCLIDict, macroCLIDictName );
224 // Disable Macro debug mode
229 // ----- CLI Command Functions -----
231 void cliFunc_capList( char* args )
236 void cliFunc_capSelect( char* args )
238 // Parse code from argument
239 // NOTE: Only first argument is used
242 CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr );
244 // Depending on the first character, the lookup changes
245 switch ( arg1Ptr[0] )
247 // Keyboard Capability
254 // Add to the USB Buffer using the DefaultMap lookup
255 Macro_bufferAdd( decToInt( &arg1Ptr[1] ) );
260 // Just add the key to the USB Buffer
261 if ( KeyIndex_BufferUsed < KEYBOARD_BUFFER )
263 KeyIndex_Buffer[KeyIndex_BufferUsed++] = decToInt( &arg1Ptr[1] );
269 void cliFunc_lookComb( char* args )
271 // Parse code from argument
272 // NOTE: Only first argument is used
275 CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr );
277 // Depending on the first character, the lookup changes
278 switch ( arg1Ptr[0] )
292 void cliFunc_lookDefault( char* args )
294 // Parse code from argument
295 // NOTE: Only first argument is used
298 CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr );
300 // Depending on the first character, the lookup changes
301 switch ( arg1Ptr[0] )
306 printInt8( DefaultMap_Lookup[decToInt( &arg1Ptr[1] )] );
308 printHex( DefaultMap_Lookup[decToInt( &arg1Ptr[1] )] );
313 void cliFunc_lookPartial( char* args )
315 // Parse code from argument
316 // NOTE: Only first argument is used
319 CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr );
321 // Depending on the first character, the lookup changes
322 switch ( arg1Ptr[0] )
336 void cliFunc_macroDebug( char* args )
338 // Toggle macro debug mode
339 macroDebugMode = macroDebugMode ? 0 : 1;
342 info_msg("Macro Debug Mode: ");
343 printInt8( macroDebugMode );