louis/kiibohd-controller: Macro/PartialMap/macro.c annotate

annotate Macro/PartialMap/macro.c @ 453:98bbee08f005 default tip louis

Setup hgignore, volume/brightness up/down, sysreq still not working

author	Louis Opter <kalessin@kalessin.fr>
date	Wed, 13 Jul 2016 23:16:49 -0700
parents	0f7a6b593dc4
children

rev	line source
433 0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	1 /* Copyright (C) 2014-2016 by Jacob Alexander
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	2 *
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	3 * This file is free software: you can redistribute it and/or modify
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	4 * it under the terms of the GNU General Public License as published by
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	5 * the Free Software Foundation, either version 3 of the License, or
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	6 * (at your option) any later version.
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	7 *
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	8 * This file is distributed in the hope that it will be useful,
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	11 * GNU General Public License for more details.
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	12 *
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	13 * You should have received a copy of the GNU General Public License
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	14 * along with this file. If not, see <http://www.gnu.org/licenses/>.
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	15 */
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	16
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	17 // ----- Includes -----
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	18
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	19 // Compiler Includes
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	20 #include <Lib/MacroLib.h>
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	21
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	22 // Project Includes
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	23 #include <cli.h>
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	24 #include <led.h>
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	25 #include <print.h>
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	26 #include <scan_loop.h>
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	27
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	28 // Keymaps
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	29 #include "usb_hid.h"
205 a2e9bb170eef Adding CMake build support for the KLL compiler Jacob Alexander <haata@kiibohd.com> parents: 204 diff changeset	30 #include <generatedKeymap.h> // Generated using kll at compile time, in build directory
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	31
360 dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	32 // Connect Includes
dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	33 #if defined(ConnectEnabled_define)
dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	34 #include <connect_scan.h>
dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	35 #endif
dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	36
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	37 // Local Includes
433 0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	38 #include "trigger.h"
0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	39 #include "result.h"
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	40 #include "macro.h"
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	41
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	42
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	43
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	44 // ----- Function Declarations -----
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	45
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	46 void cliFunc_capList ( char* args );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	47 void cliFunc_capSelect ( char* args );
192 6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	48 void cliFunc_keyHold ( char* args );
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	49 void cliFunc_keyPress ( char* args );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	50 void cliFunc_keyRelease( char* args );
344 f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	51 void cliFunc_layerDebug( char* args );
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	52 void cliFunc_layerList ( char* args );
183 bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	53 void cliFunc_layerState( char* args );
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	54 void cliFunc_macroDebug( char* args );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	55 void cliFunc_macroList ( char* args );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	56 void cliFunc_macroProc ( char* args );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	57 void cliFunc_macroShow ( char* args );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	58 void cliFunc_macroStep ( char* args );
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	59
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	60
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	61
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	62 // ----- Variables -----
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	63
132 e08d7b586ea3 Adding analog.c lib from teensyduino. Jacob Alexander <haata@kiibohd.com> parents: 126 diff changeset	64 // Macro Module command dictionary
239 2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	65 CLIDict_Entry( capList, "Prints an indexed list of all non USB keycode capabilities." );
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	66 CLIDict_Entry( capSelect, "Triggers the specified capabilities. First two args are state and stateType." NL "\t\t\033[35mK11\033[0m Keyboard Capability 0x0B" );
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	67 CLIDict_Entry( keyHold, "Send key-hold events to the macro module. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A" );
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	68 CLIDict_Entry( keyPress, "Send key-press events to the macro module. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A" );
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	69 CLIDict_Entry( keyRelease, "Send key-release event to macro module. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A" );
344 f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	70 CLIDict_Entry( layerDebug, "Layer debug mode. Shows layer stack and any changes." );
239 2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	71 CLIDict_Entry( layerList, "List available layers." );
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	72 CLIDict_Entry( layerState, "Modify specified indexed layer state <layer> <state byte>." NL "\t\t\033[35mL2\033[0m Indexed Layer 0x02" NL "\t\t0 Off, 1 Shift, 2 Latch, 4 Lock States" );
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	73 CLIDict_Entry( macroDebug, "Disables/Enables sending USB keycodes to the Output Module and prints U/K codes." );
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	74 CLIDict_Entry( macroList, "List the defined trigger and result macros." );
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	75 CLIDict_Entry( macroProc, "Pause/Resume macro processing." );
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	76 CLIDict_Entry( macroShow, "Show the macro corresponding to the given index." NL "\t\t\033[35mT16\033[0m Indexed Trigger Macro 0x10, \033[35mR12\033[0m Indexed Result Macro 0x0C" );
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	77 CLIDict_Entry( macroStep, "Do N macro processing steps. Defaults to 1." );
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	78
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	79 CLIDict_Def( macroCLIDict, "Macro Module Commands" ) = {
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	80 CLIDict_Item( capList ),
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	81 CLIDict_Item( capSelect ),
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	82 CLIDict_Item( keyHold ),
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	83 CLIDict_Item( keyPress ),
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	84 CLIDict_Item( keyRelease ),
344 f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	85 CLIDict_Item( layerDebug ),
239 2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	86 CLIDict_Item( layerList ),
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	87 CLIDict_Item( layerState ),
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	88 CLIDict_Item( macroDebug ),
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	89 CLIDict_Item( macroList ),
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	90 CLIDict_Item( macroProc ),
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	91 CLIDict_Item( macroShow ),
2a4c99da1276 HUGE AVR RAM optimization (~28%). Jacob Alexander <haata@kiibohd.com> parents: 217 diff changeset	92 CLIDict_Item( macroStep ),
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	93 { 0, 0, 0 } // Null entry for dictionary end
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	94 };
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	95
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	96
344 f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	97 // Layer debug flag - If set, displays any changes to layers and the full layer stack on change
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	98 uint8_t layerDebugMode = 0;
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	99
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	100 // Macro debug flag - If set, clears the USB Buffers after signalling processing completion
670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	101 uint8_t macroDebugMode = 0;
670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	102
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	103 // Macro pause flag - If set, the macro module pauses processing, unless unset, or the step counter is non-zero
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	104 uint8_t macroPauseMode = 0;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	105
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	106 // Macro step counter - If non-zero, the step counter counts down every time the macro module does one processing loop
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	107 uint16_t macroStepCounter = 0;
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	108
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	109
297 c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	110 // Key Trigger List Buffer and Layer Cache
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	111 // The layer cache is set on press only, hold and release events refer to the value set on press
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	112 TriggerGuide macroTriggerListBuffer[ MaxScanCode ];
410 8fa2619aa60e Fix a handful of infinite loops that occur if you have more than 254 macros Kevin Frei <freik@fb.com> parents: 385 diff changeset	113 var_uint_t macroTriggerListBufferSize = 0;
297 c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	114 var_uint_t macroTriggerListLayerCache[ MaxScanCode ];
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	115
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	116 // Layer Index Stack
f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	117 // * When modifying layer state and the state is non-0x0, the stack must be adjusted
433 0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	118 index_uint_t macroLayerIndexStack[ LayerNum + 1 ] = { 0 };
0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	119 index_uint_t macroLayerIndexStackSize = 0;
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	120
433 0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	121 // TODO REMOVE when dependency no longer exists
0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	122 extern index_uint_t macroResultMacroPendingList[];
0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	123 extern index_uint_t macroResultMacroPendingListSize;
0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	124 extern index_uint_t macroTriggerMacroPendingList[];
0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	125 extern index_uint_t macroTriggerMacroPendingListSize;
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	126
361 7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	127 // Interconnect ScanCode Cache
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	128 #if defined(ConnectEnabled_define)
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	129 // TODO This can be shrunk by the size of the max node 0 ScanCode
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	130 TriggerGuide macroInterconnectCache[ MaxScanCode ];
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	131 uint8_t macroInterconnectCacheSize = 0;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	132 #endif
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	133
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	134
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	135
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	136 // ----- Capabilities -----
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	137
199 559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	138 // Sets the given layer with the specified layerState
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	139 void Macro_layerState( uint8_t state, uint8_t stateType, uint16_t layer, uint8_t layerState )
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	140 {
377 dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	141 // Ignore if layer does not exist or trying to manipulate layer 0/Default layer
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	142 if ( layer >= LayerNum \|\| layer == 0 )
241 9f62492034c7 Fixing bug that locks up the keyboard if shifting to a layer that doesn't exist. Jacob Alexander <haata@kiibohd.com> parents: 239 diff changeset	143 return;
9f62492034c7 Fixing bug that locks up the keyboard if shifting to a layer that doesn't exist. Jacob Alexander <haata@kiibohd.com> parents: 239 diff changeset	144
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	145 // Is layer in the LayerIndexStack?
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	146 uint8_t inLayerIndexStack = 0;
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	147 uint16_t stackItem = 0;
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	148 while ( stackItem < macroLayerIndexStackSize )
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	149 {
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	150 // Flag if layer is already in the LayerIndexStack
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	151 if ( macroLayerIndexStack[ stackItem ] == layer )
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	152 {
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	153 inLayerIndexStack = 1;
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	154 break;
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	155 }
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	156
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	157 // Increment to next item
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	158 stackItem++;
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	159 }
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	160
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	161 // Toggle Layer State Byte
214 5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	162 if ( LayerState[ layer ] & layerState )
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	163 {
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	164 // Unset
214 5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	165 LayerState[ layer ] &= ~layerState;
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	166 }
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	167 else
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	168 {
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	169 // Set
214 5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	170 LayerState[ layer ] \|= layerState;
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	171 }
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	172
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	173 // If the layer was not in the LayerIndexStack add it
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	174 if ( !inLayerIndexStack )
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	175 {
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	176 macroLayerIndexStack[ macroLayerIndexStackSize++ ] = layer;
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	177 }
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	178
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	179 // If the layer is in the LayerIndexStack and the state is 0x00, remove
214 5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	180 if ( LayerState[ layer ] == 0x00 && inLayerIndexStack )
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	181 {
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	182 // Remove the layer from the LayerIndexStack
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	183 // Using the already positioned stackItem variable from the loop above
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	184 while ( stackItem < macroLayerIndexStackSize )
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	185 {
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	186 macroLayerIndexStack[ stackItem ] = macroLayerIndexStack[ stackItem + 1 ];
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	187 stackItem++;
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	188 }
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	189
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	190 // Reduce LayerIndexStack size
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	191 macroLayerIndexStackSize--;
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	192 }
344 f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	193
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	194 // Layer Debug Mode
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	195 if ( layerDebugMode )
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	196 {
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	197 dbug_msg("Layer ");
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	198
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	199 // Iterate over each of the layers displaying the state as a hex value
433 0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	200 for ( index_uint_t index = 0; index < LayerNum; index++ )
344 f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	201 {
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	202 printHex_op( LayerState[ index ], 0 );
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	203 }
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	204
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	205 // Always show the default layer (it's always 0)
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	206 print(" 0");
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	207
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	208 // Iterate over the layer stack starting from the bottom of the stack
433 0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	209 for ( index_uint_t index = macroLayerIndexStackSize; index > 0; index-- )
344 f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	210 {
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	211 print(":");
345 2bcf6800b851 Fixing order of layer debug stack display Jacob Alexander <haata@kiibohd.com> parents: 344 diff changeset	212 printHex_op( macroLayerIndexStack[ index - 1 ], 0 );
344 f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	213 }
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	214
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	215 print( NL );
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	216 }
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	217 }
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	218
199 559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	219 // Modifies the specified Layer control byte
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	220 // Argument #1: Layer Index -> uint16_t
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	221 // Argument #2: Layer State -> uint8_t
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	222 void Macro_layerState_capability( uint8_t state, uint8_t stateType, uint8_t *args )
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	223 {
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	224 // Display capability name
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	225 if ( stateType == 0xFF && state == 0xFF )
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	226 {
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	227 print("Macro_layerState(layerIndex,layerState)");
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	228 return;
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	229 }
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	230
201 326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	231 // Only use capability on press or release
326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	232 // TODO Analog
326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	233 // XXX This may cause issues, might be better to implement state table here to decide -HaaTa
326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	234 if ( stateType == 0x00 && state == 0x02 ) // Hold condition
326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	235 return;
326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	236
199 559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	237 // Get layer index from arguments
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	238 // Cast pointer to uint8_t to uint16_t then access that memory location
199 559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	239 uint16_t layer = (uint16_t)(&args[0]);
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	240
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	241 // Get layer toggle byte
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	242 uint8_t layerState = args[ sizeof(uint16_t) ];
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	243
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	244 Macro_layerState( state, stateType, layer, layerState );
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	245 }
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	246
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	247
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	248 // Latches given layer
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	249 // Argument #1: Layer Index -> uint16_t
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	250 void Macro_layerLatch_capability( uint8_t state, uint8_t stateType, uint8_t *args )
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	251 {
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	252 // Display capability name
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	253 if ( stateType == 0xFF && state == 0xFF )
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	254 {
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	255 print("Macro_layerLatch(layerIndex)");
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	256 return;
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	257 }
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	258
201 326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	259 // Only use capability on press
326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	260 // TODO Analog
253 e79f2b9c39cf Fixing layer latch capability. Jacob Alexander <haata@kiibohd.com> parents: 241 diff changeset	261 if ( stateType == 0x00 && state != 0x03 ) // Only on release
201 326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	262 return;
326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	263
199 559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	264 // Get layer index from arguments
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	265 // Cast pointer to uint8_t to uint16_t then access that memory location
199 559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	266 uint16_t layer = (uint16_t)(&args[0]);
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	267
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	268 Macro_layerState( state, stateType, layer, 0x02 );
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	269 }
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	270
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	271
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	272 // Locks given layer
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	273 // Argument #1: Layer Index -> uint16_t
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	274 void Macro_layerLock_capability( uint8_t state, uint8_t stateType, uint8_t *args )
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	275 {
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	276 // Display capability name
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	277 if ( stateType == 0xFF && state == 0xFF )
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	278 {
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	279 print("Macro_layerLock(layerIndex)");
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	280 return;
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	281 }
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	282
201 326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	283 // Only use capability on press
326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	284 // TODO Analog
326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	285 // XXX Could also be on release, but that's sorta dumb -HaaTa
326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	286 if ( stateType == 0x00 && state != 0x01 ) // All normal key conditions except press
326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	287 return;
326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	288
199 559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	289 // Get layer index from arguments
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	290 // Cast pointer to uint8_t to uint16_t then access that memory location
199 559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	291 uint16_t layer = (uint16_t)(&args[0]);
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	292
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	293 Macro_layerState( state, stateType, layer, 0x04 );
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	294 }
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	295
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	296
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	297 // Shifts given layer
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	298 // Argument #1: Layer Index -> uint16_t
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	299 void Macro_layerShift_capability( uint8_t state, uint8_t stateType, uint8_t *args )
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	300 {
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	301 // Display capability name
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	302 if ( stateType == 0xFF && state == 0xFF )
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	303 {
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	304 print("Macro_layerShift(layerIndex)");
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	305 return;
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	306 }
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	307
201 326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	308 // Only use capability on press or release
326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	309 // TODO Analog
326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	310 if ( stateType == 0x00 && ( state == 0x00 \|\| state == 0x02 ) ) // Only pass press or release conditions
326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	311 return;
326f75709d10 Fixing release state for keys Jacob Alexander <jacob.alexander@virtualinstruments.com> parents: 199 diff changeset	312
199 559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	313 // Get layer index from arguments
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	314 // Cast pointer to uint8_t to uint16_t then access that memory location
199 559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	315 uint16_t layer = (uint16_t)(&args[0]);
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	316
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	317 Macro_layerState( state, stateType, layer, 0x01 );
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	318 }
559a467f6d57 Preparing for kll compiler usage Jacob Alexander <haata@kiibohd.com> parents: 197 diff changeset	319
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	320
377 dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	321 // Rotate layer to next/previous
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	322 // Uses state variable to keep track of the current layer position
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	323 // Layers are still evaluated using the layer stack
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	324 uint16_t Macro_rotationLayer;
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	325 void Macro_layerRotate_capability( uint8_t state, uint8_t stateType, uint8_t *args )
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	326 {
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	327 // Display capability name
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	328 if ( stateType == 0xFF && state == 0xFF )
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	329 {
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	330 print("Macro_layerRotate(previous)");
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	331 return;
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	332 }
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	333
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	334 // Only use capability on press
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	335 // TODO Analog
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	336 // XXX Could also be on release, but that's sorta dumb -HaaTa
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	337 if ( stateType == 0x00 && state != 0x01 ) // All normal key conditions except press
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	338 return;
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	339
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	340 // Unset previous rotation layer if not 0
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	341 if ( Macro_rotationLayer != 0 )
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	342 {
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	343 Macro_layerState( state, stateType, Macro_rotationLayer, 0x04 );
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	344 }
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	345
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	346 // Get direction of rotation, 0, next, non-zero previous
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	347 uint8_t direction = *args;
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	348
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	349 // Next
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	350 if ( !direction )
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	351 {
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	352 Macro_rotationLayer++;
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	353
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	354 // Invalid layer
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	355 if ( Macro_rotationLayer >= LayerNum )
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	356 Macro_rotationLayer = 0;
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	357 }
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	358 // Previous
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	359 else
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	360 {
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	361 Macro_rotationLayer--;
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	362
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	363 // Layer wrap
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	364 if ( Macro_rotationLayer >= LayerNum )
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	365 Macro_rotationLayer = LayerNum - 1;
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	366 }
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	367
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	368 // Toggle the computed layer rotation
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	369 Macro_layerState( state, stateType, Macro_rotationLayer, 0x04 );
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	370 }
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	371
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	372
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	373
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	374 // ----- Functions -----
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	375
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	376 // Looks up the trigger list for the given scan code (from the active layer)
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	377 // NOTE: Calling function must handle the NULL pointer case
297 c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	378 nat_ptr_t Macro_layerLookup( TriggerGuide guide, uint8_t latch_expire )
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	379 {
297 c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	380 uint8_t scanCode = guide->scanCode;
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	381
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	382 // TODO Analog
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	383 // If a normal key, and not pressed, do a layer cache lookup
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	384 if ( guide->type == 0x00 && guide->state != 0x01 )
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	385 {
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	386 // Cached layer
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	387 var_uint_t cachedLayer = macroTriggerListLayerCache[ scanCode ];
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	388
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	389 // Lookup map, then layer
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	390 nat_ptr_t map = (nat_ptr_t)LayerIndex[ cachedLayer ].triggerMap;
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	391 const Layer *layer = &LayerIndex[ cachedLayer ];
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	392
380 5f085e29a66c Fix Latching bug (introduced when fixing shift and lock recently) Jacob Alexander <haata@kiibohd.com> parents: 377 diff changeset	393 // Cache trigger list before attempting to expire latch
5f085e29a66c Fix Latching bug (introduced when fixing shift and lock recently) Jacob Alexander <haata@kiibohd.com> parents: 377 diff changeset	394 nat_ptr_t *trigger_list = map[ scanCode - layer->first ];
5f085e29a66c Fix Latching bug (introduced when fixing shift and lock recently) Jacob Alexander <haata@kiibohd.com> parents: 377 diff changeset	395
5f085e29a66c Fix Latching bug (introduced when fixing shift and lock recently) Jacob Alexander <haata@kiibohd.com> parents: 377 diff changeset	396 // Check if latch has been pressed for this layer
5f085e29a66c Fix Latching bug (introduced when fixing shift and lock recently) Jacob Alexander <haata@kiibohd.com> parents: 377 diff changeset	397 uint8_t latch = LayerState[ cachedLayer ] & 0x02;
5f085e29a66c Fix Latching bug (introduced when fixing shift and lock recently) Jacob Alexander <haata@kiibohd.com> parents: 377 diff changeset	398 if ( latch && latch_expire )
5f085e29a66c Fix Latching bug (introduced when fixing shift and lock recently) Jacob Alexander <haata@kiibohd.com> parents: 377 diff changeset	399 {
5f085e29a66c Fix Latching bug (introduced when fixing shift and lock recently) Jacob Alexander <haata@kiibohd.com> parents: 377 diff changeset	400 Macro_layerState( 0, 0, cachedLayer, 0x02 );
5f085e29a66c Fix Latching bug (introduced when fixing shift and lock recently) Jacob Alexander <haata@kiibohd.com> parents: 377 diff changeset	401 #if defined(ConnectEnabled_define) && defined(LCDEnabled_define)
5f085e29a66c Fix Latching bug (introduced when fixing shift and lock recently) Jacob Alexander <haata@kiibohd.com> parents: 377 diff changeset	402 // Evaluate the layerStack capability if available (LCD + Interconnect)
5f085e29a66c Fix Latching bug (introduced when fixing shift and lock recently) Jacob Alexander <haata@kiibohd.com> parents: 377 diff changeset	403 extern void LCD_layerStack_capability( uint8_t state, uint8_t stateType, uint8_t *args );
5f085e29a66c Fix Latching bug (introduced when fixing shift and lock recently) Jacob Alexander <haata@kiibohd.com> parents: 377 diff changeset	404 LCD_layerStack_capability( 0, 0, 0 );
5f085e29a66c Fix Latching bug (introduced when fixing shift and lock recently) Jacob Alexander <haata@kiibohd.com> parents: 377 diff changeset	405 #endif
5f085e29a66c Fix Latching bug (introduced when fixing shift and lock recently) Jacob Alexander <haata@kiibohd.com> parents: 377 diff changeset	406 }
5f085e29a66c Fix Latching bug (introduced when fixing shift and lock recently) Jacob Alexander <haata@kiibohd.com> parents: 377 diff changeset	407
5f085e29a66c Fix Latching bug (introduced when fixing shift and lock recently) Jacob Alexander <haata@kiibohd.com> parents: 377 diff changeset	408 return trigger_list;
297 c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	409 }
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	410
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	411 // If no trigger macro is defined at the given layer, fallthrough to the next layer
371 23104e8e24f4 Fixing layer stack evaluation Jacob Alexander <haata@kiibohd.com> parents: 364 diff changeset	412 for ( uint16_t layerIndex = macroLayerIndexStackSize; layerIndex != 0xFFFF; layerIndex-- )
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	413 {
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	414 // Lookup Layer
214 5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	415 const Layer *layer = &LayerIndex[ macroLayerIndexStack[ layerIndex ] ];
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	416
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	417 // Check if latch has been pressed for this layer
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	418 // XXX Regardless of whether a key is found, the latch is removed on first lookup
253 e79f2b9c39cf Fixing layer latch capability. Jacob Alexander <haata@kiibohd.com> parents: 241 diff changeset	419 uint8_t latch = LayerState[ macroLayerIndexStack[ layerIndex ] ] & 0x02;
e79f2b9c39cf Fixing layer latch capability. Jacob Alexander <haata@kiibohd.com> parents: 241 diff changeset	420 if ( latch && latch_expire )
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	421 {
253 e79f2b9c39cf Fixing layer latch capability. Jacob Alexander <haata@kiibohd.com> parents: 241 diff changeset	422 Macro_layerState( 0, 0, macroLayerIndexStack[ layerIndex ], 0x02 );
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	423 }
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	424
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	425 // Only use layer, if state is valid
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	426 // XOR each of the state bits
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	427 // If only two are enabled, do not use this state
216 738445f38639 DPH controller now working with the kishsaver and macros Jacob Alexander <haata@kiibohd.com> parents: 215 diff changeset	428 if ( (LayerState[ macroLayerIndexStack[ layerIndex ] ] & 0x01) ^ (latch>>1) ^ ((LayerState[ macroLayerIndexStack[ layerIndex ] ] & 0x04)>>2) )
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	429 {
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	430 // Lookup layer
202 1a68a9a04ad3 Adding variable width state variable width. Jacob Alexander <haata@kiibohd.com> parents: 201 diff changeset	431 nat_ptr_t map = (nat_ptr_t)layer->triggerMap;
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	432
3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	433 // Determine if layer has key defined
214 5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	434 // Make sure scanCode is between layer first and last scancodes
5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	435 if ( map != 0
377 dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	436 && scanCode <= layer->last
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	437 && scanCode >= layer->first
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	438 && *map[ scanCode - layer->first ] != 0 )
214 5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	439 {
297 c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	440 // Set the layer cache
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	441 macroTriggerListLayerCache[ scanCode ] = macroLayerIndexStack[ layerIndex ];
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	442
214 5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	443 return map[ scanCode - layer->first ];
5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	444 }
191 3404be65670b Adding generic layerToggle and USB Key Output capabilities. Jacob Alexander <haata@kiibohd.com> parents: 190 diff changeset	445 }
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	446 }
f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	447
f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	448 // Do lookup on default layer
202 1a68a9a04ad3 Adding variable width state variable width. Jacob Alexander <haata@kiibohd.com> parents: 201 diff changeset	449 nat_ptr_t map = (nat_ptr_t)LayerIndex[0].triggerMap;
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	450
214 5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	451 // Lookup default layer
216 738445f38639 DPH controller now working with the kishsaver and macros Jacob Alexander <haata@kiibohd.com> parents: 215 diff changeset	452 const Layer *layer = &LayerIndex[0];
214 5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	453
5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	454 // Make sure scanCode is between layer first and last scancodes
5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	455 if ( map != 0
377 dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	456 && scanCode <= layer->last
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	457 && scanCode >= layer->first
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	458 && *map[ scanCode - layer->first ] != 0 )
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	459 {
297 c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	460 // Set the layer cache to default map
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	461 macroTriggerListLayerCache[ scanCode ] = 0;
c86eb7d0a693 Fixing releasing Function key and holding layered key Jacob Alexander <haata@kiibohd.com> parents: 271 diff changeset	462
214 5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	463 return map[ scanCode - layer->first ];
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	464 }
f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	465
214 5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	466 // Otherwise no defined Trigger Macro
5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	467 erro_msg("Scan Code has no defined Trigger Macro: ");
5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	468 printHex( scanCode );
361 7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	469 print( NL );
214 5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	470 return 0;
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	471 }
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	472
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	473
361 7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	474 // Add an interconnect ScanCode
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	475 // These are handled differently (less information is sent, hold/off states must be assumed)
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	476 #if defined(ConnectEnabled_define)
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	477 inline void Macro_interconnectAdd( void *trigger_ptr )
307 ecd2ae35d25c Initial commit for UARTConnect module Jacob Alexander <haata@kiibohd.com> parents: 297 diff changeset	478 {
361 7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	479 TriggerGuide trigger = (TriggerGuide)trigger_ptr;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	480
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	481 // Error checking
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	482 uint8_t error = 0;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	483 switch ( trigger->type )
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	484 {
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	485 case 0x00: // Normal key
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	486 switch ( trigger->state )
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	487 {
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	488 case 0x00:
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	489 case 0x01:
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	490 case 0x02:
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	491 case 0x03:
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	492 break;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	493 default:
362 e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	494 erro_msg("Invalid key state - ");
361 7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	495 error = 1;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	496 break;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	497 }
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	498 break;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	499
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	500 // Invalid TriggerGuide type
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	501 default:
362 e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	502 erro_msg("Invalid type - ");
361 7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	503 error = 1;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	504 break;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	505 }
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	506
362 e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	507 // Check if ScanCode is out of range
364 5aa3f6a92682 Fixing typo on range check for MDErgo1 Jacob Alexander <haata@kiibohd.com> parents: 362 diff changeset	508 if ( trigger->scanCode > MaxScanCode )
362 e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	509 {
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	510 warn_msg("ScanCode is out of range/not defined - ");
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	511 error = 1;
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	512 }
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	513
361 7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	514 // Display TriggerGuide
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	515 if ( error )
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	516 {
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	517 printHex( trigger->type );
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	518 print(" ");
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	519 printHex( trigger->state );
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	520 print(" ");
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	521 printHex( trigger->scanCode );
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	522 print( NL );
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	523 return;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	524 }
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	525
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	526 // Add trigger to the Interconnect Cache
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	527 // During each processing loop, a scancode may be re-added depending on it's state
410 8fa2619aa60e Fix a handful of infinite loops that occur if you have more than 254 macros Kevin Frei <freik@fb.com> parents: 385 diff changeset	528 for ( var_uint_t c = 0; c < macroInterconnectCacheSize; c++ )
361 7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	529 {
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	530 // Check if the same ScanCode
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	531 if ( macroInterconnectCache[ c ].scanCode == trigger->scanCode )
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	532 {
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	533 // Update the state
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	534 macroInterconnectCache[ c ].state = trigger->state;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	535 return;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	536 }
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	537 }
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	538
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	539 // If not in the list, add it
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	540 macroInterconnectCache[ macroInterconnectCacheSize++ ] = *trigger;
307 ecd2ae35d25c Initial commit for UARTConnect module Jacob Alexander <haata@kiibohd.com> parents: 297 diff changeset	541 }
361 7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	542 #endif
307 ecd2ae35d25c Initial commit for UARTConnect module Jacob Alexander <haata@kiibohd.com> parents: 297 diff changeset	543
ecd2ae35d25c Initial commit for UARTConnect module Jacob Alexander <haata@kiibohd.com> parents: 297 diff changeset	544
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	545 // Update the scancode key state
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	546 // States:
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	547 // * 0x00 - Off
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	548 // * 0x01 - Pressed
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	549 // * 0x02 - Held
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	550 // * 0x03 - Released
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	551 // * 0x04 - Unpressed (this is currently ignored)
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	552 inline void Macro_keyState( uint8_t scanCode, uint8_t state )
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	553 {
361 7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	554 #if defined(ConnectEnabled_define)
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	555 // Only compile in if a Connect node module is available
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	556 if ( !Connect_master )
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	557 {
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	558 // ScanCodes are only added if there was a state change (on/off)
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	559 switch ( state )
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	560 {
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	561 case 0x00: // Off
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	562 case 0x02: // Held
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	563 return;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	564 }
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	565 }
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	566 #endif
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	567
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	568 // Only add to macro trigger list if one of three states
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	569 switch ( state )
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	570 {
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	571 case 0x01: // Pressed
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	572 case 0x02: // Held
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	573 case 0x03: // Released
362 e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	574 // Check if ScanCode is out of range
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	575 if ( scanCode > MaxScanCode )
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	576 {
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	577 warn_msg("ScanCode is out of range/not defined: ");
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	578 printHex( scanCode );
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	579 print( NL );
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	580 return;
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	581 }
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	582
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	583 macroTriggerListBuffer[ macroTriggerListBufferSize ].scanCode = scanCode;
f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	584 macroTriggerListBuffer[ macroTriggerListBufferSize ].state = state;
f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	585 macroTriggerListBuffer[ macroTriggerListBufferSize ].type = 0x00; // Normal key
f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	586 macroTriggerListBufferSize++;
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	587 break;
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	588 }
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	589 }
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	590
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	591
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	592 // Update the scancode analog state
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	593 // States:
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	594 // * 0x00 - Off
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	595 // * 0x01 - Released
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	596 // * 0x02-0xFF - Analog value (low to high)
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	597 inline void Macro_analogState( uint8_t scanCode, uint8_t state )
166 2fba36caf039 Initial work for KLL macro support Jacob Alexander <haata@kiibohd.com> parents: 159 diff changeset	598 {
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	599 // Only add to macro trigger list if non-off
361 7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	600 // TODO Handle change for interconnect
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	601 if ( state != 0x00 )
f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	602 {
362 e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	603 // Check if ScanCode is out of range
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	604 if ( scanCode > MaxScanCode )
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	605 {
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	606 warn_msg("ScanCode is out of range/not defined: ");
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	607 printHex( scanCode );
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	608 print( NL );
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	609 return;
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	610 }
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	611
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	612 macroTriggerListBuffer[ macroTriggerListBufferSize ].scanCode = scanCode;
f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	613 macroTriggerListBuffer[ macroTriggerListBufferSize ].state = state;
f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	614 macroTriggerListBuffer[ macroTriggerListBufferSize ].type = 0x02; // Analog key
f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	615 macroTriggerListBufferSize++;
f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	616 }
166 2fba36caf039 Initial work for KLL macro support Jacob Alexander <haata@kiibohd.com> parents: 159 diff changeset	617 }
2fba36caf039 Initial work for KLL macro support Jacob Alexander <haata@kiibohd.com> parents: 159 diff changeset	618
2fba36caf039 Initial work for KLL macro support Jacob Alexander <haata@kiibohd.com> parents: 159 diff changeset	619
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	620 // Update led state
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	621 // States:
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	622 // * 0x00 - Off
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	623 // * 0x01 - On
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	624 inline void Macro_ledState( uint8_t ledCode, uint8_t state )
166 2fba36caf039 Initial work for KLL macro support Jacob Alexander <haata@kiibohd.com> parents: 159 diff changeset	625 {
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	626 // Only add to macro trigger list if non-off
361 7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	627 // TODO Handle change for interconnect
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	628 if ( state != 0x00 )
f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	629 {
362 e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	630 // Check if LedCode is out of range
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	631 // TODO
e4be15c39cce Adding initial WhiteFox support. Jacob Alexander <haata@kiibohd.com> parents: 361 diff changeset	632
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	633 macroTriggerListBuffer[ macroTriggerListBufferSize ].scanCode = ledCode;
f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	634 macroTriggerListBuffer[ macroTriggerListBufferSize ].state = state;
f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	635 macroTriggerListBuffer[ macroTriggerListBufferSize ].type = 0x01; // LED key
f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	636 macroTriggerListBufferSize++;
f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	637 }
166 2fba36caf039 Initial work for KLL macro support Jacob Alexander <haata@kiibohd.com> parents: 159 diff changeset	638 }
2fba36caf039 Initial work for KLL macro support Jacob Alexander <haata@kiibohd.com> parents: 159 diff changeset	639
2fba36caf039 Initial work for KLL macro support Jacob Alexander <haata@kiibohd.com> parents: 159 diff changeset	640
189 4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	641 // Append result macro to pending list, checking for duplicates
4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	642 // Do nothing if duplicate
433 0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	643 void Macro_appendResultMacroToPendingList( const TriggerMacro *triggerMacro )
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	644 {
196 8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	645 // Lookup result macro index
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	646 var_uint_t resultMacroIndex = triggerMacro->result;
196 8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	647
189 4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	648 // Iterate through result macro pending list, making sure this macro hasn't been added yet
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	649 for ( var_uint_t macro = 0; macro < macroResultMacroPendingListSize; macro++ )
189 4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	650 {
4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	651 // If duplicate found, do nothing
4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	652 if ( macroResultMacroPendingList[ macro ] == resultMacroIndex )
4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	653 return;
4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	654 }
166 2fba36caf039 Initial work for KLL macro support Jacob Alexander <haata@kiibohd.com> parents: 159 diff changeset	655
189 4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	656 // No duplicates found, add to pending list
4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	657 macroResultMacroPendingList[ macroResultMacroPendingListSize++ ] = resultMacroIndex;
196 8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	658
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	659 // Lookup scanCode of the last key in the last combo
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	660 var_uint_t pos = 0;
196 8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	661 for ( uint8_t comboLength = triggerMacro->guide[0]; comboLength > 0; )
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	662 {
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	663 pos += TriggerGuideSize * comboLength + 1;
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	664 comboLength = triggerMacro->guide[ pos ];
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	665 }
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	666
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	667 uint8_t scanCode = ((TriggerGuide*)&triggerMacro->guide[ pos - TriggerGuideSize ])->scanCode;
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	668
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	669 // Lookup scanCode in buffer list for the current state and stateType
410 8fa2619aa60e Fix a handful of infinite loops that occur if you have more than 254 macros Kevin Frei <freik@fb.com> parents: 385 diff changeset	670 for ( var_uint_t keyIndex = 0; keyIndex < macroTriggerListBufferSize; keyIndex++ )
196 8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	671 {
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	672 if ( macroTriggerListBuffer[ keyIndex ].scanCode == scanCode )
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	673 {
217 8ceb1a0582ee Adding more RAM optimizations Jacob Alexander <haata@kiibohd.com> parents: 216 diff changeset	674 ResultMacroRecordList[ resultMacroIndex ].state = macroTriggerListBuffer[ keyIndex ].state;
8ceb1a0582ee Adding more RAM optimizations Jacob Alexander <haata@kiibohd.com> parents: 216 diff changeset	675 ResultMacroRecordList[ resultMacroIndex ].stateType = macroTriggerListBuffer[ keyIndex ].type;
196 8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	676 }
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	677 }
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	678
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	679 // Reset the macro position
217 8ceb1a0582ee Adding more RAM optimizations Jacob Alexander <haata@kiibohd.com> parents: 216 diff changeset	680 ResultMacroRecordList[ resultMacroIndex ].pos = 0;
189 4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	681 }
4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	682
4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	683
185 68f3dc0cddd0 Macro cleanup. Jacob Alexander <haata@kiibohd.com> parents: 184 diff changeset	684 // Macro Procesing Loop
68f3dc0cddd0 Macro cleanup. Jacob Alexander <haata@kiibohd.com> parents: 184 diff changeset	685 // Called once per USB buffer send
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	686 inline void Macro_process()
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	687 {
360 dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	688 #if defined(ConnectEnabled_define)
dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	689 // Only compile in if a Connect node module is available
dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	690 // If this is a interconnect slave node, send all scancodes to master node
dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	691 if ( !Connect_master )
dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	692 {
dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	693 if ( macroTriggerListBufferSize > 0 )
dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	694 {
361 7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	695 Connect_send_ScanCode( Connect_id, macroTriggerListBuffer, macroTriggerListBufferSize );
360 dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	696 macroTriggerListBufferSize = 0;
dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	697 }
dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	698 return;
dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	699 }
dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	700 #endif
dbefb68411e1 Initial UARTConnect scancode support Jacob Alexander <haata@kiibohd.com> parents: 345 diff changeset	701
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	702 // Only do one round of macro processing between Output Module timer sends
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	703 if ( USBKeys_Sent != 0 )
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	704 return;
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	705
361 7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	706 #if defined(ConnectEnabled_define)
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	707 // Check if there are any ScanCodes in the interconnect cache to process
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	708 if ( Connect_master && macroInterconnectCacheSize > 0 )
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	709 {
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	710 // Iterate over all the cache ScanCodes
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	711 uint8_t currentInterconnectCacheSize = macroInterconnectCacheSize;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	712 macroInterconnectCacheSize = 0;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	713 for ( uint8_t c = 0; c < currentInterconnectCacheSize; c++ )
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	714 {
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	715 // Add to the trigger list
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	716 macroTriggerListBuffer[ macroTriggerListBufferSize++ ] = macroInterconnectCache[ c ];
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	717
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	718 // TODO Handle other TriggerGuide types (e.g. analog)
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	719 switch ( macroInterconnectCache[ c ].type )
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	720 {
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	721 // Normal (Press/Hold/Release)
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	722 case 0x00:
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	723 // Decide what to do based on the current state
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	724 switch ( macroInterconnectCache[ c ].state )
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	725 {
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	726 // Re-add to interconnect cache in hold state
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	727 case 0x01: // Press
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	728 //case 0x02: // Hold // XXX Why does this not work? -HaaTa
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	729 macroInterconnectCache[ c ].state = 0x02;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	730 macroInterconnectCache[ macroInterconnectCacheSize++ ] = macroInterconnectCache[ c ];
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	731 break;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	732 case 0x03: // Remove
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	733 break;
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	734 // Otherwise, do not re-add
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	735 }
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	736 }
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	737 }
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	738 }
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	739 #endif
7c6ac7b88cda Working support for Interconnect Jacob Alexander <haata@kiibohd.com> parents: 360 diff changeset	740
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	741 // If the pause flag is set, only process if the step counter is non-zero
189 4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	742 if ( macroPauseMode )
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	743 {
189 4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	744 if ( macroStepCounter == 0 )
4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	745 return;
4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	746
4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	747 // Proceed, decrementing the step counter
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	748 macroStepCounter--;
192 6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	749 dbug_print("Macro Step");
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	750 }
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	751
433 0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	752 // Process Trigger Macros
0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	753 Trigger_process();
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	754
190 7a71c6e38d56 Macro processing is now feature complete. Jacob Alexander <haata@kiibohd.com> parents: 189 diff changeset	755
433 0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	756 // Process result macros
0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	757 Result_process();
190 7a71c6e38d56 Macro processing is now feature complete. Jacob Alexander <haata@kiibohd.com> parents: 189 diff changeset	758
7a71c6e38d56 Macro processing is now feature complete. Jacob Alexander <haata@kiibohd.com> parents: 189 diff changeset	759 // Signal buffer that we've used it
7a71c6e38d56 Macro processing is now feature complete. Jacob Alexander <haata@kiibohd.com> parents: 189 diff changeset	760 Scan_finishedWithMacro( macroTriggerListBufferSize );
7a71c6e38d56 Macro processing is now feature complete. Jacob Alexander <haata@kiibohd.com> parents: 189 diff changeset	761
7a71c6e38d56 Macro processing is now feature complete. Jacob Alexander <haata@kiibohd.com> parents: 189 diff changeset	762 // Reset TriggerList buffer
7a71c6e38d56 Macro processing is now feature complete. Jacob Alexander <haata@kiibohd.com> parents: 189 diff changeset	763 macroTriggerListBufferSize = 0;
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	764
670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	765 // If Macro debug mode is set, clear the USB Buffer
670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	766 if ( macroDebugMode )
670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	767 {
670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	768 USBKeys_Modifiers = 0;
670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	769 USBKeys_Sent = 0;
670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	770 }
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	771 }
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	772
185 68f3dc0cddd0 Macro cleanup. Jacob Alexander <haata@kiibohd.com> parents: 184 diff changeset	773
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	774 inline void Macro_setup()
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	775 {
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	776 // Register Macro CLI dictionary
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	777 CLI_registerDictionary( macroCLIDict, macroCLIDictName );
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	778
670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	779 // Disable Macro debug mode
670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	780 macroDebugMode = 0;
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	781
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	782 // Disable Macro pause flag
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	783 macroPauseMode = 0;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	784
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	785 // Set Macro step counter to zero
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	786 macroStepCounter = 0;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	787
176 d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	788 // Make sure macro trigger buffer is empty
d3ae6b409cfa Initial work for partial layers and macros. Jacob Alexander <haata@kiibohd.com> parents: 166 diff changeset	789 macroTriggerListBufferSize = 0;
189 4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	790
377 dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	791 // Set the current rotated layer to 0
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	792 Macro_rotationLayer = 0;
dbbdedccc275 Adding layer rotation (next/prev) capability Jacob Alexander <haata@kiibohd.com> parents: 371 diff changeset	793
433 0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	794 // Setup Triggers
0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	795 Trigger_setup();
189 4493d8d2c959 Adding TriggerMacro processing. Jacob Alexander <haata@kiibohd.com> parents: 186 diff changeset	796
433 0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	797 // Setup Results
0f7a6b593dc4 Initial refactoring of PartialMap for supporting custom Triggers Jacob Alexander <haata@kiibohd.com> parents: 410 diff changeset	798 Result_setup();
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	799 }
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	800
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	801
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	802 // ----- CLI Command Functions -----
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	803
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	804 void cliFunc_capList( char* args )
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	805 {
180 ed56f7873645 Added capabilities list debug option Jacob Alexander <haata@kiibohd.com> parents: 179 diff changeset	806 print( NL );
271 e6c753528873 More mk20dx256vlh7 preparation. Jacob Alexander <haata@kiibohd.com> parents: 265 diff changeset	807 info_msg("Capabilities List ");
192 6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	808 printHex( CapabilitiesNum );
180 ed56f7873645 Added capabilities list debug option Jacob Alexander <haata@kiibohd.com> parents: 179 diff changeset	809
ed56f7873645 Added capabilities list debug option Jacob Alexander <haata@kiibohd.com> parents: 179 diff changeset	810 // Iterate through all of the capabilities and display them
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	811 for ( var_uint_t cap = 0; cap < CapabilitiesNum; cap++ )
180 ed56f7873645 Added capabilities list debug option Jacob Alexander <haata@kiibohd.com> parents: 179 diff changeset	812 {
ed56f7873645 Added capabilities list debug option Jacob Alexander <haata@kiibohd.com> parents: 179 diff changeset	813 print( NL "\t" );
ed56f7873645 Added capabilities list debug option Jacob Alexander <haata@kiibohd.com> parents: 179 diff changeset	814 printHex( cap );
ed56f7873645 Added capabilities list debug option Jacob Alexander <haata@kiibohd.com> parents: 179 diff changeset	815 print(" - ");
ed56f7873645 Added capabilities list debug option Jacob Alexander <haata@kiibohd.com> parents: 179 diff changeset	816
ed56f7873645 Added capabilities list debug option Jacob Alexander <haata@kiibohd.com> parents: 179 diff changeset	817 // Display/Lookup Capability Name (utilize debug mode of capability)
182 880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	818 void (capability)(uint8_t, uint8_t, uint8_t) = (void()(uint8_t, uint8_t, uint8_t))(CapabilitiesList[ cap ].func);
180 ed56f7873645 Added capabilities list debug option Jacob Alexander <haata@kiibohd.com> parents: 179 diff changeset	819 capability( 0xFF, 0xFF, 0 );
ed56f7873645 Added capabilities list debug option Jacob Alexander <haata@kiibohd.com> parents: 179 diff changeset	820 }
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	821 }
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	822
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	823 void cliFunc_capSelect( char* args )
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	824 {
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	825 // Parse code from argument
182 880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	826 char* curArgs;
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	827 char* arg1Ptr;
182 880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	828 char* arg2Ptr = args;
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	829
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	830 // Total number of args to scan (must do a lookup if a keyboard capability is selected)
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	831 var_uint_t totalArgs = 2; // Always at least two args
b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	832 var_uint_t cap = 0;
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	833
182 880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	834 // Arguments used for keyboard capability function
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	835 var_uint_t argSetCount = 0;
182 880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	836 uint8_t argSet = (uint8_t)args;
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	837
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	838 // Process all args
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	839 for ( var_uint_t c = 0; argSetCount < totalArgs; c++ )
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	840 {
182 880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	841 curArgs = arg2Ptr;
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	842 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	843
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	844 // Stop processing args if no more are found
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	845 // Extra arguments are ignored
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	846 if ( *arg1Ptr == '\0' )
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	847 break;
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	848
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	849 // For the first argument, choose the capability
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	850 if ( c == 0 ) switch ( arg1Ptr[0] )
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	851 {
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	852 // Keyboard Capability
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	853 case 'K':
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	854 // Determine capability index
195 58cfcb7bac88 Changing decToInt to numToInt (adds support for Hex number interpreter) Jacob Alexander <haata@kiibohd.com> parents: 192 diff changeset	855 cap = numToInt( &arg1Ptr[1] );
182 880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	856
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	857 // Lookup the number of args
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	858 totalArgs += CapabilitiesList[ cap ].argCount;
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	859 continue;
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	860 }
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	861
182 880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	862 // Because allocating memory isn't doable, and the argument count is arbitrary
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	863 // The argument pointer is repurposed as the argument list (much smaller anyways)
195 58cfcb7bac88 Changing decToInt to numToInt (adds support for Hex number interpreter) Jacob Alexander <haata@kiibohd.com> parents: 192 diff changeset	864 argSet[ argSetCount++ ] = (uint8_t)numToInt( arg1Ptr );
182 880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	865
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	866 // Once all the arguments are prepared, call the keyboard capability function
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	867 if ( argSetCount == totalArgs )
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	868 {
182 880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	869 // Indicate that the capability was called
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	870 print( NL );
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	871 info_msg("K");
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	872 printInt8( cap );
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	873 print(" - ");
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	874 printHex( argSet[0] );
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	875 print(" - ");
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	876 printHex( argSet[1] );
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	877 print(" - ");
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	878 printHex( argSet[2] );
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	879 print( "..." NL );
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	880
385 d8f61e15aca1 Adding jump to bootloader key Jacob Alexander <haata@kiibohd.com> parents: 380 diff changeset	881 // Make sure this isn't the reload capability
d8f61e15aca1 Adding jump to bootloader key Jacob Alexander <haata@kiibohd.com> parents: 380 diff changeset	882 // If it is, and the remote reflash define is not set, ignore
d8f61e15aca1 Adding jump to bootloader key Jacob Alexander <haata@kiibohd.com> parents: 380 diff changeset	883 if ( flashModeEnabled_define == 0 ) for ( uint32_t cap = 0; cap < CapabilitiesNum; cap++ )
d8f61e15aca1 Adding jump to bootloader key Jacob Alexander <haata@kiibohd.com> parents: 380 diff changeset	884 {
d8f61e15aca1 Adding jump to bootloader key Jacob Alexander <haata@kiibohd.com> parents: 380 diff changeset	885 if ( CapabilitiesList[ cap ].func == (const void*)Output_flashMode_capability )
d8f61e15aca1 Adding jump to bootloader key Jacob Alexander <haata@kiibohd.com> parents: 380 diff changeset	886 {
d8f61e15aca1 Adding jump to bootloader key Jacob Alexander <haata@kiibohd.com> parents: 380 diff changeset	887 print( NL );
d8f61e15aca1 Adding jump to bootloader key Jacob Alexander <haata@kiibohd.com> parents: 380 diff changeset	888 warn_print("flashModeEnabled not set, cancelling firmware reload...");
d8f61e15aca1 Adding jump to bootloader key Jacob Alexander <haata@kiibohd.com> parents: 380 diff changeset	889 info_msg("Set flashModeEnabled to 1 in your kll configuration.");
d8f61e15aca1 Adding jump to bootloader key Jacob Alexander <haata@kiibohd.com> parents: 380 diff changeset	890 return;
d8f61e15aca1 Adding jump to bootloader key Jacob Alexander <haata@kiibohd.com> parents: 380 diff changeset	891 }
d8f61e15aca1 Adding jump to bootloader key Jacob Alexander <haata@kiibohd.com> parents: 380 diff changeset	892 }
d8f61e15aca1 Adding jump to bootloader key Jacob Alexander <haata@kiibohd.com> parents: 380 diff changeset	893
182 880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	894 void (capability)(uint8_t, uint8_t, uint8_t) = (void()(uint8_t, uint8_t, uint8_t))(CapabilitiesList[ cap ].func);
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	895 capability( argSet[0], argSet[1], &argSet[2] );
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	896 }
670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	897 }
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	898 }
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	899
192 6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	900 void cliFunc_keyHold( char* args )
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	901 {
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	902 // Parse codes from arguments
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	903 char* curArgs;
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	904 char* arg1Ptr;
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	905 char* arg2Ptr = args;
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	906
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	907 // Process all args
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	908 for ( ;; )
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	909 {
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	910 curArgs = arg2Ptr;
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	911 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	912
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	913 // Stop processing args if no more are found
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	914 if ( *arg1Ptr == '\0' )
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	915 break;
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	916
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	917 // Ignore non-Scancode numbers
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	918 switch ( arg1Ptr[0] )
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	919 {
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	920 // Scancode
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	921 case 'S':
195 58cfcb7bac88 Changing decToInt to numToInt (adds support for Hex number interpreter) Jacob Alexander <haata@kiibohd.com> parents: 192 diff changeset	922 Macro_keyState( (uint8_t)numToInt( &arg1Ptr[1] ), 0x02 ); // Hold scancode
192 6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	923 break;
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	924 }
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	925 }
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	926 }
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	927
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	928 void cliFunc_keyPress( char* args )
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	929 {
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	930 // Parse codes from arguments
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	931 char* curArgs;
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	932 char* arg1Ptr;
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	933 char* arg2Ptr = args;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	934
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	935 // Process all args
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	936 for ( ;; )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	937 {
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	938 curArgs = arg2Ptr;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	939 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	940
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	941 // Stop processing args if no more are found
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	942 if ( *arg1Ptr == '\0' )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	943 break;
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	944
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	945 // Ignore non-Scancode numbers
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	946 switch ( arg1Ptr[0] )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	947 {
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	948 // Scancode
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	949 case 'S':
195 58cfcb7bac88 Changing decToInt to numToInt (adds support for Hex number interpreter) Jacob Alexander <haata@kiibohd.com> parents: 192 diff changeset	950 Macro_keyState( (uint8_t)numToInt( &arg1Ptr[1] ), 0x01 ); // Press scancode
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	951 break;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	952 }
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	953 }
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	954 }
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	955
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	956 void cliFunc_keyRelease( char* args )
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	957 {
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	958 // Parse codes from arguments
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	959 char* curArgs;
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	960 char* arg1Ptr;
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	961 char* arg2Ptr = args;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	962
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	963 // Process all args
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	964 for ( ;; )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	965 {
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	966 curArgs = arg2Ptr;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	967 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	968
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	969 // Stop processing args if no more are found
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	970 if ( *arg1Ptr == '\0' )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	971 break;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	972
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	973 // Ignore non-Scancode numbers
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	974 switch ( arg1Ptr[0] )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	975 {
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	976 // Scancode
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	977 case 'S':
195 58cfcb7bac88 Changing decToInt to numToInt (adds support for Hex number interpreter) Jacob Alexander <haata@kiibohd.com> parents: 192 diff changeset	978 Macro_keyState( (uint8_t)numToInt( &arg1Ptr[1] ), 0x03 ); // Release scancode
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	979 break;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	980 }
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	981 }
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	982 }
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	983
344 f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	984 void cliFunc_layerDebug( char *args )
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	985 {
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	986 // Toggle layer debug mode
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	987 layerDebugMode = layerDebugMode ? 0 : 1;
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	988
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	989 print( NL );
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	990 info_msg("Layer Debug Mode: ");
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	991 printInt8( layerDebugMode );
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	992 }
f04450004adf Adding layerDebug cli command Jacob Alexander <haata@kiibohd.com> parents: 307 diff changeset	993
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	994 void cliFunc_layerList( char* args )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	995 {
183 bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	996 print( NL );
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	997 info_msg("Layer List");
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	998
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	999 // Iterate through all of the layers and display them
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	1000 for ( uint16_t layer = 0; layer < LayerNum; layer++ )
183 bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1001 {
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1002 print( NL "\t" );
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1003 printHex( layer );
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1004 print(" - ");
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1005
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1006 // Display layer name
192 6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1007 dPrint( (char*)LayerIndex[ layer ].name );
183 bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1008
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1009 // Default map
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1010 if ( layer == 0 )
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1011 print(" \033[1m(default)\033[0m");
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1012
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1013 // Layer State
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1014 print( NL "\t\t Layer State: " );
214 5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	1015 printHex( LayerState[ layer ] );
183 bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1016
214 5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	1017 // First -> Last Indices
5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	1018 print(" First -> Last Indices: ");
5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	1019 printHex( LayerIndex[ layer ].first );
5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	1020 print(" -> ");
5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	1021 printHex( LayerIndex[ layer ].last );
183 bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1022 }
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1023 }
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	1024
183 bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1025 void cliFunc_layerState( char* args )
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1026 {
183 bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1027 // Parse codes from arguments
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1028 char* curArgs;
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1029 char* arg1Ptr;
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1030 char* arg2Ptr = args;
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1031
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1032 uint8_t arg1 = 0;
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1033 uint8_t arg2 = 0;
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1034
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1035 // Process first two args
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1036 for ( uint8_t c = 0; c < 2; c++ )
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1037 {
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1038 curArgs = arg2Ptr;
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1039 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1040
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1041 // Stop processing args if no more are found
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1042 if ( *arg1Ptr == '\0' )
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1043 break;
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1044
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1045 switch ( c )
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1046 {
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1047 // First argument (e.g. L1)
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1048 case 0:
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1049 if ( arg1Ptr[0] != 'L' )
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1050 return;
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1051
195 58cfcb7bac88 Changing decToInt to numToInt (adds support for Hex number interpreter) Jacob Alexander <haata@kiibohd.com> parents: 192 diff changeset	1052 arg1 = (uint8_t)numToInt( &arg1Ptr[1] );
183 bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1053 break;
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1054 // Second argument (e.g. 4)
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1055 case 1:
195 58cfcb7bac88 Changing decToInt to numToInt (adds support for Hex number interpreter) Jacob Alexander <haata@kiibohd.com> parents: 192 diff changeset	1056 arg2 = (uint8_t)numToInt( arg1Ptr );
183 bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1057
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1058 // Display operation (to indicate that it worked)
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1059 print( NL );
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1060 info_msg("Setting Layer L");
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1061 printInt8( arg1 );
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1062 print(" to - ");
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1063 printHex( arg2 );
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1064
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1065 // Set the layer state
214 5a5404338b9f Adding support for layer packing Jacob Alexander <haata@kiibohd.com> parents: 205 diff changeset	1066 LayerState[ arg1 ] = arg2;
183 bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1067 break;
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1068 }
bb96551a3065 Added layerList and layerState functions Jacob Alexander <haata@kiibohd.com> parents: 182 diff changeset	1069 }
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	1070 }
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	1071
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	1072 void cliFunc_macroDebug( char* args )
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	1073 {
126 670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	1074 // Toggle macro debug mode
670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	1075 macroDebugMode = macroDebugMode ? 0 : 1;
670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	1076
670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	1077 print( NL );
670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	1078 info_msg("Macro Debug Mode: ");
670fc9c3a739 Added CLI DefaultMap lookup command. Jacob Alexander <haata@kiibohd.com> parents: 125 diff changeset	1079 printInt8( macroDebugMode );
125 8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	1080 }
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module Jacob Alexander <haata@kiibohd.com> parents: diff changeset	1081
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1082 void cliFunc_macroList( char* args )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1083 {
192 6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1084 // Show pending key events
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1085 print( NL );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1086 info_msg("Pending Key Events: ");
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1087 printInt16( (uint16_t)macroTriggerListBufferSize );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1088 print(" : ");
410 8fa2619aa60e Fix a handful of infinite loops that occur if you have more than 254 macros Kevin Frei <freik@fb.com> parents: 385 diff changeset	1089 for ( var_uint_t key = 0; key < macroTriggerListBufferSize; key++ )
192 6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1090 {
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1091 printHex( macroTriggerListBuffer[ key ].scanCode );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1092 print(" ");
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1093 }
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1094
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1095 // Show pending trigger macros
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1096 print( NL );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1097 info_msg("Pending Trigger Macros: ");
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1098 printInt16( (uint16_t)macroTriggerMacroPendingListSize );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1099 print(" : ");
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	1100 for ( var_uint_t macro = 0; macro < macroTriggerMacroPendingListSize; macro++ )
192 6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1101 {
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1102 printHex( macroTriggerMacroPendingList[ macro ] );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1103 print(" ");
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1104 }
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1105
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1106 // Show pending result macros
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1107 print( NL );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1108 info_msg("Pending Result Macros: ");
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1109 printInt16( (uint16_t)macroResultMacroPendingListSize );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1110 print(" : ");
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	1111 for ( var_uint_t macro = 0; macro < macroResultMacroPendingListSize; macro++ )
192 6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1112 {
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1113 printHex( macroResultMacroPendingList[ macro ] );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1114 print(" ");
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1115 }
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1116
181 80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1117 // Show available trigger macro indices
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1118 print( NL );
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1119 info_msg("Trigger Macros Range: T0 -> T");
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1120 printInt16( (uint16_t)TriggerMacroNum - 1 ); // Hopefully large enough :P (can't assume 32-bit)
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1121
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1122 // Show available result macro indices
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1123 print( NL );
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1124 info_msg("Result Macros Range: R0 -> R");
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1125 printInt16( (uint16_t)ResultMacroNum - 1 ); // Hopefully large enough :P (can't assume 32-bit)
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1126
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1127 // Show Trigger to Result Macro Links
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1128 print( NL );
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1129 info_msg("Trigger : Result Macro Pairs");
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	1130 for ( var_uint_t macro = 0; macro < TriggerMacroNum; macro++ )
181 80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1131 {
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1132 print( NL );
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1133 print("\tT");
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1134 printInt16( (uint16_t)macro ); // Hopefully large enough :P (can't assume 32-bit)
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1135 print(" : R");
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1136 printInt16( (uint16_t)TriggerMacroList[ macro ].result ); // Hopefully large enough :P (can't assume 32-bit)
80a44dcdafaf Adding macroList debug function Jacob Alexander <haata@kiibohd.com> parents: 180 diff changeset	1137 }
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1138 }
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1139
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1140 void cliFunc_macroProc( char* args )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1141 {
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1142 // Toggle macro pause mode
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1143 macroPauseMode = macroPauseMode ? 0 : 1;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1144
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1145 print( NL );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1146 info_msg("Macro Processing Mode: ");
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1147 printInt8( macroPauseMode );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1148 }
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1149
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	1150 void macroDebugShowTrigger( var_uint_t index )
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1151 {
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1152 // Only proceed if the macro exists
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1153 if ( index >= TriggerMacroNum )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1154 return;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1155
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1156 // Trigger Macro Show
217 8ceb1a0582ee Adding more RAM optimizations Jacob Alexander <haata@kiibohd.com> parents: 216 diff changeset	1157 const TriggerMacro *macro = &TriggerMacroList[ index ];
8ceb1a0582ee Adding more RAM optimizations Jacob Alexander <haata@kiibohd.com> parents: 216 diff changeset	1158 TriggerMacroRecord *record = &TriggerMacroRecordList[ index ];
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1159
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1160 print( NL );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1161 info_msg("Trigger Macro Index: ");
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1162 printInt16( (uint16_t)index ); // Hopefully large enough :P (can't assume 32-bit)
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1163 print( NL );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1164
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1165 // Read the comboLength for combo in the sequence (sequence of combos)
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	1166 var_uint_t pos = 0;
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1167 uint8_t comboLength = macro->guide[ pos ];
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1168
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1169 // Iterate through and interpret the guide
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1170 while ( comboLength != 0 )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1171 {
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1172 // Initial position of the combo
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	1173 var_uint_t comboPos = ++pos;
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1174
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1175 // Iterate through the combo
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1176 while ( pos < comboLength * TriggerGuideSize + comboPos )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1177 {
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1178 // Assign TriggerGuide element (key type, state and scancode)
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1179 TriggerGuide guide = (TriggerGuide)(&macro->guide[ pos ]);
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1180
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1181 // Display guide information about trigger key
184 f9ef267ccc8b Adding layer fall-through lookup Jacob Alexander <haata@kiibohd.com> parents: 183 diff changeset	1182 printHex( guide->scanCode );
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1183 print("\|");
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1184 printHex( guide->type );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1185 print("\|");
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1186 printHex( guide->state );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1187
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1188 // Increment position
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1189 pos += TriggerGuideSize;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1190
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1191 // Only show combo separator if there are combos left in the sequence element
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1192 if ( pos < comboLength * TriggerGuideSize + comboPos )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1193 print("+");
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1194 }
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1195
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1196 // Read the next comboLength
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1197 comboLength = macro->guide[ pos ];
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1198
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1199 // Only show sequence separator if there is another combo to process
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1200 if ( comboLength != 0 )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1201 print(";");
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1202 }
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1203
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1204 // Display current position
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1205 print( NL "Position: " );
217 8ceb1a0582ee Adding more RAM optimizations Jacob Alexander <haata@kiibohd.com> parents: 216 diff changeset	1206 printInt16( (uint16_t)record->pos ); // Hopefully large enough :P (can't assume 32-bit)
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1207
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1208 // Display result macro index
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1209 print( NL "Result Macro Index: " );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1210 printInt16( (uint16_t)macro->result ); // Hopefully large enough :P (can't assume 32-bit)
196 8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	1211
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	1212 // Display trigger macro state
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	1213 print( NL "Trigger Macro State: " );
217 8ceb1a0582ee Adding more RAM optimizations Jacob Alexander <haata@kiibohd.com> parents: 216 diff changeset	1214 switch ( record->state )
196 8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	1215 {
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	1216 case TriggerMacro_Press: print("Press"); break;
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	1217 case TriggerMacro_Release: print("Release"); break;
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	1218 case TriggerMacro_Waiting: print("Waiting"); break;
8ecfdaa27234 Basic Trigger and Result Macros are now working. Jacob Alexander <haata@kiibohd.com> parents: 195 diff changeset	1219 }
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1220 }
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1221
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	1222 void macroDebugShowResult( var_uint_t index )
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1223 {
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1224 // Only proceed if the macro exists
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1225 if ( index >= ResultMacroNum )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1226 return;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1227
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1228 // Trigger Macro Show
217 8ceb1a0582ee Adding more RAM optimizations Jacob Alexander <haata@kiibohd.com> parents: 216 diff changeset	1229 const ResultMacro *macro = &ResultMacroList[ index ];
8ceb1a0582ee Adding more RAM optimizations Jacob Alexander <haata@kiibohd.com> parents: 216 diff changeset	1230 ResultMacroRecord *record = &ResultMacroRecordList[ index ];
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1231
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1232 print( NL );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1233 info_msg("Result Macro Index: ");
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1234 printInt16( (uint16_t)index ); // Hopefully large enough :P (can't assume 32-bit)
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1235 print( NL );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1236
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1237 // Read the comboLength for combo in the sequence (sequence of combos)
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	1238 var_uint_t pos = 0;
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1239 uint8_t comboLength = macro->guide[ pos++ ];
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1240
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1241 // Iterate through and interpret the guide
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1242 while ( comboLength != 0 )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1243 {
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1244 // Function Counter, used to keep track of the combos processed
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	1245 var_uint_t funcCount = 0;
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1246
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1247 // Iterate through the combo
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1248 while ( funcCount < comboLength )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1249 {
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1250 // Assign TriggerGuide element (key type, state and scancode)
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1251 ResultGuide guide = (ResultGuide)(&macro->guide[ pos ]);
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1252
180 ed56f7873645 Added capabilities list debug option Jacob Alexander <haata@kiibohd.com> parents: 179 diff changeset	1253 // Display Function Index
ed56f7873645 Added capabilities list debug option Jacob Alexander <haata@kiibohd.com> parents: 179 diff changeset	1254 printHex( guide->index );
ed56f7873645 Added capabilities list debug option Jacob Alexander <haata@kiibohd.com> parents: 179 diff changeset	1255 print("\|");
ed56f7873645 Added capabilities list debug option Jacob Alexander <haata@kiibohd.com> parents: 179 diff changeset	1256
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1257 // Display Function Ptr Address
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	1258 printHex( (nat_ptr_t)CapabilitiesList[ guide->index ].func );
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1259 print("\|");
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1260
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1261 // Display/Lookup Capability Name (utilize debug mode of capability)
182 880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	1262 void (capability)(uint8_t, uint8_t, uint8_t) = (void()(uint8_t, uint8_t, uint8_t))(CapabilitiesList[ guide->index ].func);
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1263 capability( 0xFF, 0xFF, 0 );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1264
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1265 // Display Argument(s)
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1266 print("(");
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	1267 for ( var_uint_t arg = 0; arg < CapabilitiesList[ guide->index ].argCount; arg++ )
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1268 {
180 ed56f7873645 Added capabilities list debug option Jacob Alexander <haata@kiibohd.com> parents: 179 diff changeset	1269 // Arguments are only 8 bit values
ed56f7873645 Added capabilities list debug option Jacob Alexander <haata@kiibohd.com> parents: 179 diff changeset	1270 printHex( (&guide->args)[ arg ] );
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1271
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1272 // Only show arg separator if there are args left
182 880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability Jacob Alexander <haata@kiibohd.com> parents: 181 diff changeset	1273 if ( arg + 1 < CapabilitiesList[ guide->index ].argCount )
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1274 print(",");
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1275 }
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1276 print(")");
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1277
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1278 // Increment position
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1279 pos += ResultGuideSize( guide );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1280
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1281 // Increment function count
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1282 funcCount++;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1283
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1284 // Only show combo separator if there are combos left in the sequence element
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1285 if ( funcCount < comboLength )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1286 print("+");
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1287 }
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1288
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1289 // Read the next comboLength
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1290 comboLength = macro->guide[ pos++ ];
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1291
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1292 // Only show sequence separator if there is another combo to process
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1293 if ( comboLength != 0 )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1294 print(";");
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1295 }
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1296
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1297 // Display current position
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1298 print( NL "Position: " );
217 8ceb1a0582ee Adding more RAM optimizations Jacob Alexander <haata@kiibohd.com> parents: 216 diff changeset	1299 printInt16( (uint16_t)record->pos ); // Hopefully large enough :P (can't assume 32-bit)
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1300
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1301 // Display final trigger state/type
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1302 print( NL "Final Trigger State (State/Type): " );
217 8ceb1a0582ee Adding more RAM optimizations Jacob Alexander <haata@kiibohd.com> parents: 216 diff changeset	1303 printHex( record->state );
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1304 print("/");
217 8ceb1a0582ee Adding more RAM optimizations Jacob Alexander <haata@kiibohd.com> parents: 216 diff changeset	1305 printHex( record->stateType );
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1306 }
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1307
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1308 void cliFunc_macroShow( char* args )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1309 {
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1310 // Parse codes from arguments
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1311 char* curArgs;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1312 char* arg1Ptr;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1313 char* arg2Ptr = args;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1314
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1315 // Process all args
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1316 for ( ;; )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1317 {
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1318 curArgs = arg2Ptr;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1319 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1320
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1321 // Stop processing args if no more are found
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1322 if ( *arg1Ptr == '\0' )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1323 break;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1324
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1325 // Ignore invalid codes
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1326 switch ( arg1Ptr[0] )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1327 {
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1328 // Indexed Trigger Macro
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1329 case 'T':
195 58cfcb7bac88 Changing decToInt to numToInt (adds support for Hex number interpreter) Jacob Alexander <haata@kiibohd.com> parents: 192 diff changeset	1330 macroDebugShowTrigger( numToInt( &arg1Ptr[1] ) );
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1331 break;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1332 // Indexed Result Macro
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1333 case 'R':
195 58cfcb7bac88 Changing decToInt to numToInt (adds support for Hex number interpreter) Jacob Alexander <haata@kiibohd.com> parents: 192 diff changeset	1334 macroDebugShowResult( numToInt( &arg1Ptr[1] ) );
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1335 break;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1336 }
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1337 }
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1338 }
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1339
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1340 void cliFunc_macroStep( char* args )
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1341 {
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1342 // Parse number from argument
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1343 // NOTE: Only first argument is used
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1344 char* arg1Ptr;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1345 char* arg2Ptr;
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1346 CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr );
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1347
192 6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1348 // Default to 1, if no argument given
204 b718fdb741c3 Updating PartialLayer code to support varying counter widths. Jacob Alexander <haata@kiibohd.com> parents: 202 diff changeset	1349 var_uint_t count = (var_uint_t)numToInt( arg1Ptr );
192 6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1350
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1351 if ( count == 0 )
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1352 count = 1;
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1353
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1354 // Set the macro step counter, negative int's are cast to uint
192 6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage Jacob Alexander <haata@kiibohd.com> parents: 191 diff changeset	1355 macroStepCounter = count;
179 e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1356 }
e5cf79b516e4 Basic debug trigger/result macro viewer Jacob Alexander <haata@kiibohd.com> parents: 176 diff changeset	1357

Mercurial > louis > kiibohd-controller

annotate Macro/PartialMap/macro.c @ 453:98bbee08f005 default tip louis