Mercurial > louis > kiibohd-controller

annotate Macro/PartialMap/macro.c @ 345:2bcf6800b851

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fixing order of layer debug stack display - Adding NL's for fault messages
author Jacob Alexander <haata@kiibohd.com>
date Tue, 23 Jun 2015 07:58:31 -0700
parents f04450004adf
children dbefb68411e1
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
297
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
1 /* Copyright (C) 2014-2015 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
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
32 // Local Includes
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
33 #include "macro.h"
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
34
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
35
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
36
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
37 // ----- Function Declarations -----
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
38
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
39 void cliFunc_capList ( char* args );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
40 void cliFunc_capSelect ( char* args );
192
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
41 void cliFunc_keyHold ( char* args );
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
42 void cliFunc_keyPress ( char* args );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
43 void cliFunc_keyRelease( char* args );
344
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
44 void cliFunc_layerDebug( char* args );
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
45 void cliFunc_layerList ( char* args );
183
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
46 void cliFunc_layerState( char* args );
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
47 void cliFunc_macroDebug( char* args );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
48 void cliFunc_macroList ( char* args );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
49 void cliFunc_macroProc ( char* args );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
50 void cliFunc_macroShow ( char* args );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
51 void cliFunc_macroStep ( char* args );
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
52
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
53
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
54
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
55 // ----- Enums -----
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
56
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
57 // Bit positions are important, passes (correct key) always trump incorrect key votes
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
58 typedef enum TriggerMacroVote {
197
1ebb6fb5f74f All basic macros tested and working!
Jacob Alexander <haata@kiibohd.com>
parents: 196
diff changeset
59 TriggerMacroVote_Release = 0x10, // Correct key
1ebb6fb5f74f All basic macros tested and working!
Jacob Alexander <haata@kiibohd.com>
parents: 196
diff changeset
60 TriggerMacroVote_PassRelease = 0x18, // Correct key (both pass and release)
1ebb6fb5f74f All basic macros tested and working!
Jacob Alexander <haata@kiibohd.com>
parents: 196
diff changeset
61 TriggerMacroVote_Pass = 0x8, // Correct key
1ebb6fb5f74f All basic macros tested and working!
Jacob Alexander <haata@kiibohd.com>
parents: 196
diff changeset
62 TriggerMacroVote_DoNothingRelease = 0x4, // Incorrect key
1ebb6fb5f74f All basic macros tested and working!
Jacob Alexander <haata@kiibohd.com>
parents: 196
diff changeset
63 TriggerMacroVote_DoNothing = 0x2, // Incorrect key
1ebb6fb5f74f All basic macros tested and working!
Jacob Alexander <haata@kiibohd.com>
parents: 196
diff changeset
64 TriggerMacroVote_Fail = 0x1, // Incorrect key
1ebb6fb5f74f All basic macros tested and working!
Jacob Alexander <haata@kiibohd.com>
parents: 196
diff changeset
65 TriggerMacroVote_Invalid = 0x0, // Invalid state
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
66 } TriggerMacroVote;
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
67
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
68 typedef enum TriggerMacroEval {
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
69 TriggerMacroEval_DoNothing,
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
70 TriggerMacroEval_DoResult,
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
71 TriggerMacroEval_DoResultAndRemove,
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
72 TriggerMacroEval_Remove,
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
73 } TriggerMacroEval;
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
74
190
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
75 typedef enum ResultMacroEval {
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
76 ResultMacroEval_DoNothing,
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
77 ResultMacroEval_Remove,
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
78 } ResultMacroEval;
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
79
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
80
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
81
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
82 // ----- Variables -----
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
83
132
e08d7b586ea3 Adding analog.c lib from teensyduino.
Jacob Alexander <haata@kiibohd.com>
parents: 126
diff changeset
84 // Macro Module command dictionary
239
2a4c99da1276 HUGE AVR RAM optimization (~28%).
Jacob Alexander <haata@kiibohd.com>
parents: 217
diff changeset
85 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
86 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
87 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
88 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
89 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
90 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
91 CLIDict_Entry( layerList, "List available layers." );
2a4c99da1276 HUGE AVR RAM optimization (~28%).
Jacob Alexander <haata@kiibohd.com>
parents: 217
diff changeset
92 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
93 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
94 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
95 CLIDict_Entry( macroProc, "Pause/Resume macro processing." );
2a4c99da1276 HUGE AVR RAM optimization (~28%).
Jacob Alexander <haata@kiibohd.com>
parents: 217
diff changeset
96 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
97 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
98
2a4c99da1276 HUGE AVR RAM optimization (~28%).
Jacob Alexander <haata@kiibohd.com>
parents: 217
diff changeset
99 CLIDict_Def( macroCLIDict, "Macro Module Commands" ) = {
2a4c99da1276 HUGE AVR RAM optimization (~28%).
Jacob Alexander <haata@kiibohd.com>
parents: 217
diff changeset
100 CLIDict_Item( capList ),
2a4c99da1276 HUGE AVR RAM optimization (~28%).
Jacob Alexander <haata@kiibohd.com>
parents: 217
diff changeset
101 CLIDict_Item( capSelect ),
2a4c99da1276 HUGE AVR RAM optimization (~28%).
Jacob Alexander <haata@kiibohd.com>
parents: 217
diff changeset
102 CLIDict_Item( keyHold ),
2a4c99da1276 HUGE AVR RAM optimization (~28%).
Jacob Alexander <haata@kiibohd.com>
parents: 217
diff changeset
103 CLIDict_Item( keyPress ),
2a4c99da1276 HUGE AVR RAM optimization (~28%).
Jacob Alexander <haata@kiibohd.com>
parents: 217
diff changeset
104 CLIDict_Item( keyRelease ),
344
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
105 CLIDict_Item( layerDebug ),
239
2a4c99da1276 HUGE AVR RAM optimization (~28%).
Jacob Alexander <haata@kiibohd.com>
parents: 217
diff changeset
106 CLIDict_Item( layerList ),
2a4c99da1276 HUGE AVR RAM optimization (~28%).
Jacob Alexander <haata@kiibohd.com>
parents: 217
diff changeset
107 CLIDict_Item( layerState ),
2a4c99da1276 HUGE AVR RAM optimization (~28%).
Jacob Alexander <haata@kiibohd.com>
parents: 217
diff changeset
108 CLIDict_Item( macroDebug ),
2a4c99da1276 HUGE AVR RAM optimization (~28%).
Jacob Alexander <haata@kiibohd.com>
parents: 217
diff changeset
109 CLIDict_Item( macroList ),
2a4c99da1276 HUGE AVR RAM optimization (~28%).
Jacob Alexander <haata@kiibohd.com>
parents: 217
diff changeset
110 CLIDict_Item( macroProc ),
2a4c99da1276 HUGE AVR RAM optimization (~28%).
Jacob Alexander <haata@kiibohd.com>
parents: 217
diff changeset
111 CLIDict_Item( macroShow ),
2a4c99da1276 HUGE AVR RAM optimization (~28%).
Jacob Alexander <haata@kiibohd.com>
parents: 217
diff changeset
112 CLIDict_Item( macroStep ),
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
113 { 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
114 };
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
115
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
116
344
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
117 // 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
118 uint8_t layerDebugMode = 0;
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
119
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
120 // 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
121 uint8_t macroDebugMode = 0;
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
122
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
123 // 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
124 uint8_t macroPauseMode = 0;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
125
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
126 // 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
127 uint16_t macroStepCounter = 0;
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
128
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
129
297
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
130 // 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
131 // 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
132 TriggerGuide macroTriggerListBuffer[ MaxScanCode ];
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
133 uint8_t macroTriggerListBufferSize = 0;
297
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
134 var_uint_t macroTriggerListLayerCache[ MaxScanCode ];
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
135
184
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
136 // Pending Trigger Macro Index List
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
137 // * Any trigger macros that need processing from a previous macro processing loop
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
138 // TODO, figure out a good way to scale this array size without wasting too much memory, but not rejecting macros
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
139 // Possibly could be calculated by the KLL compiler
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
140 // XXX It may be possible to calculate the worst case using the KLL compiler
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
141 uint16_t macroTriggerMacroPendingList[ TriggerMacroNum ] = { 0 };
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
142 uint16_t macroTriggerMacroPendingListSize = 0;
184
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
143
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
144 // Layer Index Stack
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
145 // * When modifying layer state and the state is non-0x0, the stack must be adjusted
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
146 uint16_t macroLayerIndexStack[ LayerNum + 1 ] = { 0 };
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
147 uint16_t macroLayerIndexStackSize = 0;
184
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
148
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
149 // Pending Result Macro Index List
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
150 // * Any result macro that needs processing from a previous macro processing loop
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
151 uint16_t macroResultMacroPendingList[ ResultMacroNum ] = { 0 };
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
152 uint16_t macroResultMacroPendingListSize = 0;
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
153
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
154
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
155
191
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
156 // ----- Capabilities -----
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
157
199
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
158 // Sets the given layer with the specified layerState
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
159 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
160 {
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
161 // Ignore if layer does not exist
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
162 if ( layer >= LayerNum )
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
163 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
164
191
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
165 // Is layer in the LayerIndexStack?
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
166 uint8_t inLayerIndexStack = 0;
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
167 uint16_t stackItem = 0;
191
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
168 while ( stackItem < macroLayerIndexStackSize )
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
169 {
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
170 // 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
171 if ( macroLayerIndexStack[ stackItem ] == layer )
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 inLayerIndexStack = 1;
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
174 break;
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
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
177 // Increment to next item
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
178 stackItem++;
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
179 }
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
180
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
181 // Toggle Layer State Byte
214
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
182 if ( LayerState[ layer ] & layerState )
191
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
183 {
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
184 // Unset
214
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
185 LayerState[ layer ] &= ~layerState;
191
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
186 }
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
187 else
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 // Set
214
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
190 LayerState[ layer ] |= layerState;
191
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
191 }
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
192
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
193 // 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
194 if ( !inLayerIndexStack )
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
195 {
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
196 macroLayerIndexStack[ macroLayerIndexStackSize++ ] = layer;
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
197 }
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
198
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
199 // 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
200 if ( LayerState[ layer ] == 0x00 && inLayerIndexStack )
191
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
201 {
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
202 // Remove the layer from the LayerIndexStack
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
203 // 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
204 while ( stackItem < macroLayerIndexStackSize )
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
205 {
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
206 macroLayerIndexStack[ stackItem ] = macroLayerIndexStack[ stackItem + 1 ];
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
207 stackItem++;
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
208 }
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
209
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
210 // Reduce LayerIndexStack size
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
211 macroLayerIndexStackSize--;
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
212 }
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 // Layer Debug Mode
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
215 if ( layerDebugMode )
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
216 {
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
217 dbug_msg("Layer ");
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
218
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
219 // Iterate over each of the layers displaying the state as a hex value
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
220 for ( uint16_t index = 0; index < LayerNum; index++ )
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
221 {
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
222 printHex_op( LayerState[ index ], 0 );
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
223 }
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
224
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
225 // Always show the default layer (it's always 0)
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
226 print(" 0");
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
227
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
228 // Iterate over the layer stack starting from the bottom of the stack
345
2bcf6800b851 Fixing order of layer debug stack display
Jacob Alexander <haata@kiibohd.com>
parents: 344
diff changeset
229 for ( uint16_t index = macroLayerIndexStackSize; index > 0; index-- )
344
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
230 {
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
231 print(":");
345
2bcf6800b851 Fixing order of layer debug stack display
Jacob Alexander <haata@kiibohd.com>
parents: 344
diff changeset
232 printHex_op( macroLayerIndexStack[ index - 1 ], 0 );
344
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
233 }
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
234
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
235 print( NL );
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
236 }
191
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
237 }
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
238
199
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
239 // Modifies the specified Layer control byte
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
240 // Argument #1: Layer Index -> uint16_t
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
241 // Argument #2: Layer State -> uint8_t
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
242 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
243 {
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
244 // Display capability name
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
245 if ( stateType == 0xFF && state == 0xFF )
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 print("Macro_layerState(layerIndex,layerState)");
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
248 return;
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
249 }
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
250
201
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
251 // Only use capability on press or release
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
252 // TODO Analog
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
253 // 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
254 if ( stateType == 0x00 && state == 0x02 ) // Hold condition
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
255 return;
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
256
199
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
257 // Get layer index from arguments
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
258 // 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
259 uint16_t layer = *(uint16_t*)(&args[0]);
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
260
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
261 // Get layer toggle byte
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
262 uint8_t layerState = args[ sizeof(uint16_t) ];
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
263
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
264 Macro_layerState( state, stateType, layer, layerState );
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
265 }
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
266
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 // Latches given layer
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
269 // Argument #1: Layer Index -> uint16_t
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
270 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
271 {
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
272 // Display capability name
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
273 if ( stateType == 0xFF && state == 0xFF )
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
274 {
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
275 print("Macro_layerLatch(layerIndex)");
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
276 return;
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
277 }
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
278
201
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
279 // Only use capability on press
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
280 // TODO Analog
253
e79f2b9c39cf Fixing layer latch capability.
Jacob Alexander <haata@kiibohd.com>
parents: 241
diff changeset
281 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
282 return;
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
283
199
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
284 // Get layer index from arguments
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
285 // 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
286 uint16_t layer = *(uint16_t*)(&args[0]);
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
287
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
288 Macro_layerState( state, stateType, layer, 0x02 );
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
289 }
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
290
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
291
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
292 // Locks given layer
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
293 // Argument #1: Layer Index -> uint16_t
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
294 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
295 {
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
296 // Display capability name
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
297 if ( stateType == 0xFF && state == 0xFF )
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
298 {
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
299 print("Macro_layerLock(layerIndex)");
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
300 return;
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
301 }
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
302
201
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
303 // Only use capability on press
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
304 // TODO Analog
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
305 // 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
306 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
307 return;
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
308
199
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
309 // Get layer index from arguments
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
310 // 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
311 uint16_t layer = *(uint16_t*)(&args[0]);
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
312
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
313 Macro_layerState( state, stateType, layer, 0x04 );
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
314 }
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
315
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 // Shifts given layer
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
318 // Argument #1: Layer Index -> uint16_t
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
319 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
320 {
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
321 // Display capability name
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
322 if ( stateType == 0xFF && state == 0xFF )
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
323 {
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
324 print("Macro_layerShift(layerIndex)");
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
325 return;
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
326 }
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
327
201
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
328 // Only use capability on press or release
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
329 // TODO Analog
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
330 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
331 return;
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
332
199
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
333 // Get layer index from arguments
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
334 // 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
335 uint16_t layer = *(uint16_t*)(&args[0]);
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
336
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
337 Macro_layerState( state, stateType, layer, 0x01 );
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
338 }
559a467f6d57 Preparing for kll compiler usage
Jacob Alexander <haata@kiibohd.com>
parents: 197
diff changeset
339
191
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
340
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
341
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
342 // ----- Functions -----
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
343
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
344 // 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
345 // 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
346 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
347 {
297
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
348 uint8_t scanCode = guide->scanCode;
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
349
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
350 // TODO Analog
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
351 // 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
352 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
353 {
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
354 // Cached layer
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
355 var_uint_t cachedLayer = macroTriggerListLayerCache[ scanCode ];
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
356
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
357 // Lookup map, then layer
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
358 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
359 const Layer *layer = &LayerIndex[ cachedLayer ];
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
360
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
361 return map[ scanCode - layer->first ];
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
362 }
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
363
184
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
364 // If no trigger macro is defined at the given layer, fallthrough to the next layer
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
365 for ( uint16_t layerIndex = 0; layerIndex < macroLayerIndexStackSize; layerIndex++ )
184
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
366 {
191
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
367 // Lookup Layer
214
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
368 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
369
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
370 // 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
371 // 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
372 uint8_t latch = LayerState[ macroLayerIndexStack[ layerIndex ] ] & 0x02;
e79f2b9c39cf Fixing layer latch capability.
Jacob Alexander <haata@kiibohd.com>
parents: 241
diff changeset
373 if ( latch && latch_expire )
191
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
374 {
253
e79f2b9c39cf Fixing layer latch capability.
Jacob Alexander <haata@kiibohd.com>
parents: 241
diff changeset
375 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
376 }
184
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
377
191
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
378 // 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
379 // XOR each of the state bits
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
380 // 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
381 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
382 {
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
383 // Lookup layer
202
1a68a9a04ad3 Adding variable width state variable width.
Jacob Alexander <haata@kiibohd.com>
parents: 201
diff changeset
384 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
385
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
386 // Determine if layer has key defined
214
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
387 // 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
388 if ( map != 0
215
00a8c7f491d4 Fixing first and last element bug for layers.
Jacob Alexander <haata@kiibohd.com>
parents: 214
diff changeset
389 && scanCode <= layer->last
00a8c7f491d4 Fixing first and last element bug for layers.
Jacob Alexander <haata@kiibohd.com>
parents: 214
diff changeset
390 && scanCode >= layer->first
214
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
391 && *map[ scanCode - layer->first ] != 0 )
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
392 {
297
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
393 // Set the layer cache
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
394 macroTriggerListLayerCache[ scanCode ] = macroLayerIndexStack[ layerIndex ];
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
395
214
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
396 return map[ scanCode - layer->first ];
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
397 }
191
3404be65670b Adding generic layerToggle and USB Key Output capabilities.
Jacob Alexander <haata@kiibohd.com>
parents: 190
diff changeset
398 }
184
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
399 }
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
400
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
401 // Do lookup on default layer
202
1a68a9a04ad3 Adding variable width state variable width.
Jacob Alexander <haata@kiibohd.com>
parents: 201
diff changeset
402 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
403
214
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
404 // Lookup default layer
216
738445f38639 DPH controller now working with the kishsaver and macros
Jacob Alexander <haata@kiibohd.com>
parents: 215
diff changeset
405 const Layer *layer = &LayerIndex[0];
214
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
406
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
407 // 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
408 if ( map != 0
215
00a8c7f491d4 Fixing first and last element bug for layers.
Jacob Alexander <haata@kiibohd.com>
parents: 214
diff changeset
409 && scanCode <= layer->last
00a8c7f491d4 Fixing first and last element bug for layers.
Jacob Alexander <haata@kiibohd.com>
parents: 214
diff changeset
410 && scanCode >= layer->first
214
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
411 && *map[ scanCode - layer->first ] != 0 )
184
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
412 {
297
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
413 // 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
414 macroTriggerListLayerCache[ scanCode ] = 0;
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
415
214
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
416 return map[ scanCode - layer->first ];
184
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
417 }
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
418
214
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
419 // Otherwise no defined Trigger Macro
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
420 erro_msg("Scan Code has no defined Trigger Macro: ");
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
421 printHex( scanCode );
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
422 return 0;
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
423 }
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
424
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
425
307
ecd2ae35d25c Initial commit for UARTConnect module
Jacob Alexander <haata@kiibohd.com>
parents: 297
diff changeset
426 // Update the scancode using a list of TriggerGuides
ecd2ae35d25c Initial commit for UARTConnect module
Jacob Alexander <haata@kiibohd.com>
parents: 297
diff changeset
427 // TODO Handle led state and analog
ecd2ae35d25c Initial commit for UARTConnect module
Jacob Alexander <haata@kiibohd.com>
parents: 297
diff changeset
428 inline void Macro_triggerState( void *triggers, uint8_t num )
ecd2ae35d25c Initial commit for UARTConnect module
Jacob Alexander <haata@kiibohd.com>
parents: 297
diff changeset
429 {
ecd2ae35d25c Initial commit for UARTConnect module
Jacob Alexander <haata@kiibohd.com>
parents: 297
diff changeset
430 // Copy each of the TriggerGuides to the TriggerListBuffer
ecd2ae35d25c Initial commit for UARTConnect module
Jacob Alexander <haata@kiibohd.com>
parents: 297
diff changeset
431 for ( uint8_t c = 0; c < num; c++ )
ecd2ae35d25c Initial commit for UARTConnect module
Jacob Alexander <haata@kiibohd.com>
parents: 297
diff changeset
432 macroTriggerListBuffer[ macroTriggerListBufferSize++ ] = ((TriggerGuide*)triggers)[ c ];
ecd2ae35d25c Initial commit for UARTConnect module
Jacob Alexander <haata@kiibohd.com>
parents: 297
diff changeset
433 }
ecd2ae35d25c Initial commit for UARTConnect module
Jacob Alexander <haata@kiibohd.com>
parents: 297
diff changeset
434
ecd2ae35d25c Initial commit for UARTConnect module
Jacob Alexander <haata@kiibohd.com>
parents: 297
diff changeset
435
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
436 // Update the scancode key state
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
437 // States:
184
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
438 // * 0x00 - Off
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
439 // * 0x01 - Pressed
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
440 // * 0x02 - Held
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
441 // * 0x03 - Released
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
442 // * 0x04 - Unpressed (this is currently ignored)
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
443 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
444 {
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
445 // 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
446 switch ( state )
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
447 {
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
448 case 0x01: // Pressed
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
449 case 0x02: // Held
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
450 case 0x03: // Released
184
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
451 macroTriggerListBuffer[ macroTriggerListBufferSize ].scanCode = scanCode;
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
452 macroTriggerListBuffer[ macroTriggerListBufferSize ].state = state;
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
453 macroTriggerListBuffer[ macroTriggerListBufferSize ].type = 0x00; // Normal key
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
454 macroTriggerListBufferSize++;
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
455 break;
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
456 }
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
457 }
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
458
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
459
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
460 // Update the scancode analog state
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
461 // States:
184
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
462 // * 0x00 - Off
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
463 // * 0x01 - Released
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
464 // * 0x02-0xFF - Analog value (low to high)
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
465 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
466 {
184
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
467 // Only add to macro trigger list if non-off
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
468 if ( state != 0x00 )
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
469 {
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
470 macroTriggerListBuffer[ macroTriggerListBufferSize ].scanCode = scanCode;
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
471 macroTriggerListBuffer[ macroTriggerListBufferSize ].state = state;
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
472 macroTriggerListBuffer[ macroTriggerListBufferSize ].type = 0x02; // Analog key
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
473 macroTriggerListBufferSize++;
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
474 }
166
2fba36caf039 Initial work for KLL macro support
Jacob Alexander <haata@kiibohd.com>
parents: 159
diff changeset
475 }
2fba36caf039 Initial work for KLL macro support
Jacob Alexander <haata@kiibohd.com>
parents: 159
diff changeset
476
2fba36caf039 Initial work for KLL macro support
Jacob Alexander <haata@kiibohd.com>
parents: 159
diff changeset
477
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
478 // Update led state
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
479 // States:
184
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
480 // * 0x00 - Off
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
481 // * 0x01 - On
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
482 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
483 {
184
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
484 // Only add to macro trigger list if non-off
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
485 if ( state != 0x00 )
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
486 {
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
487 macroTriggerListBuffer[ macroTriggerListBufferSize ].scanCode = ledCode;
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
488 macroTriggerListBuffer[ macroTriggerListBufferSize ].state = state;
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
489 macroTriggerListBuffer[ macroTriggerListBufferSize ].type = 0x01; // LED key
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
490 macroTriggerListBufferSize++;
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
491 }
166
2fba36caf039 Initial work for KLL macro support
Jacob Alexander <haata@kiibohd.com>
parents: 159
diff changeset
492 }
2fba36caf039 Initial work for KLL macro support
Jacob Alexander <haata@kiibohd.com>
parents: 159
diff changeset
493
2fba36caf039 Initial work for KLL macro support
Jacob Alexander <haata@kiibohd.com>
parents: 159
diff changeset
494
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
495 // Append result macro to pending list, checking for duplicates
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
496 // Do nothing if duplicate
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
497 inline void Macro_appendResultMacroToPendingList( const TriggerMacro *triggerMacro )
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
498 {
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
499 // Lookup result macro index
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
500 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
501
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
502 // 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
503 for ( var_uint_t macro = 0; macro < macroResultMacroPendingListSize; macro++ )
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
504 {
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
505 // If duplicate found, do nothing
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
506 if ( macroResultMacroPendingList[ macro ] == resultMacroIndex )
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
507 return;
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
508 }
166
2fba36caf039 Initial work for KLL macro support
Jacob Alexander <haata@kiibohd.com>
parents: 159
diff changeset
509
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
510 // No duplicates found, add to pending list
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
511 macroResultMacroPendingList[ macroResultMacroPendingListSize++ ] = resultMacroIndex;
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
512
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
513 // 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
514 var_uint_t pos = 0;
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
515 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
516 {
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
517 pos += TriggerGuideSize * comboLength + 1;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
518 comboLength = triggerMacro->guide[ pos ];
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
519 }
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
520
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
521 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
522
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
523 // Lookup scanCode in buffer list for the current state and stateType
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
524 for ( uint8_t keyIndex = 0; keyIndex < macroTriggerListBufferSize; keyIndex++ )
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
525 {
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
526 if ( macroTriggerListBuffer[ keyIndex ].scanCode == scanCode )
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
527 {
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
528 ResultMacroRecordList[ resultMacroIndex ].state = macroTriggerListBuffer[ keyIndex ].state;
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
529 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
530 }
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
531 }
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
532
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
533 // Reset the macro position
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
534 ResultMacroRecordList[ resultMacroIndex ].pos = 0;
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
535 }
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
536
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
537
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
538 // Determine if long ResultMacro (more than 1 seqence element)
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
539 inline uint8_t Macro_isLongResultMacro( const ResultMacro *macro )
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
540 {
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
541 // Check the second sequence combo length
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
542 // If non-zero return non-zero (long sequence)
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
543 // 0 otherwise (short sequence)
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
544 var_uint_t position = 1;
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
545 for ( var_uint_t result = 0; result < macro->guide[0]; result++ )
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
546 position += ResultGuideSize( (ResultGuide*)&macro->guide[ position ] );
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
547 return macro->guide[ position ];
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
548 }
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
549
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
550
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
551 // Determine if long TriggerMacro (more than 1 sequence element)
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
552 inline uint8_t Macro_isLongTriggerMacro( const TriggerMacro *macro )
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
553 {
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
554 // Check the second sequence combo length
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
555 // If non-zero return non-zero (long sequence)
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
556 // 0 otherwise (short sequence)
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
557 return macro->guide[ macro->guide[0] * TriggerGuideSize + 1 ];
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
558 }
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
559
166
2fba36caf039 Initial work for KLL macro support
Jacob Alexander <haata@kiibohd.com>
parents: 159
diff changeset
560
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
561 // Votes on the given key vs. guide, short macros
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
562 inline TriggerMacroVote Macro_evalShortTriggerMacroVote( TriggerGuide *key, TriggerGuide *guide )
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
563 {
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
564 // Depending on key type
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
565 switch ( guide->type )
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
566 {
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
567 // Normal State Type
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
568 case 0x00:
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
569 // For short TriggerMacros completely ignore incorrect keys
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
570 if ( guide->scanCode == key->scanCode )
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
571 {
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
572 switch ( key->state )
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
573 {
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
574 // Correct key, pressed, possible passing
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
575 case 0x01:
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
576 return TriggerMacroVote_Pass;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
577
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
578 // Correct key, held, possible passing or release
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
579 case 0x02:
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
580 return TriggerMacroVote_PassRelease;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
581
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
582 // Correct key, released, possible release
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
583 case 0x03:
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
584 return TriggerMacroVote_Release;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
585 }
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
586 }
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
587
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
588 return TriggerMacroVote_DoNothing;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
589
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
590 // LED State Type
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
591 case 0x01:
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
592 erro_print("LED State Type - Not implemented...");
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
593 break;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
594
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
595 // Analog State Type
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
596 case 0x02:
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
597 erro_print("Analog State Type - Not implemented...");
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
598 break;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
599
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
600 // Invalid State Type
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
601 default:
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
602 erro_print("Invalid State Type. This is a bug.");
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
603 break;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
604 }
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
605
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
606 // XXX Shouldn't reach here
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
607 return TriggerMacroVote_Invalid;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
608 }
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
609
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
610
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
611 // Votes on the given key vs. guide, long macros
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
612 // A long macro is defined as a guide with more than 1 combo
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
613 inline TriggerMacroVote Macro_evalLongTriggerMacroVote( TriggerGuide *key, TriggerGuide *guide )
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
614 {
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
615 // Depending on key type
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
616 switch ( guide->type )
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
617 {
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
618 // Normal State Type
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
619 case 0x00:
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
620 // Depending on the state of the buffered key, make voting decision
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
621 // Incorrect key
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
622 if ( guide->scanCode != key->scanCode )
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
623 {
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
624 switch ( key->state )
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
625 {
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
626 // Wrong key, pressed, fail
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
627 case 0x01:
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
628 return TriggerMacroVote_Fail;
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
629
197
1ebb6fb5f74f All basic macros tested and working!
Jacob Alexander <haata@kiibohd.com>
parents: 196
diff changeset
630 // Wrong key, held, do not pass (no effect)
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
631 case 0x02:
197
1ebb6fb5f74f All basic macros tested and working!
Jacob Alexander <haata@kiibohd.com>
parents: 196
diff changeset
632 return TriggerMacroVote_DoNothing;
1ebb6fb5f74f All basic macros tested and working!
Jacob Alexander <haata@kiibohd.com>
parents: 196
diff changeset
633
1ebb6fb5f74f All basic macros tested and working!
Jacob Alexander <haata@kiibohd.com>
parents: 196
diff changeset
634 // Wrong key released, fail out if pos == 0
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
635 case 0x03:
197
1ebb6fb5f74f All basic macros tested and working!
Jacob Alexander <haata@kiibohd.com>
parents: 196
diff changeset
636 return TriggerMacroVote_DoNothing | TriggerMacroVote_DoNothingRelease;
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
637 }
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
638 }
166
2fba36caf039 Initial work for KLL macro support
Jacob Alexander <haata@kiibohd.com>
parents: 159
diff changeset
639
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
640 // Correct key
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
641 else
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
642 {
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
643 switch ( key->state )
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
644 {
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
645 // Correct key, pressed, possible passing
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
646 case 0x01:
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
647 return TriggerMacroVote_Pass;
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
648
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
649 // Correct key, held, possible passing or release
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
650 case 0x02:
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
651 return TriggerMacroVote_PassRelease;
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
652
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
653 // Correct key, released, possible release
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
654 case 0x03:
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
655 return TriggerMacroVote_Release;
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
656 }
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
657 }
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
658
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
659 break;
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
660
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
661 // LED State Type
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
662 case 0x01:
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
663 erro_print("LED State Type - Not implemented...");
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
664 break;
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
665
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
666 // Analog State Type
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
667 case 0x02:
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
668 erro_print("Analog State Type - Not implemented...");
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
669 break;
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
670
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
671 // Invalid State Type
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
672 default:
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
673 erro_print("Invalid State Type. This is a bug.");
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
674 break;
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
675 }
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
676
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
677 // XXX Shouldn't reach here
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
678 return TriggerMacroVote_Invalid;
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
679 }
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
680
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 // Evaluate/Update TriggerMacro
265
708af1b9bc55 Fixing warning messages found using clang.
Jacob Alexander <haata@kiibohd.com>
parents: 253
diff changeset
683 TriggerMacroEval Macro_evalTriggerMacro( var_uint_t triggerMacroIndex )
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
684 {
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
685 // Lookup TriggerMacro
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
686 const TriggerMacro *macro = &TriggerMacroList[ triggerMacroIndex ];
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
687 TriggerMacroRecord *record = &TriggerMacroRecordList[ triggerMacroIndex ];
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
688
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
689 // Check if macro has finished and should be incremented sequence elements
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
690 if ( record->state == TriggerMacro_Release )
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
691 {
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
692 record->state = TriggerMacro_Waiting;
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
693 record->pos = record->pos + macro->guide[ record->pos ] * TriggerGuideSize + 1;
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
694 }
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
695
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
696 // Current Macro position
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
697 var_uint_t pos = record->pos;
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
698
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
699 // Length of the combo being processed
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
700 uint8_t comboLength = macro->guide[ pos ] * TriggerGuideSize;
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
701
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
702 // If no combo items are left, remove the TriggerMacro from the pending list
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
703 if ( comboLength == 0 )
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
704 {
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
705 return TriggerMacroEval_Remove;
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
706 }
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
707
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
708 // Check if this is a long Trigger Macro
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
709 uint8_t longMacro = Macro_isLongTriggerMacro( macro );
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
710
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
711 // Iterate through the items in the combo, voting the on the key state
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
712 // If any of the pressed keys do not match, fail the macro
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
713 //
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
714 // The macro is waiting for input when in the TriggerMacro_Waiting state
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
715 // Once all keys have been pressed/held (only those keys), entered TriggerMacro_Press state (passing)
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
716 // Transition to the next combo (if it exists) when a single key is released (TriggerMacro_Release state)
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
717 // On scan after position increment, change to TriggerMacro_Waiting state
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
718 // TODO Add support for system LED states (NumLock, CapsLock, etc.)
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
719 // TODO Add support for analog key states
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
720 // TODO Add support for 0x00 Key state (not pressing a key, not all that useful in general)
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
721 // TODO Add support for Press/Hold/Release differentiation when evaluating (not sure if useful)
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
722 TriggerMacroVote overallVote = TriggerMacroVote_Invalid;
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
723 for ( uint8_t comboItem = pos + 1; comboItem < pos + comboLength + 1; comboItem += TriggerGuideSize )
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
724 {
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
725 // Assign TriggerGuide element (key type, state and scancode)
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
726 TriggerGuide *guide = (TriggerGuide*)(&macro->guide[ comboItem ]);
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
727
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
728 TriggerMacroVote vote = TriggerMacroVote_Invalid;
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
729 // Iterate through the key buffer, comparing to each key in the combo
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
730 for ( uint8_t key = 0; key < macroTriggerListBufferSize; key++ )
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
731 {
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
732 // Lookup key information
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
733 TriggerGuide *keyInfo = &macroTriggerListBuffer[ key ];
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
734
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
735 // If vote is a pass (>= 0x08, no more keys in the combo need to be looked at)
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
736 // Also mask all of the non-passing votes
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
737 vote |= longMacro
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
738 ? Macro_evalLongTriggerMacroVote( keyInfo, guide )
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
739 : Macro_evalShortTriggerMacroVote( keyInfo, guide );
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
740 if ( vote >= TriggerMacroVote_Pass )
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
741 {
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
742 vote &= TriggerMacroVote_Release | TriggerMacroVote_PassRelease | TriggerMacroVote_Pass;
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
743 break;
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
744 }
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
745 }
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
746
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
747 // If no pass vote was found after scanning all of the keys
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
748 // Fail the combo, if this is a short macro (long macros already will have a fail vote)
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
749 if ( !longMacro && vote < TriggerMacroVote_Pass )
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
750 vote |= TriggerMacroVote_Fail;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
751
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
752 // After voting, append to overall vote
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
753 overallVote |= vote;
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
754 }
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
755
197
1ebb6fb5f74f All basic macros tested and working!
Jacob Alexander <haata@kiibohd.com>
parents: 196
diff changeset
756 // If no pass vote was found after scanning the entire combo
1ebb6fb5f74f All basic macros tested and working!
Jacob Alexander <haata@kiibohd.com>
parents: 196
diff changeset
757 // And this is the first position in the combo, just remove it (nothing important happened)
1ebb6fb5f74f All basic macros tested and working!
Jacob Alexander <haata@kiibohd.com>
parents: 196
diff changeset
758 if ( longMacro && overallVote & TriggerMacroVote_DoNothingRelease && pos == 0 )
1ebb6fb5f74f All basic macros tested and working!
Jacob Alexander <haata@kiibohd.com>
parents: 196
diff changeset
759 overallVote |= TriggerMacroVote_Fail;
1ebb6fb5f74f All basic macros tested and working!
Jacob Alexander <haata@kiibohd.com>
parents: 196
diff changeset
760
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
761 // Decide new state of macro after voting
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
762 // Fail macro, remove from pending list
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
763 if ( overallVote & TriggerMacroVote_Fail )
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
764 {
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
765 return TriggerMacroEval_Remove;
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
766 }
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
767 // Do nothing, incorrect key is being held or released
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
768 else if ( overallVote & TriggerMacroVote_DoNothing && longMacro )
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
769 {
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
770 // Just doing nothing :)
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
771 }
216
738445f38639 DPH controller now working with the kishsaver and macros
Jacob Alexander <haata@kiibohd.com>
parents: 215
diff changeset
772 // If ready for transition and in Press state, set to Waiting and increment combo position
738445f38639 DPH controller now working with the kishsaver and macros
Jacob Alexander <haata@kiibohd.com>
parents: 215
diff changeset
773 // Position is incremented (and possibly remove the macro from the pending list) on the next iteration
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
774 else if ( overallVote & TriggerMacroVote_Release && record->state == TriggerMacro_Press )
216
738445f38639 DPH controller now working with the kishsaver and macros
Jacob Alexander <haata@kiibohd.com>
parents: 215
diff changeset
775 {
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
776 record->state = TriggerMacro_Release;
216
738445f38639 DPH controller now working with the kishsaver and macros
Jacob Alexander <haata@kiibohd.com>
parents: 215
diff changeset
777
738445f38639 DPH controller now working with the kishsaver and macros
Jacob Alexander <haata@kiibohd.com>
parents: 215
diff changeset
778 // If this is the last combo in the sequence, remove from the pending list
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
779 if ( macro->guide[ record->pos + macro->guide[ record->pos ] * TriggerGuideSize + 1 ] == 0 )
216
738445f38639 DPH controller now working with the kishsaver and macros
Jacob Alexander <haata@kiibohd.com>
parents: 215
diff changeset
780 return TriggerMacroEval_DoResultAndRemove;
738445f38639 DPH controller now working with the kishsaver and macros
Jacob Alexander <haata@kiibohd.com>
parents: 215
diff changeset
781 }
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
782 // If passing and in Waiting state, set macro state to Press
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
783 else if ( overallVote & TriggerMacroVote_Pass
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
784 && ( record->state == TriggerMacro_Waiting || record->state == TriggerMacro_Press ) )
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
785 {
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
786 record->state = TriggerMacro_Press;
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
787
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
788 // If in press state, and this is the final combo, send request for ResultMacro
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
789 // Check to see if the result macro only has a single element
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
790 // If this result macro has more than 1 key, only send once
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
791 // TODO Add option to have long macro repeat rate
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
792 if ( macro->guide[ pos + comboLength + 1 ] == 0 )
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
793 {
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
794 // Long result macro (more than 1 combo)
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
795 if ( Macro_isLongResultMacro( &ResultMacroList[ macro->result ] ) )
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
796 {
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
797 // Only ever trigger result once, on press
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
798 if ( overallVote == TriggerMacroVote_Pass )
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
799 {
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
800 return TriggerMacroEval_DoResultAndRemove;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
801 }
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
802 }
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
803 // Short result macro
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
804 else
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
805 {
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
806 // Only trigger result once, on press, if long trigger (more than 1 combo)
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
807 if ( Macro_isLongTriggerMacro( macro ) )
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
808 {
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
809 return TriggerMacroEval_DoResultAndRemove;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
810 }
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
811 // Otherwise, trigger result continuously
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
812 else
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
813 {
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
814 return TriggerMacroEval_DoResult;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
815 }
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
816 }
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
817 }
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
818 }
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
819 // Otherwise, just remove the macro on key release
201
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
820 // One more result has to be called to indicate to the ResultMacro that the key transitioned to the release state
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
821 else if ( overallVote & TriggerMacroVote_Release )
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
822 {
201
326f75709d10 Fixing release state for keys
Jacob Alexander <jacob.alexander@virtualinstruments.com>
parents: 199
diff changeset
823 return TriggerMacroEval_DoResultAndRemove;
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
824 }
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
825
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
826 // If this is a short macro, just remove it
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
827 // The state can be rebuilt on the next iteration
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
828 if ( !longMacro )
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
829 return TriggerMacroEval_Remove;
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
830
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
831 return TriggerMacroEval_DoNothing;
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
832 }
166
2fba36caf039 Initial work for KLL macro support
Jacob Alexander <haata@kiibohd.com>
parents: 159
diff changeset
833
2fba36caf039 Initial work for KLL macro support
Jacob Alexander <haata@kiibohd.com>
parents: 159
diff changeset
834
185
68f3dc0cddd0 Macro cleanup.
Jacob Alexander <haata@kiibohd.com>
parents: 184
diff changeset
835 // Evaluate/Update ResultMacro
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
836 inline ResultMacroEval Macro_evalResultMacro( var_uint_t resultMacroIndex )
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
837 {
190
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
838 // Lookup ResultMacro
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
839 const ResultMacro *macro = &ResultMacroList[ resultMacroIndex ];
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
840 ResultMacroRecord *record = &ResultMacroRecordList[ resultMacroIndex ];
190
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
841
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
842 // Current Macro position
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
843 var_uint_t pos = record->pos;
190
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
844
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
845 // Length of combo being processed
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
846 uint8_t comboLength = macro->guide[ pos ];
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
847
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
848 // Function Counter, used to keep track of the combo items processed
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
849 var_uint_t funcCount = 0;
190
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
850
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
851 // Combo Item Position within the guide
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
852 var_uint_t comboItem = pos + 1;
190
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
853
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
854 // Iterate through the Result Combo
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
855 while ( funcCount < comboLength )
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
856 {
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
857 // Assign TriggerGuide element (key type, state and scancode)
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
858 ResultGuide *guide = (ResultGuide*)(&macro->guide[ comboItem ]);
190
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
859
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
860 // Do lookup on capability function
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
861 void (*capability)(uint8_t, uint8_t, uint8_t*) = (void(*)(uint8_t, uint8_t, uint8_t*))(CapabilitiesList[ guide->index ].func);
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
862
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
863 // Call capability
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
864 capability( record->state, record->stateType, &guide->args );
190
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
865
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
866 // Increment counters
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
867 funcCount++;
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
868 comboItem += ResultGuideSize( (ResultGuide*)(&macro->guide[ comboItem ]) );
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
869 }
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
870
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
871 // Move to next item in the sequence
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
872 record->pos = comboItem;
190
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
873
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
874 // If the ResultMacro is finished, remove
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
875 if ( macro->guide[ comboItem ] == 0 )
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
876 {
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
877 record->pos = 0;
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
878 return ResultMacroEval_Remove;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
879 }
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
880
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
881 // Otherwise leave the macro in the list
190
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
882 return ResultMacroEval_DoNothing;
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
883 }
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
884
159
84beeecd2c94 Kishsaver is fully working with DPH!
Jacob Alexander <haata@kiibohd.com>
parents: 150
diff changeset
885
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
886 // Update pending trigger list
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
887 inline void Macro_updateTriggerMacroPendingList()
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
888 {
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
889 // Iterate over the macroTriggerListBuffer to add any new Trigger Macros to the pending list
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
890 for ( uint8_t key = 0; key < macroTriggerListBufferSize; key++ )
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
891 {
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
892 // TODO LED States
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
893 // TODO Analog Switches
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
894 // Only add TriggerMacro to pending list if key was pressed (not held, released or off)
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
895 if ( macroTriggerListBuffer[ key ].state == 0x00 && macroTriggerListBuffer[ key ].state != 0x01 )
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
896 continue;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
897
253
e79f2b9c39cf Fixing layer latch capability.
Jacob Alexander <haata@kiibohd.com>
parents: 241
diff changeset
898 // TODO Analog
e79f2b9c39cf Fixing layer latch capability.
Jacob Alexander <haata@kiibohd.com>
parents: 241
diff changeset
899 // If this is a release case, indicate to layer lookup for possible latch expiry
e79f2b9c39cf Fixing layer latch capability.
Jacob Alexander <haata@kiibohd.com>
parents: 241
diff changeset
900 uint8_t latch_expire = macroTriggerListBuffer[ key ].state == 0x03;
e79f2b9c39cf Fixing layer latch capability.
Jacob Alexander <haata@kiibohd.com>
parents: 241
diff changeset
901
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
902 // Lookup Trigger List
297
c86eb7d0a693 Fixing releasing Function key and holding layered key
Jacob Alexander <haata@kiibohd.com>
parents: 271
diff changeset
903 nat_ptr_t *triggerList = Macro_layerLookup( &macroTriggerListBuffer[ key ], latch_expire );
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
904
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
905 // Number of Triggers in list
202
1a68a9a04ad3 Adding variable width state variable width.
Jacob Alexander <haata@kiibohd.com>
parents: 201
diff changeset
906 nat_ptr_t triggerListSize = triggerList[0];
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
907
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
908 // Iterate over triggerList to see if any TriggerMacros need to be added
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
909 // First item is the number of items in the TriggerList
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
910 for ( var_uint_t macro = 1; macro < triggerListSize + 1; macro++ )
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
911 {
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
912 // Lookup trigger macro index
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
913 var_uint_t triggerMacroIndex = triggerList[ macro ];
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
914
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
915 // Iterate over macroTriggerMacroPendingList to see if any macro in the scancode's
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
916 // triggerList needs to be added
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
917 var_uint_t pending = 0;
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
918 for ( ; pending < macroTriggerMacroPendingListSize; pending++ )
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
919 {
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
920 // Stop scanning if the trigger macro index is found in the pending list
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
921 if ( macroTriggerMacroPendingList[ pending ] == triggerMacroIndex )
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
922 break;
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
923 }
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
924
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
925 // If the triggerMacroIndex (macro) was not found in the macroTriggerMacroPendingList
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
926 // Add it to the list
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
927 if ( pending == macroTriggerMacroPendingListSize )
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
928 {
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
929 macroTriggerMacroPendingList[ macroTriggerMacroPendingListSize++ ] = triggerMacroIndex;
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
930
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
931 // Reset macro position
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
932 TriggerMacroRecordList[ triggerMacroIndex ].pos = 0;
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
933 TriggerMacroRecordList[ triggerMacroIndex ].state = TriggerMacro_Waiting;
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
934 }
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
935 }
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
936 }
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
937 }
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
938
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
939
185
68f3dc0cddd0 Macro cleanup.
Jacob Alexander <haata@kiibohd.com>
parents: 184
diff changeset
940 // Macro Procesing Loop
68f3dc0cddd0 Macro cleanup.
Jacob Alexander <haata@kiibohd.com>
parents: 184
diff changeset
941 // 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
942 inline void Macro_process()
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
943 {
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
944 // 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
945 if ( USBKeys_Sent != 0 )
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
946 return;
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
947
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
948 // 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
949 if ( macroPauseMode )
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
950 {
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
951 if ( macroStepCounter == 0 )
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
952 return;
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
953
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
954 // Proceed, decrementing the step counter
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
955 macroStepCounter--;
192
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
956 dbug_print("Macro Step");
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
957 }
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
958
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
959 // Update pending trigger list, before processing TriggerMacros
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
960 Macro_updateTriggerMacroPendingList();
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
961
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
962 // Tail pointer for macroTriggerMacroPendingList
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
963 // Macros must be explicitly re-added
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
964 var_uint_t macroTriggerMacroPendingListTail = 0;
185
68f3dc0cddd0 Macro cleanup.
Jacob Alexander <haata@kiibohd.com>
parents: 184
diff changeset
965
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
966 // Iterate through the pending TriggerMacros, processing each of them
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
967 for ( var_uint_t macro = 0; macro < macroTriggerMacroPendingListSize; macro++ )
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
968 {
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
969 switch ( Macro_evalTriggerMacro( macroTriggerMacroPendingList[ macro ] ) )
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
970 {
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
971 // Trigger Result Macro (purposely falling through)
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
972 case TriggerMacroEval_DoResult:
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
973 // Append ResultMacro to PendingList
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
974 Macro_appendResultMacroToPendingList( &TriggerMacroList[ macroTriggerMacroPendingList[ macro ] ] );
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
975
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
976 default:
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
977 macroTriggerMacroPendingList[ macroTriggerMacroPendingListTail++ ] = macroTriggerMacroPendingList[ macro ];
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
978 break;
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
979
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
980 // Trigger Result Macro and Remove (purposely falling through)
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
981 case TriggerMacroEval_DoResultAndRemove:
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
982 // Append ResultMacro to PendingList
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
983 Macro_appendResultMacroToPendingList( &TriggerMacroList[ macroTriggerMacroPendingList[ macro ] ] );
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
984
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
985 // Remove Macro from Pending List, nothing to do, removing by default
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
986 case TriggerMacroEval_Remove:
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
987 break;
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
988 }
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
989 }
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
990
190
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
991 // Update the macroTriggerMacroPendingListSize with the tail pointer
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
992 macroTriggerMacroPendingListSize = macroTriggerMacroPendingListTail;
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
993
190
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
994
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
995 // Tail pointer for macroResultMacroPendingList
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
996 // Macros must be explicitly re-added
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
997 var_uint_t macroResultMacroPendingListTail = 0;
190
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
998
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
999 // Iterate through the pending ResultMacros, processing each of them
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
1000 for ( var_uint_t macro = 0; macro < macroResultMacroPendingListSize; macro++ )
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
1001 {
190
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1002 switch ( Macro_evalResultMacro( macroResultMacroPendingList[ macro ] ) )
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1003 {
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1004 // Re-add macros to pending list
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1005 case ResultMacroEval_DoNothing:
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1006 default:
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1007 macroResultMacroPendingList[ macroResultMacroPendingListTail++ ] = macroResultMacroPendingList[ macro ];
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1008 break;
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1009
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1010 // Remove Macro from Pending List, nothing to do, removing by default
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1011 case ResultMacroEval_Remove:
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1012 break;
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1013 }
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
1014 }
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
1015
190
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1016 // Update the macroResultMacroPendingListSize with the tail pointer
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1017 macroResultMacroPendingListSize = macroResultMacroPendingListTail;
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1018
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1019 // Signal buffer that we've used it
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1020 Scan_finishedWithMacro( macroTriggerListBufferSize );
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1021
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1022 // Reset TriggerList buffer
7a71c6e38d56 Macro processing is now feature complete.
Jacob Alexander <haata@kiibohd.com>
parents: 189
diff changeset
1023 macroTriggerListBufferSize = 0;
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1024
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1025 // 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
1026 if ( macroDebugMode )
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1027 {
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1028 USBKeys_Modifiers = 0;
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1029 USBKeys_Sent = 0;
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1030 }
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1031 }
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1032
185
68f3dc0cddd0 Macro cleanup.
Jacob Alexander <haata@kiibohd.com>
parents: 184
diff changeset
1033
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1034 inline void Macro_setup()
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1035 {
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1036 // Register Macro CLI dictionary
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1037 CLI_registerDictionary( macroCLIDict, macroCLIDictName );
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1038
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1039 // Disable Macro debug mode
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1040 macroDebugMode = 0;
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
1041
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1042 // Disable Macro pause flag
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1043 macroPauseMode = 0;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1044
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1045 // Set Macro step counter to zero
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1046 macroStepCounter = 0;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1047
176
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
1048 // Make sure macro trigger buffer is empty
d3ae6b409cfa Initial work for partial layers and macros.
Jacob Alexander <haata@kiibohd.com>
parents: 166
diff changeset
1049 macroTriggerListBufferSize = 0;
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
1050
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
1051 // Initialize TriggerMacro states
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
1052 for ( var_uint_t macro = 0; macro < TriggerMacroNum; macro++ )
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
1053 {
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
1054 TriggerMacroRecordList[ macro ].pos = 0;
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
1055 TriggerMacroRecordList[ macro ].state = TriggerMacro_Waiting;
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
1056 }
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
1057
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
1058 // Initialize ResultMacro states
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
1059 for ( var_uint_t macro = 0; macro < ResultMacroNum; macro++ )
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
1060 {
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
1061 ResultMacroRecordList[ macro ].pos = 0;
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
1062 ResultMacroRecordList[ macro ].state = 0;
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
1063 ResultMacroRecordList[ macro ].stateType = 0;
189
4493d8d2c959 Adding TriggerMacro processing.
Jacob Alexander <haata@kiibohd.com>
parents: 186
diff changeset
1064 }
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1065 }
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1066
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1067
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1068 // ----- CLI Command Functions -----
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1069
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1070 void cliFunc_capList( char* args )
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1071 {
180
ed56f7873645 Added capabilities list debug option
Jacob Alexander <haata@kiibohd.com>
parents: 179
diff changeset
1072 print( NL );
271
e6c753528873 More mk20dx256vlh7 preparation.
Jacob Alexander <haata@kiibohd.com>
parents: 265
diff changeset
1073 info_msg("Capabilities List ");
192
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1074 printHex( CapabilitiesNum );
180
ed56f7873645 Added capabilities list debug option
Jacob Alexander <haata@kiibohd.com>
parents: 179
diff changeset
1075
ed56f7873645 Added capabilities list debug option
Jacob Alexander <haata@kiibohd.com>
parents: 179
diff changeset
1076 // 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
1077 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
1078 {
ed56f7873645 Added capabilities list debug option
Jacob Alexander <haata@kiibohd.com>
parents: 179
diff changeset
1079 print( NL "\t" );
ed56f7873645 Added capabilities list debug option
Jacob Alexander <haata@kiibohd.com>
parents: 179
diff changeset
1080 printHex( cap );
ed56f7873645 Added capabilities list debug option
Jacob Alexander <haata@kiibohd.com>
parents: 179
diff changeset
1081 print(" - ");
ed56f7873645 Added capabilities list debug option
Jacob Alexander <haata@kiibohd.com>
parents: 179
diff changeset
1082
ed56f7873645 Added capabilities list debug option
Jacob Alexander <haata@kiibohd.com>
parents: 179
diff changeset
1083 // 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
1084 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
1085 capability( 0xFF, 0xFF, 0 );
ed56f7873645 Added capabilities list debug option
Jacob Alexander <haata@kiibohd.com>
parents: 179
diff changeset
1086 }
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1087 }
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1088
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1089 void cliFunc_capSelect( char* args )
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1090 {
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1091 // 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
1092 char* curArgs;
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1093 char* arg1Ptr;
182
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1094 char* arg2Ptr = args;
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1095
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1096 // 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
1097 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
1098 var_uint_t cap = 0;
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1099
182
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1100 // 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
1101 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
1102 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
1103
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1104 // Process all args
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
1105 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
1106 {
182
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1107 curArgs = arg2Ptr;
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1108 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
1109
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1110 // 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
1111 // Extra arguments are ignored
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1112 if ( *arg1Ptr == '\0' )
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1113 break;
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1114
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1115 // 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
1116 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
1117 {
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1118 // Keyboard Capability
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1119 case 'K':
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1120 // Determine capability index
195
58cfcb7bac88 Changing decToInt to numToInt (adds support for Hex number interpreter)
Jacob Alexander <haata@kiibohd.com>
parents: 192
diff changeset
1121 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
1122
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1123 // 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
1124 totalArgs += CapabilitiesList[ cap ].argCount;
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1125 continue;
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1126 }
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1127
182
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1128 // 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
1129 // 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
1130 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
1131
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1132 // 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
1133 if ( argSetCount == totalArgs )
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1134 {
182
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1135 // 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
1136 print( NL );
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1137 info_msg("K");
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1138 printInt8( cap );
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1139 print(" - ");
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1140 printHex( argSet[0] );
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1141 print(" - ");
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1142 printHex( argSet[1] );
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1143 print(" - ");
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1144 printHex( argSet[2] );
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1145 print( "..." NL );
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1146
880c33236cd1 Added capSelect function that can arbitrary run a keyboard capability
Jacob Alexander <haata@kiibohd.com>
parents: 181
diff changeset
1147 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
1148 capability( argSet[0], argSet[1], &argSet[2] );
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1149 }
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1150 }
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1151 }
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1152
192
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1153 void cliFunc_keyHold( char* args )
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1154 {
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1155 // Parse codes from arguments
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1156 char* curArgs;
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1157 char* arg1Ptr;
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1158 char* arg2Ptr = args;
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1159
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1160 // Process all args
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1161 for ( ;; )
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1162 {
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1163 curArgs = arg2Ptr;
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1164 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1165
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1166 // 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
1167 if ( *arg1Ptr == '\0' )
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1168 break;
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1169
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1170 // Ignore non-Scancode numbers
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1171 switch ( arg1Ptr[0] )
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1172 {
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1173 // Scancode
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1174 case 'S':
195
58cfcb7bac88 Changing decToInt to numToInt (adds support for Hex number interpreter)
Jacob Alexander <haata@kiibohd.com>
parents: 192
diff changeset
1175 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
1176 break;
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1177 }
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1178 }
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1179 }
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1180
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1181 void cliFunc_keyPress( char* args )
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1182 {
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1183 // Parse codes from arguments
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1184 char* curArgs;
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1185 char* arg1Ptr;
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1186 char* arg2Ptr = args;
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 // Process all args
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1189 for ( ;; )
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 curArgs = arg2Ptr;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1192 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1193
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1194 // Stop processing args if no more are found
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1195 if ( *arg1Ptr == '\0' )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1196 break;
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1197
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1198 // Ignore non-Scancode numbers
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1199 switch ( arg1Ptr[0] )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1200 {
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1201 // Scancode
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1202 case 'S':
195
58cfcb7bac88 Changing decToInt to numToInt (adds support for Hex number interpreter)
Jacob Alexander <haata@kiibohd.com>
parents: 192
diff changeset
1203 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
1204 break;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1205 }
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1206 }
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1207 }
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1208
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1209 void cliFunc_keyRelease( char* args )
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1210 {
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1211 // Parse codes from arguments
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1212 char* curArgs;
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1213 char* arg1Ptr;
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1214 char* arg2Ptr = args;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1215
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1216 // Process all args
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1217 for ( ;; )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1218 {
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1219 curArgs = arg2Ptr;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1220 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1221
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1222 // Stop processing args if no more are found
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1223 if ( *arg1Ptr == '\0' )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1224 break;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1225
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1226 // Ignore non-Scancode numbers
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1227 switch ( arg1Ptr[0] )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1228 {
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1229 // Scancode
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1230 case 'S':
195
58cfcb7bac88 Changing decToInt to numToInt (adds support for Hex number interpreter)
Jacob Alexander <haata@kiibohd.com>
parents: 192
diff changeset
1231 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
1232 break;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1233 }
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1234 }
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1235 }
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1236
344
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
1237 void cliFunc_layerDebug( char *args )
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
1238 {
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
1239 // Toggle layer debug mode
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
1240 layerDebugMode = layerDebugMode ? 0 : 1;
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
1241
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
1242 print( NL );
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
1243 info_msg("Layer Debug Mode: ");
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
1244 printInt8( layerDebugMode );
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
1245 }
f04450004adf Adding layerDebug cli command
Jacob Alexander <haata@kiibohd.com>
parents: 307
diff changeset
1246
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1247 void cliFunc_layerList( char* args )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1248 {
183
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1249 print( NL );
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1250 info_msg("Layer List");
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1251
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1252 // 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
1253 for ( uint16_t layer = 0; layer < LayerNum; layer++ )
183
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1254 {
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1255 print( NL "\t" );
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1256 printHex( layer );
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1257 print(" - ");
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1258
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1259 // Display layer name
192
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1260 dPrint( (char*)LayerIndex[ layer ].name );
183
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1261
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1262 // Default map
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1263 if ( layer == 0 )
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1264 print(" \033[1m(default)\033[0m");
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1265
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1266 // Layer State
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1267 print( NL "\t\t Layer State: " );
214
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
1268 printHex( LayerState[ layer ] );
183
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1269
214
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
1270 // First -> Last Indices
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
1271 print(" First -> Last Indices: ");
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
1272 printHex( LayerIndex[ layer ].first );
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
1273 print(" -> ");
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
1274 printHex( LayerIndex[ layer ].last );
183
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1275 }
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1276 }
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1277
183
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1278 void cliFunc_layerState( char* args )
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1279 {
183
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1280 // Parse codes from arguments
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1281 char* curArgs;
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1282 char* arg1Ptr;
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1283 char* arg2Ptr = args;
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1284
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1285 uint8_t arg1 = 0;
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1286 uint8_t arg2 = 0;
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1287
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1288 // Process first two args
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1289 for ( uint8_t c = 0; c < 2; c++ )
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1290 {
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1291 curArgs = arg2Ptr;
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1292 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1293
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1294 // Stop processing args if no more are found
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1295 if ( *arg1Ptr == '\0' )
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1296 break;
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1297
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1298 switch ( c )
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1299 {
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1300 // First argument (e.g. L1)
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1301 case 0:
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1302 if ( arg1Ptr[0] != 'L' )
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1303 return;
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1304
195
58cfcb7bac88 Changing decToInt to numToInt (adds support for Hex number interpreter)
Jacob Alexander <haata@kiibohd.com>
parents: 192
diff changeset
1305 arg1 = (uint8_t)numToInt( &arg1Ptr[1] );
183
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1306 break;
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1307 // Second argument (e.g. 4)
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1308 case 1:
195
58cfcb7bac88 Changing decToInt to numToInt (adds support for Hex number interpreter)
Jacob Alexander <haata@kiibohd.com>
parents: 192
diff changeset
1309 arg2 = (uint8_t)numToInt( arg1Ptr );
183
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1310
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1311 // Display operation (to indicate that it worked)
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1312 print( NL );
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1313 info_msg("Setting Layer L");
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1314 printInt8( arg1 );
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1315 print(" to - ");
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1316 printHex( arg2 );
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1317
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1318 // Set the layer state
214
5a5404338b9f Adding support for layer packing
Jacob Alexander <haata@kiibohd.com>
parents: 205
diff changeset
1319 LayerState[ arg1 ] = arg2;
183
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1320 break;
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1321 }
bb96551a3065 Added layerList and layerState functions
Jacob Alexander <haata@kiibohd.com>
parents: 182
diff changeset
1322 }
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1323 }
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1324
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1325 void cliFunc_macroDebug( char* args )
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1326 {
126
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1327 // Toggle macro debug mode
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1328 macroDebugMode = macroDebugMode ? 0 : 1;
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1329
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1330 print( NL );
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1331 info_msg("Macro Debug Mode: ");
670fc9c3a739 Added CLI DefaultMap lookup command.
Jacob Alexander <haata@kiibohd.com>
parents: 125
diff changeset
1332 printInt8( macroDebugMode );
125
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1333 }
8dab4014c398 Major code cleanup and preparation for PartialMap Macro Module
Jacob Alexander <haata@kiibohd.com>
parents:
diff changeset
1334
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1335 void cliFunc_macroList( char* args )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1336 {
192
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1337 // Show pending key events
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1338 print( NL );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1339 info_msg("Pending Key Events: ");
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1340 printInt16( (uint16_t)macroTriggerListBufferSize );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1341 print(" : ");
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1342 for ( uint8_t key = 0; key < macroTriggerListBufferSize; key++ )
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1343 {
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1344 printHex( macroTriggerListBuffer[ key ].scanCode );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1345 print(" ");
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1346 }
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1347
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1348 // Show pending trigger macros
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1349 print( NL );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1350 info_msg("Pending Trigger Macros: ");
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1351 printInt16( (uint16_t)macroTriggerMacroPendingListSize );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1352 print(" : ");
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
1353 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
1354 {
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1355 printHex( macroTriggerMacroPendingList[ macro ] );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1356 print(" ");
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1357 }
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1358
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1359 // Show pending result macros
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1360 print( NL );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1361 info_msg("Pending Result Macros: ");
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1362 printInt16( (uint16_t)macroResultMacroPendingListSize );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1363 print(" : ");
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
1364 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
1365 {
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1366 printHex( macroResultMacroPendingList[ macro ] );
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1367 print(" ");
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1368 }
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1369
181
80a44dcdafaf Adding macroList debug function
Jacob Alexander <haata@kiibohd.com>
parents: 180
diff changeset
1370 // Show available trigger macro indices
80a44dcdafaf Adding macroList debug function
Jacob Alexander <haata@kiibohd.com>
parents: 180
diff changeset
1371 print( NL );
80a44dcdafaf Adding macroList debug function
Jacob Alexander <haata@kiibohd.com>
parents: 180
diff changeset
1372 info_msg("Trigger Macros Range: T0 -> T");
80a44dcdafaf Adding macroList debug function
Jacob Alexander <haata@kiibohd.com>
parents: 180
diff changeset
1373 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
1374
80a44dcdafaf Adding macroList debug function
Jacob Alexander <haata@kiibohd.com>
parents: 180
diff changeset
1375 // Show available result macro indices
80a44dcdafaf Adding macroList debug function
Jacob Alexander <haata@kiibohd.com>
parents: 180
diff changeset
1376 print( NL );
80a44dcdafaf Adding macroList debug function
Jacob Alexander <haata@kiibohd.com>
parents: 180
diff changeset
1377 info_msg("Result Macros Range: R0 -> R");
80a44dcdafaf Adding macroList debug function
Jacob Alexander <haata@kiibohd.com>
parents: 180
diff changeset
1378 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
1379
80a44dcdafaf Adding macroList debug function
Jacob Alexander <haata@kiibohd.com>
parents: 180
diff changeset
1380 // Show Trigger to Result Macro Links
80a44dcdafaf Adding macroList debug function
Jacob Alexander <haata@kiibohd.com>
parents: 180
diff changeset
1381 print( NL );
80a44dcdafaf Adding macroList debug function
Jacob Alexander <haata@kiibohd.com>
parents: 180
diff changeset
1382 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
1383 for ( var_uint_t macro = 0; macro < TriggerMacroNum; macro++ )
181
80a44dcdafaf Adding macroList debug function
Jacob Alexander <haata@kiibohd.com>
parents: 180
diff changeset
1384 {
80a44dcdafaf Adding macroList debug function
Jacob Alexander <haata@kiibohd.com>
parents: 180
diff changeset
1385 print( NL );
80a44dcdafaf Adding macroList debug function
Jacob Alexander <haata@kiibohd.com>
parents: 180
diff changeset
1386 print("\tT");
80a44dcdafaf Adding macroList debug function
Jacob Alexander <haata@kiibohd.com>
parents: 180
diff changeset
1387 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
1388 print(" : R");
80a44dcdafaf Adding macroList debug function
Jacob Alexander <haata@kiibohd.com>
parents: 180
diff changeset
1389 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
1390 }
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1391 }
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1392
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1393 void cliFunc_macroProc( char* args )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1394 {
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1395 // Toggle macro pause mode
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1396 macroPauseMode = macroPauseMode ? 0 : 1;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1397
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1398 print( NL );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1399 info_msg("Macro Processing Mode: ");
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1400 printInt8( macroPauseMode );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1401 }
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1402
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
1403 void macroDebugShowTrigger( var_uint_t index )
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1404 {
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1405 // Only proceed if the macro exists
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1406 if ( index >= TriggerMacroNum )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1407 return;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1408
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1409 // Trigger Macro Show
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
1410 const TriggerMacro *macro = &TriggerMacroList[ index ];
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
1411 TriggerMacroRecord *record = &TriggerMacroRecordList[ index ];
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1412
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1413 print( NL );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1414 info_msg("Trigger Macro Index: ");
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1415 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
1416 print( NL );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1417
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1418 // 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
1419 var_uint_t pos = 0;
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1420 uint8_t comboLength = macro->guide[ pos ];
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1421
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1422 // Iterate through and interpret the guide
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1423 while ( comboLength != 0 )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1424 {
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1425 // Initial position of the combo
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
1426 var_uint_t comboPos = ++pos;
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1427
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1428 // Iterate through the combo
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1429 while ( pos < comboLength * TriggerGuideSize + comboPos )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1430 {
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1431 // Assign TriggerGuide element (key type, state and scancode)
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1432 TriggerGuide *guide = (TriggerGuide*)(&macro->guide[ pos ]);
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1433
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1434 // Display guide information about trigger key
184
f9ef267ccc8b Adding layer fall-through lookup
Jacob Alexander <haata@kiibohd.com>
parents: 183
diff changeset
1435 printHex( guide->scanCode );
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1436 print("|");
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1437 printHex( guide->type );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1438 print("|");
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1439 printHex( guide->state );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1440
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1441 // Increment position
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1442 pos += TriggerGuideSize;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1443
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1444 // 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
1445 if ( pos < comboLength * TriggerGuideSize + comboPos )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1446 print("+");
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1447 }
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1448
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1449 // Read the next comboLength
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1450 comboLength = macro->guide[ pos ];
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1451
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1452 // 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
1453 if ( comboLength != 0 )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1454 print(";");
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1455 }
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1456
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1457 // Display current position
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1458 print( NL "Position: " );
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
1459 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
1460
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1461 // Display result macro index
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1462 print( NL "Result Macro Index: " );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1463 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
1464
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
1465 // Display trigger macro state
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
1466 print( NL "Trigger Macro State: " );
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
1467 switch ( record->state )
196
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
1468 {
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
1469 case TriggerMacro_Press: print("Press"); break;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
1470 case TriggerMacro_Release: print("Release"); break;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
1471 case TriggerMacro_Waiting: print("Waiting"); break;
8ecfdaa27234 Basic Trigger and Result Macros are now working.
Jacob Alexander <haata@kiibohd.com>
parents: 195
diff changeset
1472 }
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1473 }
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1474
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
1475 void macroDebugShowResult( var_uint_t index )
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1476 {
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1477 // Only proceed if the macro exists
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1478 if ( index >= ResultMacroNum )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1479 return;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1480
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1481 // Trigger Macro Show
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
1482 const ResultMacro *macro = &ResultMacroList[ index ];
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
1483 ResultMacroRecord *record = &ResultMacroRecordList[ index ];
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1484
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1485 print( NL );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1486 info_msg("Result Macro Index: ");
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1487 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
1488 print( NL );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1489
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1490 // 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
1491 var_uint_t pos = 0;
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1492 uint8_t comboLength = macro->guide[ pos++ ];
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1493
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1494 // Iterate through and interpret the guide
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1495 while ( comboLength != 0 )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1496 {
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1497 // 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
1498 var_uint_t funcCount = 0;
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1499
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1500 // Iterate through the combo
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1501 while ( funcCount < comboLength )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1502 {
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1503 // Assign TriggerGuide element (key type, state and scancode)
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1504 ResultGuide *guide = (ResultGuide*)(&macro->guide[ pos ]);
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1505
180
ed56f7873645 Added capabilities list debug option
Jacob Alexander <haata@kiibohd.com>
parents: 179
diff changeset
1506 // Display Function Index
ed56f7873645 Added capabilities list debug option
Jacob Alexander <haata@kiibohd.com>
parents: 179
diff changeset
1507 printHex( guide->index );
ed56f7873645 Added capabilities list debug option
Jacob Alexander <haata@kiibohd.com>
parents: 179
diff changeset
1508 print("|");
ed56f7873645 Added capabilities list debug option
Jacob Alexander <haata@kiibohd.com>
parents: 179
diff changeset
1509
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1510 // Display Function Ptr Address
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
1511 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
1512 print("|");
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1513
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1514 // 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
1515 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
1516 capability( 0xFF, 0xFF, 0 );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1517
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1518 // Display Argument(s)
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1519 print("(");
204
b718fdb741c3 Updating PartialLayer code to support varying counter widths.
Jacob Alexander <haata@kiibohd.com>
parents: 202
diff changeset
1520 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
1521 {
180
ed56f7873645 Added capabilities list debug option
Jacob Alexander <haata@kiibohd.com>
parents: 179
diff changeset
1522 // Arguments are only 8 bit values
ed56f7873645 Added capabilities list debug option
Jacob Alexander <haata@kiibohd.com>
parents: 179
diff changeset
1523 printHex( (&guide->args)[ arg ] );
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1524
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1525 // 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
1526 if ( arg + 1 < CapabilitiesList[ guide->index ].argCount )
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1527 print(",");
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1528 }
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1529 print(")");
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1530
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1531 // Increment position
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1532 pos += ResultGuideSize( guide );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1533
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1534 // Increment function count
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1535 funcCount++;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1536
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1537 // 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
1538 if ( funcCount < comboLength )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1539 print("+");
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1540 }
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1541
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1542 // Read the next comboLength
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1543 comboLength = macro->guide[ pos++ ];
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1544
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1545 // 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
1546 if ( comboLength != 0 )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1547 print(";");
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1548 }
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1549
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1550 // Display current position
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1551 print( NL "Position: " );
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
1552 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
1553
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1554 // Display final trigger state/type
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1555 print( NL "Final Trigger State (State/Type): " );
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
1556 printHex( record->state );
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1557 print("/");
217
8ceb1a0582ee Adding more RAM optimizations
Jacob Alexander <haata@kiibohd.com>
parents: 216
diff changeset
1558 printHex( record->stateType );
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1559 }
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1560
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1561 void cliFunc_macroShow( char* args )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1562 {
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1563 // Parse codes from arguments
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1564 char* curArgs;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1565 char* arg1Ptr;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1566 char* arg2Ptr = args;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1567
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1568 // Process all args
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1569 for ( ;; )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1570 {
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1571 curArgs = arg2Ptr;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1572 CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1573
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1574 // Stop processing args if no more are found
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1575 if ( *arg1Ptr == '\0' )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1576 break;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1577
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1578 // Ignore invalid codes
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1579 switch ( arg1Ptr[0] )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1580 {
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1581 // Indexed Trigger Macro
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1582 case 'T':
195
58cfcb7bac88 Changing decToInt to numToInt (adds support for Hex number interpreter)
Jacob Alexander <haata@kiibohd.com>
parents: 192
diff changeset
1583 macroDebugShowTrigger( numToInt( &arg1Ptr[1] ) );
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1584 break;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1585 // Indexed Result Macro
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1586 case 'R':
195
58cfcb7bac88 Changing decToInt to numToInt (adds support for Hex number interpreter)
Jacob Alexander <haata@kiibohd.com>
parents: 192
diff changeset
1587 macroDebugShowResult( numToInt( &arg1Ptr[1] ) );
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1588 break;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1589 }
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1590 }
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1591 }
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1592
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1593 void cliFunc_macroStep( char* args )
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1594 {
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1595 // Parse number from argument
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1596 // NOTE: Only first argument is used
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1597 char* arg1Ptr;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1598 char* arg2Ptr;
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1599 CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr );
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1600
192
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1601 // 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
1602 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
1603
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1604 if ( count == 0 )
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1605 count = 1;
6ac92b8614c0 Fixing RAM calculator and reduced actual SRAM usage
Jacob Alexander <haata@kiibohd.com>
parents: 191
diff changeset
1606
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1607 // 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
1608 macroStepCounter = count;
179
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1609 }
e5cf79b516e4 Basic debug trigger/result macro viewer
Jacob Alexander <haata@kiibohd.com>
parents: 176
diff changeset
1610