HCoop / jackhill / qmk / firmware.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
adds planck light keyboard
[jackhill/qmk/firmware.git] / quantum / quantum.c
CommitLineData
23839b8c 1/* Copyright 2016-2017 Jack Humbert
2 *
3 * This program is free software: you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation, either version 2 of the License, or
6 * (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program. If not, see <http://www.gnu.org/licenses/>.
15 */
16
1a8c0dd2 17#include "quantum.h"
e7c4f621 18#ifdef PROTOCOL_LUFA
c17070ec 19#include "outputselect.h"
2bef8b5b 20#endif
1a8c0dd2 21
74a1f007
GN		 22#ifndef TAPPING_TERM
23#define TAPPING_TERM 200
24#endif
25
8d0fdf10
JH		 26#include "backlight.h"
27extern backlight_config_t backlight_config;
db1e9a46 28
8c93c5d9
PIN		 29#ifdef FAUXCLICKY_ENABLE
30#include "fauxclicky.h"
31#endif
8d0fdf10 32
6a3c6677
JH		 33#ifdef AUDIO_ENABLE
34 #ifndef GOODBYE_SONG
35 #define GOODBYE_SONG SONG(GOODBYE_SOUND)
36 #endif
37 #ifndef AG_NORM_SONG
38 #define AG_NORM_SONG SONG(AG_NORM_SOUND)
39 #endif
40 #ifndef AG_SWAP_SONG
41 #define AG_SWAP_SONG SONG(AG_SWAP_SOUND)
42 #endif
6a3c6677
JH		 43 float goodbye_song[][2] = GOODBYE_SONG;
44 float ag_norm_song[][2] = AG_NORM_SONG;
45 float ag_swap_song[][2] = AG_SWAP_SONG;
6895c451
JH		 46 #ifdef DEFAULT_LAYER_SONGS
47 float default_layer_songs[][16][2] = DEFAULT_LAYER_SONGS;
48 #endif
6a3c6677
JH		 49#endif
50
0d28787c
GN		 51static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
52 switch (code) {
53 case QK_MODS ... QK_MODS_MAX:
54 break;
55 default:
56 return;
57 }
58
59 if (code & QK_LCTL)
60 f(KC_LCTL);
61 if (code & QK_LSFT)
62 f(KC_LSFT);
63 if (code & QK_LALT)
64 f(KC_LALT);
65 if (code & QK_LGUI)
66 f(KC_LGUI);
67
01038ab5
OP		 68 if (code < QK_RMODS_MIN) return;
69
0d28787c
GN		 70 if (code & QK_RCTL)
71 f(KC_RCTL);
72 if (code & QK_RSFT)
73 f(KC_RSFT);
74 if (code & QK_RALT)
75 f(KC_RALT);
76 if (code & QK_RGUI)
77 f(KC_RGUI);
78}
79
f644b9a0
S		 80static inline void qk_register_weak_mods(uint8_t kc) {
81 add_weak_mods(MOD_BIT(kc));
82 send_keyboard_report();
83}
84
85static inline void qk_unregister_weak_mods(uint8_t kc) {
86 del_weak_mods(MOD_BIT(kc));
87 send_keyboard_report();
88}
89
2b385993 90static inline void qk_register_mods(uint8_t kc) {
f644b9a0
S		 91 add_weak_mods(MOD_BIT(kc));
92 send_keyboard_report();
2b385993
S		 93}
94
95static inline void qk_unregister_mods(uint8_t kc) {
f644b9a0
S		 96 del_weak_mods(MOD_BIT(kc));
97 send_keyboard_report();
2b385993
S		 98}
99
0d28787c 100void register_code16 (uint16_t code) {
f644b9a0
S		 101 if (IS_MOD(code) || code == KC_NO) {
102 do_code16 (code, qk_register_mods);
103 } else {
104 do_code16 (code, qk_register_weak_mods);
105 }
0d28787c
GN		 106 register_code (code);
107}
108
109void unregister_code16 (uint16_t code) {
110 unregister_code (code);
f644b9a0
S		 111 if (IS_MOD(code) || code == KC_NO) {
112 do_code16 (code, qk_unregister_mods);
113 } else {
114 do_code16 (code, qk_unregister_weak_mods);
115 }
0d28787c
GN		 116}
117
1a8c0dd2 118__attribute__ ((weak))
1a8c0dd2
EZ		 119bool process_action_kb(keyrecord_t *record) {
120 return true;
121}
122
17977a7e
JH		 123__attribute__ ((weak))
124bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
125 return process_record_user(keycode, record);
126}
127
128__attribute__ ((weak))
129bool process_record_user(uint16_t keycode, keyrecord_t *record) {
130 return true;
131}
132
a28a6e5b
PV		 133void reset_keyboard(void) {
134 clear_keyboard();
a64ae106
GY		 135#if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_ENABLE_BASIC))
136 music_all_notes_off();
6a3c6677
JH		 137 uint16_t timer_start = timer_read();
138 PLAY_SONG(goodbye_song);
a28a6e5b 139 shutdown_user();
6a3c6677
JH		 140 while(timer_elapsed(timer_start) < 250)
141 wait_ms(1);
142 stop_all_notes();
143#else
a28a6e5b 144 wait_ms(250);
6a3c6677 145#endif
a28a6e5b
PV		 146#ifdef CATERINA_BOOTLOADER
147 *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
148#endif
149 bootloader_jump();
150}
151
b70248fa
JH		 152// Shift / paren setup
153
154#ifndef LSPO_KEY
155 #define LSPO_KEY KC_9
156#endif
157#ifndef RSPC_KEY
158 #define RSPC_KEY KC_0
159#endif
160
8bc69afc 161static bool shift_interrupted[2] = {0, 0};
de52bd5d 162static uint16_t scs_timer[2] = {0, 0};
12370259 163
b4be711a
BG		 164/* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
165 * Used to ensure that the correct keycode is released if the key is released.
166 */
167static bool grave_esc_was_shifted = false;
168
bf5c2cce 169bool process_record_quantum(keyrecord_t *record) {
1a8c0dd2
EZ		 170
171 /* This gets the keycode from the key pressed */
172 keypos_t key = record->event.key;
173 uint16_t keycode;
174
175 #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
644c8c79
WS		 176 /* TODO: Use store_or_get_action() or a similar function. */
177 if (!disable_action_cache) {
178 uint8_t layer;
1a8c0dd2 179
644c8c79
WS		 180 if (record->event.pressed) {
181 layer = layer_switch_get_layer(key);
182 update_source_layers_cache(key, layer);
183 } else {
184 layer = read_source_layers_cache(key);
185 }
186 keycode = keymap_key_to_keycode(layer, key);
187 } else
1a8c0dd2 188 #endif
644c8c79 189 keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
1a8c0dd2 190
bf5c2cce
JH		 191 // This is how you use actions here
192 // if (keycode == KC_LEAD) {
193 // action_t action;
194 // action.code = ACTION_DEFAULT_LAYER_SET(0);
195 // process_action(record, action);
196 // return false;
197 // }
198
65faab3b 199 if (!(
8e1be7c7
FS		 200 #if defined(KEY_LOCK_ENABLE)
201 // Must run first to be able to mask key_up events.
a3e1d9a8 202 process_key_lock(&keycode, record) &&
8e1be7c7 203 #endif
65faab3b 204 process_record_kb(keycode, record) &&
525be99e 205 #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
65faab3b 206 process_midi(keycode, record) &&
fde477a9 207 #endif
1a8c0dd2 208 #ifdef AUDIO_ENABLE
1000799d
GY		 209 process_audio(keycode, record) &&
210 #endif
5987f679
JW		 211 #ifdef STENO_ENABLE
212 process_steno(keycode, record) &&
213 #endif
525be99e 214 #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
65faab3b 215 process_music(keycode, record) &&
1a8c0dd2 216 #endif
65faab3b
JH		 217 #ifdef TAP_DANCE_ENABLE
218 process_tap_dance(keycode, record) &&
219 #endif
220 #ifndef DISABLE_LEADER
221 process_leader(keycode, record) &&
222 #endif
223 #ifndef DISABLE_CHORDING
224 process_chording(keycode, record) &&
225 #endif
40abf8bc
OP		 226 #ifdef COMBO_ENABLE
227 process_combo(keycode, record) &&
228 #endif
65faab3b
JH		 229 #ifdef UNICODE_ENABLE
230 process_unicode(keycode, record) &&
857aa5be
GN		 231 #endif
232 #ifdef UCIS_ENABLE
233 process_ucis(keycode, record) &&
5f91fb41
JH		 234 #endif
235 #ifdef PRINTING_ENABLE
236 process_printer(keycode, record) &&
e9f74875 237 #endif
abba393f
JC		 238 #ifdef AUTO_SHIFT_ENABLE
239 process_auto_shift(keycode, record) &&
240 #endif
5b2e455d
PIN		 241 #ifdef UNICODEMAP_ENABLE
242 process_unicode_map(keycode, record) &&
7ad924ba
JH		 243 #endif
244 #ifdef TERMINAL_ENABLE
245 process_terminal(keycode, record) &&
65faab3b
JH		 246 #endif
247 true)) {
248 return false;
b732b79b
JH		 249 }
250
b70248fa
JH		 251 // Shift / paren setup
252
12370259 253 switch(keycode) {
db32864c
JH		 254 case RESET:
255 if (record->event.pressed) {
a28a6e5b 256 reset_keyboard();
db32864c 257 }
4580d3a7 258 return false;
db32864c
JH		 259 case DEBUG:
260 if (record->event.pressed) {
db32864c 261 debug_enable = true;
4d5eeb3d 262 print("DEBUG: enabled.\n");
db32864c 263 }
4580d3a7 264 return false;
8c93c5d9
PIN		 265 #ifdef FAUXCLICKY_ENABLE
266 case FC_TOG:
267 if (record->event.pressed) {
268 FAUXCLICKY_TOGGLE;
269 }
270 return false;
8c93c5d9
PIN		 271 case FC_ON:
272 if (record->event.pressed) {
273 FAUXCLICKY_ON;
274 }
275 return false;
8c93c5d9
PIN		 276 case FC_OFF:
277 if (record->event.pressed) {
278 FAUXCLICKY_OFF;
279 }
280 return false;
8c93c5d9 281 #endif
4580d3a7 282 #ifdef RGBLIGHT_ENABLE
283 case RGB_TOG:
284 if (record->event.pressed) {
285 rgblight_toggle();
286 }
287 return false;
288 case RGB_MOD:
289 if (record->event.pressed) {
290 rgblight_step();
291 }
292 return false;
1f434959
SK		 293 case RGB_SMOD:
294 // same as RBG_MOD, but if shift is pressed, it will use the reverese direction instead.
295 if (record->event.pressed) {
296 uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
297 if(shifted) {
298 rgblight_step_reverse();
299 }
300 else {
301 rgblight_step();
302 }
303 }
304 return false;
4580d3a7 305 case RGB_HUI:
306 if (record->event.pressed) {
307 rgblight_increase_hue();
308 }
309 return false;
310 case RGB_HUD:
311 if (record->event.pressed) {
312 rgblight_decrease_hue();
313 }
314 return false;
315 case RGB_SAI:
316 if (record->event.pressed) {
317 rgblight_increase_sat();
318 }
319 return false;
320 case RGB_SAD:
321 if (record->event.pressed) {
322 rgblight_decrease_sat();
323 }
324 return false;
325 case RGB_VAI:
326 if (record->event.pressed) {
327 rgblight_increase_val();
328 }
329 return false;
330 case RGB_VAD:
331 if (record->event.pressed) {
332 rgblight_decrease_val();
333 }
334 return false;
335 case RGB_MODE_PLAIN:
336 if (record->event.pressed) {
337 rgblight_mode(1);
338 }
339 return false;
340 case RGB_MODE_BREATHE:
341 if (record->event.pressed) {
342 if ((2 <= rgblight_get_mode()) && (rgblight_get_mode() < 5)) {
343 rgblight_step();
344 } else {
345 rgblight_mode(2);
f7a86822 346 }
4580d3a7 347 }
348 return false;
349 case RGB_MODE_RAINBOW:
350 if (record->event.pressed) {
351 if ((6 <= rgblight_get_mode()) && (rgblight_get_mode() < 8)) {
352 rgblight_step();
353 } else {
354 rgblight_mode(6);
f7a86822 355 }
4580d3a7 356 }
357 return false;
358 case RGB_MODE_SWIRL:
359 if (record->event.pressed) {
360 if ((9 <= rgblight_get_mode()) && (rgblight_get_mode() < 14)) {
361 rgblight_step();
362 } else {
363 rgblight_mode(9);
f7a86822 364 }
4580d3a7 365 }
366 return false;
367 case RGB_MODE_SNAKE:
368 if (record->event.pressed) {
369 if ((15 <= rgblight_get_mode()) && (rgblight_get_mode() < 20)) {
370 rgblight_step();
371 } else {
372 rgblight_mode(15);
f7a86822 373 }
4580d3a7 374 }
375 return false;
376 case RGB_MODE_KNIGHT:
377 if (record->event.pressed) {
378 if ((21 <= rgblight_get_mode()) && (rgblight_get_mode() < 23)) {
379 rgblight_step();
380 } else {
381 rgblight_mode(21);
f7a86822 382 }
4580d3a7 383 }
384 return false;
385 case RGB_MODE_XMAS:
386 if (record->event.pressed) {
387 rgblight_mode(24);
388 }
389 return false;
390 case RGB_MODE_GRADIENT:
391 if (record->event.pressed) {
392 if ((25 <= rgblight_get_mode()) && (rgblight_get_mode() < 34)) {
393 rgblight_step();
394 } else {
395 rgblight_mode(25);
f7a86822 396 }
4580d3a7 397 }
398 return false;
399 #endif
e7c4f621 400 #ifdef PROTOCOL_LUFA
c17070ec
PIN		 401 case OUT_AUTO:
402 if (record->event.pressed) {
403 set_output(OUTPUT_AUTO);
404 }
405 return false;
c17070ec
PIN		 406 case OUT_USB:
407 if (record->event.pressed) {
408 set_output(OUTPUT_USB);
409 }
410 return false;
c17070ec
PIN		 411 #ifdef BLUETOOTH_ENABLE
412 case OUT_BT:
413 if (record->event.pressed) {
414 set_output(OUTPUT_BLUETOOTH);
415 }
416 return false;
c17070ec 417 #endif
2bef8b5b 418 #endif
558f3ec1 419 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
db32864c
JH		 420 if (record->event.pressed) {
421 // MAGIC actions (BOOTMAGIC without the boot)
422 if (!eeconfig_is_enabled()) {
423 eeconfig_init();
424 }
425 /* keymap config */
426 keymap_config.raw = eeconfig_read_keymap();
558f3ec1
I		 427 switch (keycode)
428 {
429 case MAGIC_SWAP_CONTROL_CAPSLOCK:
430 keymap_config.swap_control_capslock = true;
431 break;
432 case MAGIC_CAPSLOCK_TO_CONTROL:
433 keymap_config.capslock_to_control = true;
434 break;
435 case MAGIC_SWAP_LALT_LGUI:
436 keymap_config.swap_lalt_lgui = true;
437 break;
438 case MAGIC_SWAP_RALT_RGUI:
439 keymap_config.swap_ralt_rgui = true;
440 break;
441 case MAGIC_NO_GUI:
442 keymap_config.no_gui = true;
443 break;
444 case MAGIC_SWAP_GRAVE_ESC:
445 keymap_config.swap_grave_esc = true;
446 break;
447 case MAGIC_SWAP_BACKSLASH_BACKSPACE:
448 keymap_config.swap_backslash_backspace = true;
449 break;
450 case MAGIC_HOST_NKRO:
451 keymap_config.nkro = true;
452 break;
453 case MAGIC_SWAP_ALT_GUI:
454 keymap_config.swap_lalt_lgui = true;
455 keymap_config.swap_ralt_rgui = true;
6a3c6677
JH		 456 #ifdef AUDIO_ENABLE
457 PLAY_SONG(ag_swap_song);
458 #endif
558f3ec1
I		 459 break;
460 case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
461 keymap_config.swap_control_capslock = false;
462 break;
463 case MAGIC_UNCAPSLOCK_TO_CONTROL:
464 keymap_config.capslock_to_control = false;
465 break;
466 case MAGIC_UNSWAP_LALT_LGUI:
467 keymap_config.swap_lalt_lgui = false;
468 break;
469 case MAGIC_UNSWAP_RALT_RGUI:
470 keymap_config.swap_ralt_rgui = false;
471 break;
472 case MAGIC_UNNO_GUI:
473 keymap_config.no_gui = false;
474 break;
475 case MAGIC_UNSWAP_GRAVE_ESC:
476 keymap_config.swap_grave_esc = false;
477 break;
478 case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
479 keymap_config.swap_backslash_backspace = false;
480 break;
481 case MAGIC_UNHOST_NKRO:
482 keymap_config.nkro = false;
483 break;
484 case MAGIC_UNSWAP_ALT_GUI:
485 keymap_config.swap_lalt_lgui = false;
486 keymap_config.swap_ralt_rgui = false;
6a3c6677
JH		 487 #ifdef AUDIO_ENABLE
488 PLAY_SONG(ag_norm_song);
489 #endif
558f3ec1
I		 490 break;
491 case MAGIC_TOGGLE_NKRO:
492 keymap_config.nkro = !keymap_config.nkro;
493 break;
494 default:
495 break;
db32864c
JH		 496 }
497 eeconfig_update_keymap(keymap_config.raw);
558f3ec1
I		 498 clear_keyboard(); // clear to prevent stuck keys
499
db32864c
JH		 500 return false;
501 }
502 break;
12370259 503 case KC_LSPO: {
db32864c
JH		 504 if (record->event.pressed) {
505 shift_interrupted[0] = false;
de52bd5d 506 scs_timer[0] = timer_read ();
76076db7 507 register_mods(MOD_BIT(KC_LSFT));
db32864c
JH		 508 }
509 else {
b12fe6ab
S		 510 #ifdef DISABLE_SPACE_CADET_ROLLOVER
511 if (get_mods() & MOD_BIT(KC_RSFT)) {
512 shift_interrupted[0] = true;
513 shift_interrupted[1] = true;
514 }
515 #endif
de52bd5d 516 if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
db32864c
JH		 517 register_code(LSPO_KEY);
518 unregister_code(LSPO_KEY);
519 }
76076db7 520 unregister_mods(MOD_BIT(KC_LSFT));
db32864c
JH		 521 }
522 return false;
db32864c 523 }
12370259
EZ		 524
525 case KC_RSPC: {
db32864c
JH		 526 if (record->event.pressed) {
527 shift_interrupted[1] = false;
de52bd5d 528 scs_timer[1] = timer_read ();
76076db7 529 register_mods(MOD_BIT(KC_RSFT));
db32864c
JH		 530 }
531 else {
b12fe6ab
S		 532 #ifdef DISABLE_SPACE_CADET_ROLLOVER
533 if (get_mods() & MOD_BIT(KC_LSFT)) {
534 shift_interrupted[0] = true;
535 shift_interrupted[1] = true;
536 }
537 #endif
de52bd5d 538 if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
db32864c
JH		 539 register_code(RSPC_KEY);
540 unregister_code(RSPC_KEY);
541 }
76076db7 542 unregister_mods(MOD_BIT(KC_RSFT));
db32864c
JH		 543 }
544 return false;
db32864c 545 }
98316ef0 546 case GRAVE_ESC: {
98316ef0 547 uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
548 |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
b4be711a 549
897ceac2 550#ifdef GRAVE_ESC_CTRL_OVERRIDE
188ed682
BG		 551 // if CTRL is pressed, ESC is always read as ESC, even if SHIFT or GUI is pressed.
552 // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
897ceac2
BG		 553 if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL)))
554 shifted = 0;
555#endif
98316ef0 556
b4be711a
BG		 557 if (record->event.pressed) {
558 grave_esc_was_shifted = shifted;
559 add_key(shifted ? KC_GRAVE : KC_ESCAPE);
560 }
561 else {
562 del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
563 }
564
565 send_keyboard_report();
98316ef0 566 }
12370259 567 default: {
db32864c
JH		 568 shift_interrupted[0] = true;
569 shift_interrupted[1] = true;
570 break;
571 }
12370259
EZ		 572 }
573
1a8c0dd2
EZ		 574 return process_action_kb(record);
575}
576
48ff9358 577__attribute__ ((weak))
fdc2e805 578const bool ascii_to_shift_lut[0x80] PROGMEM = {
794aed37
ET		 579 0, 0, 0, 0, 0, 0, 0, 0,
580 0, 0, 0, 0, 0, 0, 0, 0,
581 0, 0, 0, 0, 0, 0, 0, 0,
582 0, 0, 0, 0, 0, 0, 0, 0,
583 0, 1, 1, 1, 1, 1, 1, 0,
584 1, 1, 1, 1, 0, 0, 0, 0,
585 0, 0, 0, 0, 0, 0, 0, 0,
586 0, 0, 1, 0, 1, 0, 1, 1,
587 1, 1, 1, 1, 1, 1, 1, 1,
588 1, 1, 1, 1, 1, 1, 1, 1,
589 1, 1, 1, 1, 1, 1, 1, 1,
590 1, 1, 1, 0, 0, 0, 1, 1,
591 0, 0, 0, 0, 0, 0, 0, 0,
592 0, 0, 0, 0, 0, 0, 0, 0,
593 0, 0, 0, 0, 0, 0, 0, 0,
594 0, 0, 0, 1, 1, 1, 1, 0
1c9f33c0
JH		 595};
596
48ff9358 597__attribute__ ((weak))
fdc2e805 598const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
794aed37
ET		 599 0, 0, 0, 0, 0, 0, 0, 0,
600 KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
601 0, 0, 0, 0, 0, 0, 0, 0,
602 0, 0, 0, KC_ESC, 0, 0, 0, 0,
603 KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
604 KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
605 KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
606 KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
607 KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
608 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
609 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
610 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
611 KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
612 KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
613 KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
614 KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
1c9f33c0
JH		 615};
616
5dae013f 617void send_string(const char *str) {
fdc2e805
SH		 618 send_string_with_delay(str, 0);
619}
620
7ad924ba
JH		 621void send_string_P(const char *str) {
622 send_string_with_delay_P(str, 0);
623}
624
fdc2e805 625void send_string_with_delay(const char *str, uint8_t interval) {
5dae013f 626 while (1) {
7ad924ba 627 char ascii_code = *str;
5dae013f 628 if (!ascii_code) break;
7ad924ba
JH		 629 if (ascii_code == 1) {
630 // tap
631 uint8_t keycode = *(++str);
632 register_code(keycode);
633 unregister_code(keycode);
634 } else if (ascii_code == 2) {
635 // down
636 uint8_t keycode = *(++str);
637 register_code(keycode);
638 } else if (ascii_code == 3) {
639 // up
640 uint8_t keycode = *(++str);
641 unregister_code(keycode);
642 } else {
643 send_char(ascii_code);
5dae013f 644 }
7ad924ba
JH		 645 ++str;
646 // interval
647 { uint8_t ms = interval; while (ms--) wait_ms(1); }
648 }
649}
650
651void send_string_with_delay_P(const char *str, uint8_t interval) {
652 while (1) {
653 char ascii_code = pgm_read_byte(str);
654 if (!ascii_code) break;
655 if (ascii_code == 1) {
656 // tap
657 uint8_t keycode = pgm_read_byte(++str);
658 register_code(keycode);
659 unregister_code(keycode);
660 } else if (ascii_code == 2) {
661 // down
662 uint8_t keycode = pgm_read_byte(++str);
663 register_code(keycode);
664 } else if (ascii_code == 3) {
665 // up
666 uint8_t keycode = pgm_read_byte(++str);
667 unregister_code(keycode);
668 } else {
669 send_char(ascii_code);
5dae013f 670 }
671 ++str;
fdc2e805
SH		 672 // interval
673 { uint8_t ms = interval; while (ms--) wait_ms(1); }
5dae013f 674 }
675}
676
7ad924ba
JH		 677void send_char(char ascii_code) {
678 uint8_t keycode;
679 keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
680 if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
681 register_code(KC_LSFT);
682 register_code(keycode);
683 unregister_code(keycode);
684 unregister_code(KC_LSFT);
685 } else {
686 register_code(keycode);
687 unregister_code(keycode);
688 }
689}
690
6a3c6677 691void set_single_persistent_default_layer(uint8_t default_layer) {
6895c451 692 #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
6a3c6677
JH		 693 PLAY_SONG(default_layer_songs[default_layer]);
694 #endif
695 eeconfig_update_default_layer(1U<<default_layer);
696 default_layer_set(1U<<default_layer);
697}
698
db32864c
JH		 699void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
700 if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
701 layer_on(layer3);
702 } else {
703 layer_off(layer3);
704 }
705}
1c9f33c0 706
197f152d 707void tap_random_base64(void) {
60fd885a
JH		 708 #if defined(__AVR_ATmega32U4__)
709 uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
710 #else
711 uint8_t key = rand() % 64;
712 #endif
197f152d
JH		 713 switch (key) {
714 case 0 ... 25:
715 register_code(KC_LSFT);
716 register_code(key + KC_A);
717 unregister_code(key + KC_A);
718 unregister_code(KC_LSFT);
719 break;
720 case 26 ... 51:
721 register_code(key - 26 + KC_A);
722 unregister_code(key - 26 + KC_A);
723 break;
724 case 52:
725 register_code(KC_0);
726 unregister_code(KC_0);
727 break;
728 case 53 ... 61:
729 register_code(key - 53 + KC_1);
730 unregister_code(key - 53 + KC_1);
731 break;
732 case 62:
733 register_code(KC_LSFT);
734 register_code(KC_EQL);
735 unregister_code(KC_EQL);
736 unregister_code(KC_LSFT);
737 break;
738 case 63:
739 register_code(KC_SLSH);
740 unregister_code(KC_SLSH);
741 break;
742 }
743}
744
1a8c0dd2 745void matrix_init_quantum() {
13bb6b4b
JH		 746 #ifdef BACKLIGHT_ENABLE
747 backlight_init_ports();
748 #endif
6a3c6677
JH		 749 #ifdef AUDIO_ENABLE
750 audio_init();
751 #endif
1a8c0dd2
EZ		 752 matrix_init_kb();
753}
754
755void matrix_scan_quantum() {
15719f35 756 #ifdef AUDIO_ENABLE
65faab3b 757 matrix_scan_music();
15719f35 758 #endif
fde477a9 759
65faab3b
JH		 760 #ifdef TAP_DANCE_ENABLE
761 matrix_scan_tap_dance();
762 #endif
b6bf4e0d
OP		 763
764 #ifdef COMBO_ENABLE
765 matrix_scan_combo();
766 #endif
767
8d0fdf10
JH		 768 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
769 backlight_task();
770 #endif
771
1a8c0dd2 772 matrix_scan_kb();
0428214b 773}
13bb6b4b 774
13bb6b4b
JH		 775#if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
776
777static const uint8_t backlight_pin = BACKLIGHT_PIN;
778
779#if BACKLIGHT_PIN == B7
780# define COM1x1 COM1C1
781# define OCR1x OCR1C
782#elif BACKLIGHT_PIN == B6
783# define COM1x1 COM1B1
784# define OCR1x OCR1B
785#elif BACKLIGHT_PIN == B5
786# define COM1x1 COM1A1
787# define OCR1x OCR1A
788#else
b4e30d39
JH		 789# define NO_BACKLIGHT_CLOCK
790#endif
791
792#ifndef BACKLIGHT_ON_STATE
793#define BACKLIGHT_ON_STATE 0
13bb6b4b
JH		 794#endif
795
796__attribute__ ((weak))
797void backlight_init_ports(void)
798{
799
b4e30d39 800 // Setup backlight pin as output and output to on state.
13bb6b4b
JH		 801 // DDRx |= n
802 _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
b4e30d39
JH		 803 #if BACKLIGHT_ON_STATE == 0
804 // PORTx &= ~n
805 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
806 #else
807 // PORTx |= n
808 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
809 #endif
13bb6b4b 810
b4e30d39
JH		 811 #ifndef NO_BACKLIGHT_CLOCK
812 // Use full 16-bit resolution.
813 ICR1 = 0xFFFF;
13bb6b4b 814
b4e30d39
JH		 815 // I could write a wall of text here to explain... but TL;DW
816 // Go read the ATmega32u4 datasheet.
817 // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
13bb6b4b 818
b4e30d39
JH		 819 // Pin PB7 = OCR1C (Timer 1, Channel C)
820 // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
821 // (i.e. start high, go low when counter matches.)
822 // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
823 // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
13bb6b4b 824
b4e30d39
JH		 825 TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
826 TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
827 #endif
13bb6b4b
JH		 828
829 backlight_init();
830 #ifdef BACKLIGHT_BREATHING
831 breathing_defaults();
832 #endif
833}
834
835__attribute__ ((weak))
836void backlight_set(uint8_t level)
837{
838 // Prevent backlight blink on lowest level
8d0fdf10
JH		 839 // #if BACKLIGHT_ON_STATE == 0
840 // // PORTx &= ~n
841 // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
842 // #else
843 // // PORTx |= n
844 // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
845 // #endif
13bb6b4b
JH		 846
847 if ( level == 0 ) {
b4e30d39
JH		 848 #ifndef NO_BACKLIGHT_CLOCK
849 // Turn off PWM control on backlight pin, revert to output low.
850 TCCR1A &= ~(_BV(COM1x1));
851 OCR1x = 0x0;
852 #else
8d0fdf10
JH		 853 // #if BACKLIGHT_ON_STATE == 0
854 // // PORTx |= n
855 // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
856 // #else
857 // // PORTx &= ~n
858 // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
859 // #endif
b4e30d39 860 #endif
5987f679 861 }
b4e30d39
JH		 862 #ifndef NO_BACKLIGHT_CLOCK
863 else if ( level == BACKLIGHT_LEVELS ) {
864 // Turn on PWM control of backlight pin
865 TCCR1A |= _BV(COM1x1);
866 // Set the brightness
867 OCR1x = 0xFFFF;
5987f679 868 }
b4e30d39
JH		 869 else {
870 // Turn on PWM control of backlight pin
871 TCCR1A |= _BV(COM1x1);
872 // Set the brightness
873 OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
874 }
875 #endif
13bb6b4b
JH		 876
877 #ifdef BACKLIGHT_BREATHING
878 breathing_intensity_default();
879 #endif
880}
881
8d0fdf10
JH		 882uint8_t backlight_tick = 0;
883
884void backlight_task(void) {
885 #ifdef NO_BACKLIGHT_CLOCK
5987f679 886 if ((0xFFFF >> ((BACKLIGHT_LEVELS - backlight_config.level) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
8d0fdf10
JH		 887 #if BACKLIGHT_ON_STATE == 0
888 // PORTx &= ~n
889 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
890 #else
891 // PORTx |= n
892 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
893 #endif
894 } else {
895 #if BACKLIGHT_ON_STATE == 0
896 // PORTx |= n
897 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
898 #else
899 // PORTx &= ~n
900 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
901 #endif
902 }
903 backlight_tick = (backlight_tick + 1) % 16;
904 #endif
905}
13bb6b4b
JH		 906
907#ifdef BACKLIGHT_BREATHING
908
909#define BREATHING_NO_HALT 0
910#define BREATHING_HALT_OFF 1
911#define BREATHING_HALT_ON 2
912
913static uint8_t breath_intensity;
914static uint8_t breath_speed;
915static uint16_t breathing_index;
916static uint8_t breathing_halt;
917
918void breathing_enable(void)
919{
920 if (get_backlight_level() == 0)
921 {
922 breathing_index = 0;
923 }
924 else
925 {
926 // Set breathing_index to be at the midpoint (brightest point)
927 breathing_index = 0x20 << breath_speed;
928 }
929
930 breathing_halt = BREATHING_NO_HALT;
931
932 // Enable breathing interrupt
933 TIMSK1 |= _BV(OCIE1A);
934}
935
936void breathing_pulse(void)
937{
938 if (get_backlight_level() == 0)
939 {
940 breathing_index = 0;
941 }
942 else
943 {
944 // Set breathing_index to be at the midpoint + 1 (brightest point)
945 breathing_index = 0x21 << breath_speed;
946 }
947
948 breathing_halt = BREATHING_HALT_ON;
949
950 // Enable breathing interrupt
951 TIMSK1 |= _BV(OCIE1A);
952}
953
954void breathing_disable(void)
955{
956 // Disable breathing interrupt
957 TIMSK1 &= ~_BV(OCIE1A);
958 backlight_set(get_backlight_level());
959}
960
961void breathing_self_disable(void)
962{
963 if (get_backlight_level() == 0)
964 {
965 breathing_halt = BREATHING_HALT_OFF;
966 }
967 else
968 {
969 breathing_halt = BREATHING_HALT_ON;
970 }
971
972 //backlight_set(get_backlight_level());
973}
974
975void breathing_toggle(void)
976{
977 if (!is_breathing())
978 {
979 if (get_backlight_level() == 0)
980 {
981 breathing_index = 0;
982 }
983 else
984 {
985 // Set breathing_index to be at the midpoint + 1 (brightest point)
986 breathing_index = 0x21 << breath_speed;
987 }
988
989 breathing_halt = BREATHING_NO_HALT;
990 }
991
992 // Toggle breathing interrupt
993 TIMSK1 ^= _BV(OCIE1A);
994
995 // Restore backlight level
996 if (!is_breathing())
997 {
998 backlight_set(get_backlight_level());
999 }
1000}
1001
1002bool is_breathing(void)
1003{
1004 return (TIMSK1 && _BV(OCIE1A));
1005}
1006
1007void breathing_intensity_default(void)
1008{
1009 //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
1010 breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
1011}
1012
1013void breathing_intensity_set(uint8_t value)
1014{
1015 breath_intensity = value;
1016}
1017
1018void breathing_speed_default(void)
1019{
1020 breath_speed = 4;
1021}
1022
1023void breathing_speed_set(uint8_t value)
1024{
1025 bool is_breathing_now = is_breathing();
1026 uint8_t old_breath_speed = breath_speed;
1027
1028 if (is_breathing_now)
1029 {
1030 // Disable breathing interrupt
1031 TIMSK1 &= ~_BV(OCIE1A);
1032 }
1033
1034 breath_speed = value;
1035
1036 if (is_breathing_now)
1037 {
1038 // Adjust index to account for new speed
1039 breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
1040
1041 // Enable breathing interrupt
1042 TIMSK1 |= _BV(OCIE1A);
1043 }
1044
1045}
1046
1047void breathing_speed_inc(uint8_t value)
1048{
1049 if ((uint16_t)(breath_speed - value) > 10 )
1050 {
1051 breathing_speed_set(0);
1052 }
1053 else
1054 {
1055 breathing_speed_set(breath_speed - value);
1056 }
1057}
1058
1059void breathing_speed_dec(uint8_t value)
1060{
1061 if ((uint16_t)(breath_speed + value) > 10 )
1062 {
1063 breathing_speed_set(10);
1064 }
1065 else
1066 {
1067 breathing_speed_set(breath_speed + value);
1068 }
1069}
1070
1071void breathing_defaults(void)
1072{
1073 breathing_intensity_default();
1074 breathing_speed_default();
1075 breathing_halt = BREATHING_NO_HALT;
1076}
1077
1078/* Breathing Sleep LED brighness(PWM On period) table
1079 * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
1080 *
1081 * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
1082 * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
1083 */
1084static const uint8_t breathing_table[64] PROGMEM = {
1085 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 6, 10,
1086 15, 23, 32, 44, 58, 74, 93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
1087255, 252, 245, 233, 218, 199, 179, 157, 135, 113, 93, 74, 58, 44, 32, 23,
1088 15, 10, 6, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1089};
1090
1091ISR(TIMER1_COMPA_vect)
1092{
1093 // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
1094
1095
1096 uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
1097
1098 if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
1099 {
1100 // Disable breathing interrupt
1101 TIMSK1 &= ~_BV(OCIE1A);
1102 }
1103
1104 OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
1105
1106}
1107
13bb6b4b
JH		 1108#endif // breathing
1109
1110#else // backlight
1111
1112__attribute__ ((weak))
1113void backlight_init_ports(void)
1114{
1115
1116}
1117
1118__attribute__ ((weak))
1119void backlight_set(uint8_t level)
1120{
1121
1122}
1123
1124#endif // backlight
1125
1126
664c0a03
JH		 1127// Functions for spitting out values
1128//
1129
1130void send_dword(uint32_t number) { // this might not actually work
1131 uint16_t word = (number >> 16);
1132 send_word(word);
1133 send_word(number & 0xFFFFUL);
1134}
1135
1136void send_word(uint16_t number) {
1137 uint8_t byte = number >> 8;
1138 send_byte(byte);
1139 send_byte(number & 0xFF);
1140}
1141
1142void send_byte(uint8_t number) {
1143 uint8_t nibble = number >> 4;
1144 send_nibble(nibble);
1145 send_nibble(number & 0xF);
1146}
1147
1148void send_nibble(uint8_t number) {
1149 switch (number) {
1150 case 0:
1151 register_code(KC_0);
1152 unregister_code(KC_0);
1153 break;
1154 case 1 ... 9:
1155 register_code(KC_1 + (number - 1));
1156 unregister_code(KC_1 + (number - 1));
1157 break;
1158 case 0xA ... 0xF:
1159 register_code(KC_A + (number - 0xA));
1160 unregister_code(KC_A + (number - 0xA));
1161 break;
1162 }
1163}
1164
cbabb4d4
JH		 1165
1166__attribute__((weak))
1167uint16_t hex_to_keycode(uint8_t hex)
1168{
b669d115 1169 hex = hex & 0xF;
cbabb4d4
JH		 1170 if (hex == 0x0) {
1171 return KC_0;
1172 } else if (hex < 0xA) {
1173 return KC_1 + (hex - 0x1);
1174 } else {
1175 return KC_A + (hex - 0xA);
1176 }
1177}
1178
7edac212
JH		 1179void api_send_unicode(uint32_t unicode) {
1180#ifdef API_ENABLE
cefa8468
JH		 1181 uint8_t chunk[4];
1182 dword_to_bytes(unicode, chunk);
1183 MT_SEND_DATA(DT_UNICODE, chunk, 5);
7edac212 1184#endif
cefa8468 1185}
13bb6b4b
JH		 1186
1187__attribute__ ((weak))
1188void led_set_user(uint8_t usb_led) {
1189
1190}
1191
1192__attribute__ ((weak))
1193void led_set_kb(uint8_t usb_led) {
1194 led_set_user(usb_led);
1195}
1196
1197__attribute__ ((weak))
1198void led_init_ports(void)
1199{
1200
1201}
1202
1203__attribute__ ((weak))
1204void led_set(uint8_t usb_led)
1205{
1206
1207 // Example LED Code
1208 //
1209 // // Using PE6 Caps Lock LED
1210 // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1211 // {
1212 // // Output high.
1213 // DDRE |= (1<<6);
1214 // PORTE |= (1<<6);
1215 // }
1216 // else
1217 // {
1218 // // Output low.
1219 // DDRE &= ~(1<<6);
1220 // PORTE &= ~(1<<6);
1221 // }
1222
1223 led_set_kb(usb_led);
1224}
1225
1226
287eb7ad 1227//------------------------------------------------------------------------------
794aed37 1228// Override these functions in your keymap file to play different tunes on
287eb7ad
JH		 1229// different events such as startup and bootloader jump
1230
1231__attribute__ ((weak))
1232void startup_user() {}
1233
1234__attribute__ ((weak))
1235void shutdown_user() {}
1236
12370259 1237//------------------------------------------------------------------------------
QMK Keyboard Firmware