12 #define Kdebug(s) do { if (debug_keyboard) debug(s); } while(0)
13 #define Kdebug_P(s) do { if (debug_keyboard) debug_P(s); } while(0)
14 #define Kdebug_hex(s) do { if (debug_keyboard) debug_hex(s); } while(0)
19 * Event/State|IDLE PRESSING DELAYING[f] WAITING[f,k]
20 * -----------+------------------------------------------------------------------
21 * Fn Down |(L+) -*1 WAITING(Sk) IDLE(Rf,Ps)*7
22 * Up |(L-) IDLE(L-)*8 IDLE(L-)*8 IDLE(L-)*8
23 * Fnk Down |DELAYING(Sf)* (Rf) WAITING(Sk) IDLE(Rf,Ps,Rf)
24 * Up |(L-) IDLE(L-/Uf)*8 IDLE(Rf,Uf/L-)*3 IDLE(Rf,Ps,Uf/L-)*3
25 * Key Down |PRESSING(Rk) (Rk) WAITING(Sk) IDLE(Rf,Ps,Rk)
26 * Up |(Uk) IDLE(Uk)*4 (Uk) IDLE(L+,Ps,Pk)/(Uk)*a
28 * Delay |- - IDLE(L+) IDLE(L+,Ps)
29 * Magic Key |COMMAND*5
31 * *1: ignore Fn if other key is down.
32 * *2: register Fnk if any key is pressing
33 * *3: register/unregister delayed Fnk and move to IDLE if code == delayed Fnk, else *8
34 * *4: if no keys registered to host
35 * *5: unregister all keys
36 * *6: only if no keys down
37 * *7: ignore Fn because Fnk key and stored key are down.
38 * *8: move to IDLE if layer switch(off) occurs, else stay at current state
39 * *9: repeat key if pressing Fnk twice quickly(move to PRESSING)
40 * *a: layer switch and process waiting key and code if code == wainting key, else unregister key
43 * IDLE: No key is down except modifiers
44 * DELAYING: delay layer switch after pressing Fn with alt keycode
45 * WAITING: key is pressed during DELAYING
48 * Fn: Fn key without alternative keycode
49 * Fnk: Fn key with alternative keycode
51 * Delay: layer switch delay term is elapsed
56 * Rf: register Fn(alt keycode)
57 * Uf: unregister Fn(alt keycode)
58 * Rs: register stored key
59 * Us: unregister stored key
60 * Sk: Store key(waiting Key)
61 * Sf: Store Fn(delayed Fn)
62 * Ps: Process stored key
64 * Is: Interpret stored keys in current layer
65 * L+: Switch to new layer(*unregister* all keys but modifiers)
66 * L-: Switch back to last layer(*unregister* all keys but modifiers)
67 * Ld: Switch back to default layer(*unregister* all keys but modifiers)
71 typedef enum { IDLE, DELAYING, WAITING, PRESSING } kbdstate_t;
72 #define NEXT(state) do { \
73 Kdebug("NEXT: "); Kdebug_P(state_str(kbdstate)); \
75 Kdebug(" -> "); Kdebug_P(state_str(kbdstate)); Kdebug("\n"); \
79 static kbdstate_t kbdstate = IDLE;
80 static uint8_t fn_state_bits = 0;
81 static keyrecord_t delayed_fn = {};
82 static keyrecord_t waiting_key = {};
84 static const char *state_str(kbdstate_t state)
86 if (state == IDLE) return PSTR("IDLE");
87 if (state == DELAYING) return PSTR("DELAYING");
88 if (state == WAITING) return PSTR("WAITING");
89 if (state == PRESSING) return PSTR("PRESSING");
90 return PSTR("UNKNOWN");
92 static bool anykey_sent_to_host(void)
94 return (host_has_anykey() || host_mouse_in_use() ||
95 host_last_sysytem_report() || host_last_consumer_report());
101 static void layer_switch_on(uint8_t code);
102 static void layer_switch_off(uint8_t code);
103 static void key_action(uint8_t code, keyevent_t event);
104 static void key_pressed(uint8_t code, keyevent_t event);
105 static void key_released(uint8_t code, keyevent_t event);
106 static void mod_pressed(uint8_t code, keyevent_t event);
107 static void mod_released(uint8_t code, keyevent_t event);
110 static void register_code(uint8_t code);
111 static void unregister_code(uint8_t code);
112 static void register_mods(uint8_t mods);
113 static void unregister_mods(uint8_t mods);
114 static void clear_keyboard(void);
115 static void clear_keyboard_but_mods(void);
116 static void layer_switch(uint8_t new_layer);
121 static keyevent_t last_event = {};
122 static uint16_t last_event_time = 0;
123 static uint8_t tap_count = 0;
126 uint8_t default_layer = 0;
127 uint8_t current_layer = 0;
128 uint8_t waiting_layer = 0;
131 void action_exec(action_t action, keyevent_t event)
133 /* count tap when key is up */
134 if (KEYEQ(event.key, last_event.key) && timer_elapsed(last_event_time) < TAP_TIME) {
135 if (!event.pressed) tap_count++;
140 debug("action: "); debug_hex16(action.code); debug("\n");
141 debug("kind.id: "); debug_hex(action.kind.id); debug("\n");
142 debug("kind.param: "); debug_hex16(action.kind.param); debug("\n");
143 debug("key.code: "); debug_hex(action.key.code); debug("\n");
144 debug("key.mods: "); debug_hex(action.key.mods); debug("\n");
146 switch (action.kind.id) {
149 register_mods(action.key.mods);
150 register_code(action.key.code);
152 unregister_code(action.key.code);
153 unregister_mods(action.key.mods);
158 register_mods(action.key.mods<<4);
159 register_code(action.key.code);
161 unregister_code(action.key.code);
162 unregister_mods(action.key.mods<<4);
166 switch (action.layer_key.code) {
167 case 0x00: // Momentary switch
168 // TODO: history of layer switch
170 layer_switch(action.layer_key.layer);
172 layer_switch(default_layer);
175 case 0x01: // Oneshot switch
178 case 0x02: // reserved
179 case 0x03: // reserved
181 case 0xF0 ... 0xF7: // Tap to enable/disable
182 case 0xF8 ... 0xFF: // Tap to toggle layer
185 default: // with keycode for tap
186 debug("tap: "); debug_hex(tap_count); debug("\n");
187 // TODO: layer switch
188 // TODO: in case tap is interrupted by other key
193 if (host_has_anykey()) {
195 register_code(action.layer_key.code);
199 if (tap_count == 0) {
200 if (host_has_anykey()) {
201 register_code(action.layer_key.code);
203 waiting_layer = action.layer_key.layer;
206 // register key when press after a tap
208 register_code(action.layer_key.code);
211 // type key after tap
212 if (tap_count == 1) {
213 register_code(action.layer_key.code);
215 unregister_code(action.layer_key.code);
221 #ifdef EXTRAKEY_ENABLE
222 switch (action.usage.page) {
223 case ACTION_USAGE_PAGE_SYSTEM:
225 host_system_send(action.usage.code);
230 case ACTION_USAGE_PAGE_CONSUMER:
232 host_consumer_send(action.usage.code);
234 host_consumer_send(0);
241 #ifdef MOUSEKEY_ENABLE
243 mousekey_on(action.key.code);
246 mousekey_off(action.key.code);
262 last_event_time = timer_read();
269 static void key_action(uint8_t code, keyevent_t event)
272 key_pressed(code, event);
274 key_released(code, event);
277 void fn_action(uint8_t code, keyevent_t event)
282 inline static void key_pressed(uint8_t code, keyevent_t event)
294 waiting_key = (keyrecord_t) {
297 .mods = keyboard_report->mods,
303 // play back key stroke
304 tmp_mods = keyboard_report->mods;
305 host_set_mods(delayed_fn.mods);
306 register_code(delayed_fn.code);
307 host_set_mods(waiting_key.mods);
308 register_code(waiting_key.code);
309 host_set_mods(tmp_mods);
315 inline static void key_released(uint8_t code, keyevent_t event)
320 unregister_code(code);
323 unregister_code(code);
324 if (!anykey_sent_to_host())
328 unregister_code(code);
331 if (code == waiting_key.code) {
332 layer_switch_on(delayed_fn.code);
334 // process waiting_key
335 tmp_mods = keyboard_report->mods;
336 host_set_mods(waiting_key.mods);
337 keymap_process_event(waiting_key.event);
338 host_set_mods(tmp_mods);
339 keymap_process_event(event);
341 unregister_code(code);
347 /* layer switch momentary */
348 inline static void layerkey_pressed(uint8_t code, keyevent_t event)
353 layer_switch_on(code);
359 waiting_key = (keyrecord_t) {
362 .mods = keyboard_report->mods,
368 tmp_mods = keyboard_report->mods;
369 host_set_mods(delayed_fn.mods);
370 register_code(delayed_fn.code);
371 host_set_mods(waiting_key.mods);
372 register_code(waiting_key.code);
373 host_set_mods(tmp_mods);
374 if (kind == FN_DOWN) {
376 } else if (kind == FNK_DOWN) {
378 } else if (kind == KEY_DOWN) {
385 inline static void layerkey_released(uint8_t code, keyevent_t event)
389 layer_switch_off(code);
394 if (layer_switch_off(code))
402 static void register_code(uint8_t code)
407 else if IS_KEY(code) {
408 // TODO: should push command_proc out of this block?
409 if (!command_proc(code)) {
411 host_send_keyboard_report();
414 else if IS_MOD(code) {
415 host_add_mods(MOD_BIT(code));
416 host_send_keyboard_report();
418 #ifdef MOUSEKEY_ENABLE
419 else if IS_MOUSEKEY(code) {
424 #ifdef EXTRAKEY_ENABLE
425 else if IS_CONSUMER(code) {
431 case KC_AUDIO_VOL_UP:
432 usage = AUDIO_VOL_UP;
434 case KC_AUDIO_VOL_DOWN:
435 usage = AUDIO_VOL_DOWN;
437 case KC_MEDIA_NEXT_TRACK:
438 usage = TRANSPORT_NEXT_TRACK;
440 case KC_MEDIA_PREV_TRACK:
441 usage = TRANSPORT_PREV_TRACK;
444 usage = TRANSPORT_STOP;
446 case KC_MEDIA_PLAY_PAUSE:
447 usage = TRANSPORT_PLAY_PAUSE;
449 case KC_MEDIA_SELECT:
450 usage = AL_CC_CONFIG;
456 usage = AL_CALCULATOR;
459 usage = AL_LOCAL_BROWSER;
479 case KC_WWW_FAVORITES:
480 usage = AC_BOOKMARKS;
483 host_consumer_send(usage);
485 else if IS_SYSTEM(code) {
488 case KC_SYSTEM_POWER:
489 usage = SYSTEM_POWER_DOWN;
491 case KC_SYSTEM_SLEEP:
492 usage = SYSTEM_SLEEP;
495 usage = SYSTEM_WAKE_UP;
498 host_system_send(usage);
503 static void unregister_code(uint8_t code)
507 host_send_keyboard_report();
509 else if IS_MOD(code) {
510 host_del_mods(MOD_BIT(code));
511 host_send_keyboard_report();
513 #ifdef MOUSEKEY_ENABLE
514 else if IS_MOUSEKEY(code) {
519 #ifdef EXTRAKEY_ENABLE
520 else if IS_CONSUMER(code) {
521 host_consumer_send(0x0000);
523 else if IS_SYSTEM(code) {
524 host_system_send(0x0000);
529 static void register_mods(uint8_t mods)
533 host_send_keyboard_report();
536 static void unregister_mods(uint8_t mods)
540 host_send_keyboard_report();
543 static void clear_keyboard(void)
546 clear_keyboard_but_mods();
549 static void clear_keyboard_but_mods(void)
552 host_send_keyboard_report();
553 #ifdef MOUSEKEY_ENABLE
557 #ifdef EXTRAKEY_ENABLE
559 host_consumer_send(0);
563 static void layer_switch(uint8_t new_layer)
565 if (current_layer != new_layer) {
566 Kdebug("Layer Switch: "); Kdebug_hex(current_layer);
567 Kdebug(" -> "); Kdebug_hex(new_layer); Kdebug("\n");
569 current_layer = new_layer;
570 clear_keyboard_but_mods(); // To avoid stuck keys