Peter's keyboard firmware (QMK) https://qmk.fm/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

quantum.c 40KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527
  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. #include "quantum.h"
  17. #if !defined(RGBLIGHT_ENABLE) && !defined(RGB_MATRIX_ENABLE)
  18. #include "rgb.h"
  19. #endif
  20. #ifdef PROTOCOL_LUFA
  21. #include "outputselect.h"
  22. #endif
  23. #ifndef TAPPING_TERM
  24. #define TAPPING_TERM 200
  25. #endif
  26. #ifndef BREATHING_PERIOD
  27. #define BREATHING_PERIOD 6
  28. #endif
  29. #include "backlight.h"
  30. extern backlight_config_t backlight_config;
  31. #ifdef FAUXCLICKY_ENABLE
  32. #include "fauxclicky.h"
  33. #endif
  34. #ifdef API_ENABLE
  35. #include "api.h"
  36. #endif
  37. #ifdef MIDI_ENABLE
  38. #include "process_midi.h"
  39. #endif
  40. #ifdef VELOCIKEY_ENABLE
  41. #include "velocikey.h"
  42. #endif
  43. #ifdef HAPTIC_ENABLE
  44. #include "haptic.h"
  45. #endif
  46. #ifdef ENCODER_ENABLE
  47. #include "encoder.h"
  48. #endif
  49. #ifdef AUDIO_ENABLE
  50. #ifndef GOODBYE_SONG
  51. #define GOODBYE_SONG SONG(GOODBYE_SOUND)
  52. #endif
  53. #ifndef AG_NORM_SONG
  54. #define AG_NORM_SONG SONG(AG_NORM_SOUND)
  55. #endif
  56. #ifndef AG_SWAP_SONG
  57. #define AG_SWAP_SONG SONG(AG_SWAP_SOUND)
  58. #endif
  59. float goodbye_song[][2] = GOODBYE_SONG;
  60. float ag_norm_song[][2] = AG_NORM_SONG;
  61. float ag_swap_song[][2] = AG_SWAP_SONG;
  62. #ifdef DEFAULT_LAYER_SONGS
  63. float default_layer_songs[][16][2] = DEFAULT_LAYER_SONGS;
  64. #endif
  65. #endif
  66. static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
  67. switch (code) {
  68. case QK_MODS ... QK_MODS_MAX:
  69. break;
  70. default:
  71. return;
  72. }
  73. if (code & QK_LCTL)
  74. f(KC_LCTL);
  75. if (code & QK_LSFT)
  76. f(KC_LSFT);
  77. if (code & QK_LALT)
  78. f(KC_LALT);
  79. if (code & QK_LGUI)
  80. f(KC_LGUI);
  81. if (code < QK_RMODS_MIN) return;
  82. if (code & QK_RCTL)
  83. f(KC_RCTL);
  84. if (code & QK_RSFT)
  85. f(KC_RSFT);
  86. if (code & QK_RALT)
  87. f(KC_RALT);
  88. if (code & QK_RGUI)
  89. f(KC_RGUI);
  90. }
  91. static inline void qk_register_weak_mods(uint8_t kc) {
  92. add_weak_mods(MOD_BIT(kc));
  93. send_keyboard_report();
  94. }
  95. static inline void qk_unregister_weak_mods(uint8_t kc) {
  96. del_weak_mods(MOD_BIT(kc));
  97. send_keyboard_report();
  98. }
  99. static inline void qk_register_mods(uint8_t kc) {
  100. add_weak_mods(MOD_BIT(kc));
  101. send_keyboard_report();
  102. }
  103. static inline void qk_unregister_mods(uint8_t kc) {
  104. del_weak_mods(MOD_BIT(kc));
  105. send_keyboard_report();
  106. }
  107. void register_code16 (uint16_t code) {
  108. if (IS_MOD(code) || code == KC_NO) {
  109. do_code16 (code, qk_register_mods);
  110. } else {
  111. do_code16 (code, qk_register_weak_mods);
  112. }
  113. register_code (code);
  114. }
  115. void unregister_code16 (uint16_t code) {
  116. unregister_code (code);
  117. if (IS_MOD(code) || code == KC_NO) {
  118. do_code16 (code, qk_unregister_mods);
  119. } else {
  120. do_code16 (code, qk_unregister_weak_mods);
  121. }
  122. }
  123. void tap_code16(uint16_t code) {
  124. register_code16(code);
  125. #if TAP_CODE_DELAY > 0
  126. wait_ms(TAP_CODE_DELAY);
  127. #endif
  128. unregister_code16(code);
  129. }
  130. __attribute__ ((weak))
  131. bool process_action_kb(keyrecord_t *record) {
  132. return true;
  133. }
  134. __attribute__ ((weak))
  135. bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
  136. return process_record_user(keycode, record);
  137. }
  138. __attribute__ ((weak))
  139. bool process_record_user(uint16_t keycode, keyrecord_t *record) {
  140. return true;
  141. }
  142. void reset_keyboard(void) {
  143. clear_keyboard();
  144. #if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
  145. process_midi_all_notes_off();
  146. #endif
  147. #ifdef AUDIO_ENABLE
  148. #ifndef NO_MUSIC_MODE
  149. music_all_notes_off();
  150. #endif
  151. uint16_t timer_start = timer_read();
  152. PLAY_SONG(goodbye_song);
  153. shutdown_user();
  154. while(timer_elapsed(timer_start) < 250)
  155. wait_ms(1);
  156. stop_all_notes();
  157. #else
  158. shutdown_user();
  159. wait_ms(250);
  160. #endif
  161. #ifdef HAPTIC_ENABLE
  162. haptic_shutdown();
  163. #endif
  164. // this is also done later in bootloader.c - not sure if it's neccesary here
  165. #ifdef BOOTLOADER_CATERINA
  166. *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
  167. #endif
  168. bootloader_jump();
  169. }
  170. // Shift / paren setup
  171. #ifndef LSPO_KEY
  172. #define LSPO_KEY KC_9
  173. #endif
  174. #ifndef RSPC_KEY
  175. #define RSPC_KEY KC_0
  176. #endif
  177. #ifndef LSPO_MOD
  178. #define LSPO_MOD KC_LSFT
  179. #endif
  180. #ifndef RSPC_MOD
  181. #define RSPC_MOD KC_RSFT
  182. #endif
  183. // Shift / Enter setup
  184. #ifndef SFTENT_KEY
  185. #define SFTENT_KEY KC_ENT
  186. #endif
  187. static bool shift_interrupted[2] = {0, 0};
  188. static uint16_t scs_timer[2] = {0, 0};
  189. /* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
  190. * Used to ensure that the correct keycode is released if the key is released.
  191. */
  192. static bool grave_esc_was_shifted = false;
  193. /* Convert record into usable keycode via the contained event. */
  194. uint16_t get_record_keycode(keyrecord_t *record) {
  195. return get_event_keycode(record->event);
  196. }
  197. /* Convert event into usable keycode. Checks the layer cache to ensure that it
  198. * retains the correct keycode after a layer change, if the key is still pressed.
  199. */
  200. uint16_t get_event_keycode(keyevent_t event) {
  201. #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
  202. /* TODO: Use store_or_get_action() or a similar function. */
  203. if (!disable_action_cache) {
  204. uint8_t layer;
  205. if (event.pressed) {
  206. layer = layer_switch_get_layer(event.key);
  207. update_source_layers_cache(event.key, layer);
  208. } else {
  209. layer = read_source_layers_cache(event.key);
  210. }
  211. return keymap_key_to_keycode(layer, event.key);
  212. } else
  213. #endif
  214. return keymap_key_to_keycode(layer_switch_get_layer(event.key), event.key);
  215. }
  216. /* Main keycode processing function. Hands off handling to other functions,
  217. * then processes internal Quantum keycodes, then processes ACTIONs.
  218. */
  219. bool process_record_quantum(keyrecord_t *record) {
  220. uint16_t keycode = get_record_keycode(record);
  221. // This is how you use actions here
  222. // if (keycode == KC_LEAD) {
  223. // action_t action;
  224. // action.code = ACTION_DEFAULT_LAYER_SET(0);
  225. // process_action(record, action);
  226. // return false;
  227. // }
  228. #ifdef VELOCIKEY_ENABLE
  229. if (velocikey_enabled() && record->event.pressed) { velocikey_accelerate(); }
  230. #endif
  231. #ifdef TAP_DANCE_ENABLE
  232. preprocess_tap_dance(keycode, record);
  233. #endif
  234. if (!(
  235. #if defined(KEY_LOCK_ENABLE)
  236. // Must run first to be able to mask key_up events.
  237. process_key_lock(&keycode, record) &&
  238. #endif
  239. #if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY)
  240. process_clicky(keycode, record) &&
  241. #endif //AUDIO_CLICKY
  242. #ifdef HAPTIC_ENABLE
  243. process_haptic(keycode, record) &&
  244. #endif //HAPTIC_ENABLE
  245. #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_KEYREACTIVE_ENABLED)
  246. process_rgb_matrix(keycode, record) &&
  247. #endif
  248. process_record_kb(keycode, record) &&
  249. #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
  250. process_midi(keycode, record) &&
  251. #endif
  252. #ifdef AUDIO_ENABLE
  253. process_audio(keycode, record) &&
  254. #endif
  255. #ifdef STENO_ENABLE
  256. process_steno(keycode, record) &&
  257. #endif
  258. #if (defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
  259. process_music(keycode, record) &&
  260. #endif
  261. #ifdef TAP_DANCE_ENABLE
  262. process_tap_dance(keycode, record) &&
  263. #endif
  264. #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
  265. process_unicode_common(keycode, record) &&
  266. #endif
  267. #ifdef LEADER_ENABLE
  268. process_leader(keycode, record) &&
  269. #endif
  270. #ifdef COMBO_ENABLE
  271. process_combo(keycode, record) &&
  272. #endif
  273. #ifdef PRINTING_ENABLE
  274. process_printer(keycode, record) &&
  275. #endif
  276. #ifdef AUTO_SHIFT_ENABLE
  277. process_auto_shift(keycode, record) &&
  278. #endif
  279. #ifdef TERMINAL_ENABLE
  280. process_terminal(keycode, record) &&
  281. #endif
  282. true)) {
  283. return false;
  284. }
  285. // Shift / paren setup
  286. switch(keycode) {
  287. case RESET:
  288. if (record->event.pressed) {
  289. reset_keyboard();
  290. }
  291. return false;
  292. case DEBUG:
  293. if (record->event.pressed) {
  294. debug_enable = true;
  295. print("DEBUG: enabled.\n");
  296. }
  297. return false;
  298. case EEPROM_RESET:
  299. if (record->event.pressed) {
  300. eeconfig_init();
  301. }
  302. return false;
  303. #ifdef FAUXCLICKY_ENABLE
  304. case FC_TOG:
  305. if (record->event.pressed) {
  306. FAUXCLICKY_TOGGLE;
  307. }
  308. return false;
  309. case FC_ON:
  310. if (record->event.pressed) {
  311. FAUXCLICKY_ON;
  312. }
  313. return false;
  314. case FC_OFF:
  315. if (record->event.pressed) {
  316. FAUXCLICKY_OFF;
  317. }
  318. return false;
  319. #endif
  320. #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
  321. case RGB_TOG:
  322. // Split keyboards need to trigger on key-up for edge-case issue
  323. #ifndef SPLIT_KEYBOARD
  324. if (record->event.pressed) {
  325. #else
  326. if (!record->event.pressed) {
  327. #endif
  328. rgblight_toggle();
  329. }
  330. return false;
  331. case RGB_MODE_FORWARD:
  332. if (record->event.pressed) {
  333. uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
  334. if(shifted) {
  335. rgblight_step_reverse();
  336. }
  337. else {
  338. rgblight_step();
  339. }
  340. }
  341. return false;
  342. case RGB_MODE_REVERSE:
  343. if (record->event.pressed) {
  344. uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
  345. if(shifted) {
  346. rgblight_step();
  347. }
  348. else {
  349. rgblight_step_reverse();
  350. }
  351. }
  352. return false;
  353. case RGB_HUI:
  354. // Split keyboards need to trigger on key-up for edge-case issue
  355. #ifndef SPLIT_KEYBOARD
  356. if (record->event.pressed) {
  357. #else
  358. if (!record->event.pressed) {
  359. #endif
  360. rgblight_increase_hue();
  361. }
  362. return false;
  363. case RGB_HUD:
  364. // Split keyboards need to trigger on key-up for edge-case issue
  365. #ifndef SPLIT_KEYBOARD
  366. if (record->event.pressed) {
  367. #else
  368. if (!record->event.pressed) {
  369. #endif
  370. rgblight_decrease_hue();
  371. }
  372. return false;
  373. case RGB_SAI:
  374. // Split keyboards need to trigger on key-up for edge-case issue
  375. #ifndef SPLIT_KEYBOARD
  376. if (record->event.pressed) {
  377. #else
  378. if (!record->event.pressed) {
  379. #endif
  380. rgblight_increase_sat();
  381. }
  382. return false;
  383. case RGB_SAD:
  384. // Split keyboards need to trigger on key-up for edge-case issue
  385. #ifndef SPLIT_KEYBOARD
  386. if (record->event.pressed) {
  387. #else
  388. if (!record->event.pressed) {
  389. #endif
  390. rgblight_decrease_sat();
  391. }
  392. return false;
  393. case RGB_VAI:
  394. // Split keyboards need to trigger on key-up for edge-case issue
  395. #ifndef SPLIT_KEYBOARD
  396. if (record->event.pressed) {
  397. #else
  398. if (!record->event.pressed) {
  399. #endif
  400. rgblight_increase_val();
  401. }
  402. return false;
  403. case RGB_VAD:
  404. // Split keyboards need to trigger on key-up for edge-case issue
  405. #ifndef SPLIT_KEYBOARD
  406. if (record->event.pressed) {
  407. #else
  408. if (!record->event.pressed) {
  409. #endif
  410. rgblight_decrease_val();
  411. }
  412. return false;
  413. case RGB_SPI:
  414. if (record->event.pressed) {
  415. rgblight_increase_speed();
  416. }
  417. return false;
  418. case RGB_SPD:
  419. if (record->event.pressed) {
  420. rgblight_decrease_speed();
  421. }
  422. return false;
  423. case RGB_MODE_PLAIN:
  424. if (record->event.pressed) {
  425. rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
  426. }
  427. return false;
  428. case RGB_MODE_BREATHE:
  429. #ifdef RGBLIGHT_EFFECT_BREATHING
  430. if (record->event.pressed) {
  431. if ((RGBLIGHT_MODE_BREATHING <= rgblight_get_mode()) &&
  432. (rgblight_get_mode() < RGBLIGHT_MODE_BREATHING_end)) {
  433. rgblight_step();
  434. } else {
  435. rgblight_mode(RGBLIGHT_MODE_BREATHING);
  436. }
  437. }
  438. #endif
  439. return false;
  440. case RGB_MODE_RAINBOW:
  441. #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
  442. if (record->event.pressed) {
  443. if ((RGBLIGHT_MODE_RAINBOW_MOOD <= rgblight_get_mode()) &&
  444. (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_MOOD_end)) {
  445. rgblight_step();
  446. } else {
  447. rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD);
  448. }
  449. }
  450. #endif
  451. return false;
  452. case RGB_MODE_SWIRL:
  453. #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
  454. if (record->event.pressed) {
  455. if ((RGBLIGHT_MODE_RAINBOW_SWIRL <= rgblight_get_mode()) &&
  456. (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_SWIRL_end)) {
  457. rgblight_step();
  458. } else {
  459. rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL);
  460. }
  461. }
  462. #endif
  463. return false;
  464. case RGB_MODE_SNAKE:
  465. #ifdef RGBLIGHT_EFFECT_SNAKE
  466. if (record->event.pressed) {
  467. if ((RGBLIGHT_MODE_SNAKE <= rgblight_get_mode()) &&
  468. (rgblight_get_mode() < RGBLIGHT_MODE_SNAKE_end)) {
  469. rgblight_step();
  470. } else {
  471. rgblight_mode(RGBLIGHT_MODE_SNAKE);
  472. }
  473. }
  474. #endif
  475. return false;
  476. case RGB_MODE_KNIGHT:
  477. #ifdef RGBLIGHT_EFFECT_KNIGHT
  478. if (record->event.pressed) {
  479. if ((RGBLIGHT_MODE_KNIGHT <= rgblight_get_mode()) &&
  480. (rgblight_get_mode() < RGBLIGHT_MODE_KNIGHT_end)) {
  481. rgblight_step();
  482. } else {
  483. rgblight_mode(RGBLIGHT_MODE_KNIGHT);
  484. }
  485. }
  486. #endif
  487. return false;
  488. case RGB_MODE_XMAS:
  489. #ifdef RGBLIGHT_EFFECT_CHRISTMAS
  490. if (record->event.pressed) {
  491. rgblight_mode(RGBLIGHT_MODE_CHRISTMAS);
  492. }
  493. #endif
  494. return false;
  495. case RGB_MODE_GRADIENT:
  496. #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
  497. if (record->event.pressed) {
  498. if ((RGBLIGHT_MODE_STATIC_GRADIENT <= rgblight_get_mode()) &&
  499. (rgblight_get_mode() < RGBLIGHT_MODE_STATIC_GRADIENT_end)) {
  500. rgblight_step();
  501. } else {
  502. rgblight_mode(RGBLIGHT_MODE_STATIC_GRADIENT);
  503. }
  504. }
  505. #endif
  506. return false;
  507. case RGB_MODE_RGBTEST:
  508. #ifdef RGBLIGHT_EFFECT_RGB_TEST
  509. if (record->event.pressed) {
  510. rgblight_mode(RGBLIGHT_MODE_RGB_TEST);
  511. }
  512. #endif
  513. return false;
  514. #endif // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
  515. #ifdef VELOCIKEY_ENABLE
  516. case VLK_TOG:
  517. if (record->event.pressed) {
  518. velocikey_toggle();
  519. }
  520. return false;
  521. #endif
  522. #ifdef PROTOCOL_LUFA
  523. case OUT_AUTO:
  524. if (record->event.pressed) {
  525. set_output(OUTPUT_AUTO);
  526. }
  527. return false;
  528. case OUT_USB:
  529. if (record->event.pressed) {
  530. set_output(OUTPUT_USB);
  531. }
  532. return false;
  533. #ifdef BLUETOOTH_ENABLE
  534. case OUT_BT:
  535. if (record->event.pressed) {
  536. set_output(OUTPUT_BLUETOOTH);
  537. }
  538. return false;
  539. #endif
  540. #endif
  541. case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
  542. if (record->event.pressed) {
  543. // MAGIC actions (BOOTMAGIC without the boot)
  544. if (!eeconfig_is_enabled()) {
  545. eeconfig_init();
  546. }
  547. /* keymap config */
  548. keymap_config.raw = eeconfig_read_keymap();
  549. switch (keycode)
  550. {
  551. case MAGIC_SWAP_CONTROL_CAPSLOCK:
  552. keymap_config.swap_control_capslock = true;
  553. break;
  554. case MAGIC_CAPSLOCK_TO_CONTROL:
  555. keymap_config.capslock_to_control = true;
  556. break;
  557. case MAGIC_SWAP_LALT_LGUI:
  558. keymap_config.swap_lalt_lgui = true;
  559. break;
  560. case MAGIC_SWAP_RALT_RGUI:
  561. keymap_config.swap_ralt_rgui = true;
  562. break;
  563. case MAGIC_NO_GUI:
  564. keymap_config.no_gui = true;
  565. break;
  566. case MAGIC_SWAP_GRAVE_ESC:
  567. keymap_config.swap_grave_esc = true;
  568. break;
  569. case MAGIC_SWAP_BACKSLASH_BACKSPACE:
  570. keymap_config.swap_backslash_backspace = true;
  571. break;
  572. case MAGIC_HOST_NKRO:
  573. keymap_config.nkro = true;
  574. break;
  575. case MAGIC_SWAP_ALT_GUI:
  576. keymap_config.swap_lalt_lgui = true;
  577. keymap_config.swap_ralt_rgui = true;
  578. #ifdef AUDIO_ENABLE
  579. PLAY_SONG(ag_swap_song);
  580. #endif
  581. break;
  582. case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
  583. keymap_config.swap_control_capslock = false;
  584. break;
  585. case MAGIC_UNCAPSLOCK_TO_CONTROL:
  586. keymap_config.capslock_to_control = false;
  587. break;
  588. case MAGIC_UNSWAP_LALT_LGUI:
  589. keymap_config.swap_lalt_lgui = false;
  590. break;
  591. case MAGIC_UNSWAP_RALT_RGUI:
  592. keymap_config.swap_ralt_rgui = false;
  593. break;
  594. case MAGIC_UNNO_GUI:
  595. keymap_config.no_gui = false;
  596. break;
  597. case MAGIC_UNSWAP_GRAVE_ESC:
  598. keymap_config.swap_grave_esc = false;
  599. break;
  600. case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
  601. keymap_config.swap_backslash_backspace = false;
  602. break;
  603. case MAGIC_UNHOST_NKRO:
  604. keymap_config.nkro = false;
  605. break;
  606. case MAGIC_UNSWAP_ALT_GUI:
  607. keymap_config.swap_lalt_lgui = false;
  608. keymap_config.swap_ralt_rgui = false;
  609. #ifdef AUDIO_ENABLE
  610. PLAY_SONG(ag_norm_song);
  611. #endif
  612. break;
  613. case MAGIC_TOGGLE_ALT_GUI:
  614. keymap_config.swap_lalt_lgui = !keymap_config.swap_lalt_lgui;
  615. keymap_config.swap_ralt_rgui = !keymap_config.swap_ralt_rgui;
  616. #ifdef AUDIO_ENABLE
  617. if (keymap_config.swap_ralt_rgui) {
  618. PLAY_SONG(ag_swap_song);
  619. } else {
  620. PLAY_SONG(ag_norm_song);
  621. }
  622. #endif
  623. break;
  624. case MAGIC_TOGGLE_NKRO:
  625. keymap_config.nkro = !keymap_config.nkro;
  626. break;
  627. default:
  628. break;
  629. }
  630. eeconfig_update_keymap(keymap_config.raw);
  631. clear_keyboard(); // clear to prevent stuck keys
  632. return false;
  633. }
  634. break;
  635. case KC_LSPO: {
  636. if (record->event.pressed) {
  637. shift_interrupted[0] = false;
  638. scs_timer[0] = timer_read ();
  639. register_mods(MOD_BIT(KC_LSFT));
  640. }
  641. else {
  642. #ifdef DISABLE_SPACE_CADET_ROLLOVER
  643. if (get_mods() & MOD_BIT(RSPC_MOD)) {
  644. shift_interrupted[0] = true;
  645. shift_interrupted[1] = true;
  646. }
  647. #endif
  648. if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
  649. #ifdef DISABLE_SPACE_CADET_MODIFIER
  650. unregister_mods(MOD_BIT(KC_LSFT));
  651. #else
  652. if( LSPO_MOD != KC_LSFT ){
  653. unregister_mods(MOD_BIT(KC_LSFT));
  654. register_mods(MOD_BIT(LSPO_MOD));
  655. }
  656. #endif
  657. register_code(LSPO_KEY);
  658. unregister_code(LSPO_KEY);
  659. #ifndef DISABLE_SPACE_CADET_MODIFIER
  660. if( LSPO_MOD != KC_LSFT ){
  661. unregister_mods(MOD_BIT(LSPO_MOD));
  662. }
  663. #endif
  664. }
  665. unregister_mods(MOD_BIT(KC_LSFT));
  666. }
  667. return false;
  668. }
  669. case KC_RSPC: {
  670. if (record->event.pressed) {
  671. shift_interrupted[1] = false;
  672. scs_timer[1] = timer_read ();
  673. register_mods(MOD_BIT(KC_RSFT));
  674. }
  675. else {
  676. #ifdef DISABLE_SPACE_CADET_ROLLOVER
  677. if (get_mods() & MOD_BIT(LSPO_MOD)) {
  678. shift_interrupted[0] = true;
  679. shift_interrupted[1] = true;
  680. }
  681. #endif
  682. if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
  683. #ifdef DISABLE_SPACE_CADET_MODIFIER
  684. unregister_mods(MOD_BIT(KC_RSFT));
  685. #else
  686. if( RSPC_MOD != KC_RSFT ){
  687. unregister_mods(MOD_BIT(KC_RSFT));
  688. register_mods(MOD_BIT(RSPC_MOD));
  689. }
  690. #endif
  691. register_code(RSPC_KEY);
  692. unregister_code(RSPC_KEY);
  693. #ifndef DISABLE_SPACE_CADET_MODIFIER
  694. if ( RSPC_MOD != KC_RSFT ){
  695. unregister_mods(MOD_BIT(RSPC_MOD));
  696. }
  697. #endif
  698. }
  699. unregister_mods(MOD_BIT(KC_RSFT));
  700. }
  701. return false;
  702. }
  703. case KC_SFTENT: {
  704. if (record->event.pressed) {
  705. shift_interrupted[1] = false;
  706. scs_timer[1] = timer_read ();
  707. register_mods(MOD_BIT(KC_RSFT));
  708. }
  709. else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
  710. unregister_mods(MOD_BIT(KC_RSFT));
  711. register_code(SFTENT_KEY);
  712. unregister_code(SFTENT_KEY);
  713. }
  714. else {
  715. unregister_mods(MOD_BIT(KC_RSFT));
  716. }
  717. return false;
  718. }
  719. case GRAVE_ESC: {
  720. uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
  721. |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
  722. #ifdef GRAVE_ESC_ALT_OVERRIDE
  723. // if ALT is pressed, ESC is always sent
  724. // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
  725. if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
  726. shifted = 0;
  727. }
  728. #endif
  729. #ifdef GRAVE_ESC_CTRL_OVERRIDE
  730. // if CTRL is pressed, ESC is always sent
  731. // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
  732. if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
  733. shifted = 0;
  734. }
  735. #endif
  736. #ifdef GRAVE_ESC_GUI_OVERRIDE
  737. // if GUI is pressed, ESC is always sent
  738. if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
  739. shifted = 0;
  740. }
  741. #endif
  742. #ifdef GRAVE_ESC_SHIFT_OVERRIDE
  743. // if SHIFT is pressed, ESC is always sent
  744. if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
  745. shifted = 0;
  746. }
  747. #endif
  748. if (record->event.pressed) {
  749. grave_esc_was_shifted = shifted;
  750. add_key(shifted ? KC_GRAVE : KC_ESCAPE);
  751. }
  752. else {
  753. del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
  754. }
  755. send_keyboard_report();
  756. return false;
  757. }
  758. #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
  759. case BL_BRTG: {
  760. if (record->event.pressed)
  761. breathing_toggle();
  762. return false;
  763. }
  764. #endif
  765. default: {
  766. shift_interrupted[0] = true;
  767. shift_interrupted[1] = true;
  768. break;
  769. }
  770. }
  771. return process_action_kb(record);
  772. }
  773. __attribute__ ((weak))
  774. const bool ascii_to_shift_lut[0x80] PROGMEM = {
  775. 0, 0, 0, 0, 0, 0, 0, 0,
  776. 0, 0, 0, 0, 0, 0, 0, 0,
  777. 0, 0, 0, 0, 0, 0, 0, 0,
  778. 0, 0, 0, 0, 0, 0, 0, 0,
  779. 0, 1, 1, 1, 1, 1, 1, 0,
  780. 1, 1, 1, 1, 0, 0, 0, 0,
  781. 0, 0, 0, 0, 0, 0, 0, 0,
  782. 0, 0, 1, 0, 1, 0, 1, 1,
  783. 1, 1, 1, 1, 1, 1, 1, 1,
  784. 1, 1, 1, 1, 1, 1, 1, 1,
  785. 1, 1, 1, 1, 1, 1, 1, 1,
  786. 1, 1, 1, 0, 0, 0, 1, 1,
  787. 0, 0, 0, 0, 0, 0, 0, 0,
  788. 0, 0, 0, 0, 0, 0, 0, 0,
  789. 0, 0, 0, 0, 0, 0, 0, 0,
  790. 0, 0, 0, 1, 1, 1, 1, 0
  791. };
  792. __attribute__ ((weak))
  793. const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
  794. 0, 0, 0, 0, 0, 0, 0, 0,
  795. KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
  796. 0, 0, 0, 0, 0, 0, 0, 0,
  797. 0, 0, 0, KC_ESC, 0, 0, 0, 0,
  798. KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
  799. KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
  800. KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
  801. KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
  802. KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
  803. KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
  804. KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
  805. KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
  806. KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
  807. KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
  808. KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
  809. KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
  810. };
  811. void send_string(const char *str) {
  812. send_string_with_delay(str, 0);
  813. }
  814. void send_string_P(const char *str) {
  815. send_string_with_delay_P(str, 0);
  816. }
  817. void send_string_with_delay(const char *str, uint8_t interval) {
  818. while (1) {
  819. char ascii_code = *str;
  820. if (!ascii_code) break;
  821. if (ascii_code == 1) {
  822. // tap
  823. uint8_t keycode = *(++str);
  824. register_code(keycode);
  825. unregister_code(keycode);
  826. } else if (ascii_code == 2) {
  827. // down
  828. uint8_t keycode = *(++str);
  829. register_code(keycode);
  830. } else if (ascii_code == 3) {
  831. // up
  832. uint8_t keycode = *(++str);
  833. unregister_code(keycode);
  834. } else {
  835. send_char(ascii_code);
  836. }
  837. ++str;
  838. // interval
  839. { uint8_t ms = interval; while (ms--) wait_ms(1); }
  840. }
  841. }
  842. void send_string_with_delay_P(const char *str, uint8_t interval) {
  843. while (1) {
  844. char ascii_code = pgm_read_byte(str);
  845. if (!ascii_code) break;
  846. if (ascii_code == 1) {
  847. // tap
  848. uint8_t keycode = pgm_read_byte(++str);
  849. register_code(keycode);
  850. unregister_code(keycode);
  851. } else if (ascii_code == 2) {
  852. // down
  853. uint8_t keycode = pgm_read_byte(++str);
  854. register_code(keycode);
  855. } else if (ascii_code == 3) {
  856. // up
  857. uint8_t keycode = pgm_read_byte(++str);
  858. unregister_code(keycode);
  859. } else {
  860. send_char(ascii_code);
  861. }
  862. ++str;
  863. // interval
  864. { uint8_t ms = interval; while (ms--) wait_ms(1); }
  865. }
  866. }
  867. void send_char(char ascii_code) {
  868. uint8_t keycode;
  869. keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
  870. if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
  871. register_code(KC_LSFT);
  872. register_code(keycode);
  873. unregister_code(keycode);
  874. unregister_code(KC_LSFT);
  875. } else {
  876. register_code(keycode);
  877. unregister_code(keycode);
  878. }
  879. }
  880. void set_single_persistent_default_layer(uint8_t default_layer) {
  881. #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
  882. PLAY_SONG(default_layer_songs[default_layer]);
  883. #endif
  884. eeconfig_update_default_layer(1U<<default_layer);
  885. default_layer_set(1U<<default_layer);
  886. }
  887. uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
  888. uint32_t mask12 = (1UL << layer1) | (1UL << layer2);
  889. uint32_t mask3 = 1UL << layer3;
  890. return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
  891. }
  892. void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
  893. layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
  894. }
  895. void tap_random_base64(void) {
  896. #if defined(__AVR_ATmega32U4__)
  897. uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
  898. #else
  899. uint8_t key = rand() % 64;
  900. #endif
  901. switch (key) {
  902. case 0 ... 25:
  903. register_code(KC_LSFT);
  904. register_code(key + KC_A);
  905. unregister_code(key + KC_A);
  906. unregister_code(KC_LSFT);
  907. break;
  908. case 26 ... 51:
  909. register_code(key - 26 + KC_A);
  910. unregister_code(key - 26 + KC_A);
  911. break;
  912. case 52:
  913. register_code(KC_0);
  914. unregister_code(KC_0);
  915. break;
  916. case 53 ... 61:
  917. register_code(key - 53 + KC_1);
  918. unregister_code(key - 53 + KC_1);
  919. break;
  920. case 62:
  921. register_code(KC_LSFT);
  922. register_code(KC_EQL);
  923. unregister_code(KC_EQL);
  924. unregister_code(KC_LSFT);
  925. break;
  926. case 63:
  927. register_code(KC_SLSH);
  928. unregister_code(KC_SLSH);
  929. break;
  930. }
  931. }
  932. __attribute__((weak))
  933. void bootmagic_lite(void) {
  934. // The lite version of TMK's bootmagic based on Wilba.
  935. // 100% less potential for accidentally making the
  936. // keyboard do stupid things.
  937. // We need multiple scans because debouncing can't be turned off.
  938. matrix_scan();
  939. #if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
  940. wait_ms(DEBOUNCING_DELAY * 2);
  941. #elif defined(DEBOUNCE) && DEBOUNCE > 0
  942. wait_ms(DEBOUNCE * 2);
  943. #else
  944. wait_ms(30);
  945. #endif
  946. matrix_scan();
  947. // If the Esc and space bar are held down on power up,
  948. // reset the EEPROM valid state and jump to bootloader.
  949. // Assumes Esc is at [0,0].
  950. // This isn't very generalized, but we need something that doesn't
  951. // rely on user's keymaps in firmware or EEPROM.
  952. if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
  953. eeconfig_disable();
  954. // Jump to bootloader.
  955. bootloader_jump();
  956. }
  957. }
  958. void matrix_init_quantum() {
  959. #ifdef BOOTMAGIC_LITE
  960. bootmagic_lite();
  961. #endif
  962. if (!eeconfig_is_enabled()) {
  963. eeconfig_init();
  964. }
  965. #ifdef BACKLIGHT_ENABLE
  966. #ifdef LED_MATRIX_ENABLE
  967. led_matrix_init();
  968. #else
  969. backlight_init_ports();
  970. #endif
  971. #endif
  972. #ifdef AUDIO_ENABLE
  973. audio_init();
  974. #endif
  975. #ifdef RGB_MATRIX_ENABLE
  976. rgb_matrix_init();
  977. #endif
  978. #ifdef ENCODER_ENABLE
  979. encoder_init();
  980. #endif
  981. #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
  982. unicode_input_mode_init();
  983. #endif
  984. #ifdef HAPTIC_ENABLE
  985. haptic_init();
  986. #endif
  987. matrix_init_kb();
  988. }
  989. void matrix_scan_quantum() {
  990. #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
  991. matrix_scan_music();
  992. #endif
  993. #ifdef TAP_DANCE_ENABLE
  994. matrix_scan_tap_dance();
  995. #endif
  996. #ifdef COMBO_ENABLE
  997. matrix_scan_combo();
  998. #endif
  999. #if defined(BACKLIGHT_ENABLE)
  1000. #if defined(LED_MATRIX_ENABLE)
  1001. led_matrix_task();
  1002. #elif defined(BACKLIGHT_PIN)
  1003. backlight_task();
  1004. #endif
  1005. #endif
  1006. #ifdef RGB_MATRIX_ENABLE
  1007. rgb_matrix_task();
  1008. #endif
  1009. #ifdef ENCODER_ENABLE
  1010. encoder_read();
  1011. #endif
  1012. #ifdef HAPTIC_ENABLE
  1013. haptic_task();
  1014. #endif
  1015. matrix_scan_kb();
  1016. }
  1017. #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
  1018. static const uint8_t backlight_pin = BACKLIGHT_PIN;
  1019. // depending on the pin, we use a different output compare unit
  1020. #if BACKLIGHT_PIN == B7
  1021. # define TCCRxA TCCR1A
  1022. # define TCCRxB TCCR1B
  1023. # define COMxx1 COM1C1
  1024. # define OCRxx OCR1C
  1025. # define ICRx ICR1
  1026. #elif BACKLIGHT_PIN == B6
  1027. # define TCCRxA TCCR1A
  1028. # define TCCRxB TCCR1B
  1029. # define COMxx1 COM1B1
  1030. # define OCRxx OCR1B
  1031. # define ICRx ICR1
  1032. #elif BACKLIGHT_PIN == B5
  1033. # define TCCRxA TCCR1A
  1034. # define TCCRxB TCCR1B
  1035. # define COMxx1 COM1A1
  1036. # define OCRxx OCR1A
  1037. # define ICRx ICR1
  1038. #elif BACKLIGHT_PIN == C6
  1039. # define TCCRxA TCCR3A
  1040. # define TCCRxB TCCR3B
  1041. # define COMxx1 COM1A1
  1042. # define OCRxx OCR3A
  1043. # define ICRx ICR3
  1044. #else
  1045. # define NO_HARDWARE_PWM
  1046. #endif
  1047. #ifndef BACKLIGHT_ON_STATE
  1048. #define BACKLIGHT_ON_STATE 0
  1049. #endif
  1050. #ifdef NO_HARDWARE_PWM // pwm through software
  1051. __attribute__ ((weak))
  1052. void backlight_init_ports(void)
  1053. {
  1054. // Setup backlight pin as output and output to on state.
  1055. // DDRx |= n
  1056. _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
  1057. #if BACKLIGHT_ON_STATE == 0
  1058. // PORTx &= ~n
  1059. _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
  1060. #else
  1061. // PORTx |= n
  1062. _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
  1063. #endif
  1064. }
  1065. __attribute__ ((weak))
  1066. void backlight_set(uint8_t level) {}
  1067. uint8_t backlight_tick = 0;
  1068. #ifndef BACKLIGHT_CUSTOM_DRIVER
  1069. void backlight_task(void) {
  1070. if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
  1071. #if BACKLIGHT_ON_STATE == 0
  1072. // PORTx &= ~n
  1073. _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
  1074. #else
  1075. // PORTx |= n
  1076. _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
  1077. #endif
  1078. } else {
  1079. #if BACKLIGHT_ON_STATE == 0
  1080. // PORTx |= n
  1081. _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
  1082. #else
  1083. // PORTx &= ~n
  1084. _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
  1085. #endif
  1086. }
  1087. backlight_tick = (backlight_tick + 1) % 16;
  1088. }
  1089. #endif
  1090. #ifdef BACKLIGHT_BREATHING
  1091. #ifndef BACKLIGHT_CUSTOM_DRIVER
  1092. #error "Backlight breathing only available with hardware PWM. Please disable."
  1093. #endif
  1094. #endif
  1095. #else // pwm through timer
  1096. #define TIMER_TOP 0xFFFFU
  1097. // See http://jared.geek.nz/2013/feb/linear-led-pwm
  1098. static uint16_t cie_lightness(uint16_t v) {
  1099. if (v <= 5243) // if below 8% of max
  1100. return v / 9; // same as dividing by 900%
  1101. else {
  1102. uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
  1103. // to get a useful result with integer division, we shift left in the expression above
  1104. // and revert what we've done again after squaring.
  1105. y = y * y * y >> 8;
  1106. if (y > 0xFFFFUL) // prevent overflow
  1107. return 0xFFFFU;
  1108. else
  1109. return (uint16_t) y;
  1110. }
  1111. }
  1112. // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
  1113. static inline void set_pwm(uint16_t val) {
  1114. OCRxx = val;
  1115. }
  1116. #ifndef BACKLIGHT_CUSTOM_DRIVER
  1117. __attribute__ ((weak))
  1118. void backlight_set(uint8_t level) {
  1119. if (level > BACKLIGHT_LEVELS)
  1120. level = BACKLIGHT_LEVELS;
  1121. if (level == 0) {
  1122. // Turn off PWM control on backlight pin
  1123. TCCRxA &= ~(_BV(COMxx1));
  1124. } else {
  1125. // Turn on PWM control of backlight pin
  1126. TCCRxA |= _BV(COMxx1);
  1127. }
  1128. // Set the brightness
  1129. set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
  1130. }
  1131. void backlight_task(void) {}
  1132. #endif // BACKLIGHT_CUSTOM_DRIVER
  1133. #ifdef BACKLIGHT_BREATHING
  1134. #define BREATHING_NO_HALT 0
  1135. #define BREATHING_HALT_OFF 1
  1136. #define BREATHING_HALT_ON 2
  1137. #define BREATHING_STEPS 128
  1138. static uint8_t breathing_period = BREATHING_PERIOD;
  1139. static uint8_t breathing_halt = BREATHING_NO_HALT;
  1140. static uint16_t breathing_counter = 0;
  1141. bool is_breathing(void) {
  1142. return !!(TIMSK1 & _BV(TOIE1));
  1143. }
  1144. #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
  1145. #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
  1146. #define breathing_min() do {breathing_counter = 0;} while (0)
  1147. #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
  1148. void breathing_enable(void)
  1149. {
  1150. breathing_counter = 0;
  1151. breathing_halt = BREATHING_NO_HALT;
  1152. breathing_interrupt_enable();
  1153. }
  1154. void breathing_pulse(void)
  1155. {
  1156. if (get_backlight_level() == 0)
  1157. breathing_min();
  1158. else
  1159. breathing_max();
  1160. breathing_halt = BREATHING_HALT_ON;
  1161. breathing_interrupt_enable();
  1162. }
  1163. void breathing_disable(void)
  1164. {
  1165. breathing_interrupt_disable();
  1166. // Restore backlight level
  1167. backlight_set(get_backlight_level());
  1168. }
  1169. void breathing_self_disable(void)
  1170. {
  1171. if (get_backlight_level() == 0)
  1172. breathing_halt = BREATHING_HALT_OFF;
  1173. else
  1174. breathing_halt = BREATHING_HALT_ON;
  1175. }
  1176. void breathing_toggle(void) {
  1177. if (is_breathing())
  1178. breathing_disable();
  1179. else
  1180. breathing_enable();
  1181. }
  1182. void breathing_period_set(uint8_t value)
  1183. {
  1184. if (!value)
  1185. value = 1;
  1186. breathing_period = value;
  1187. }
  1188. void breathing_period_default(void) {
  1189. breathing_period_set(BREATHING_PERIOD);
  1190. }
  1191. void breathing_period_inc(void)
  1192. {
  1193. breathing_period_set(breathing_period+1);
  1194. }
  1195. void breathing_period_dec(void)
  1196. {
  1197. breathing_period_set(breathing_period-1);
  1198. }
  1199. /* To generate breathing curve in python:
  1200. * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
  1201. */
  1202. static const uint8_t breathing_table[BREATHING_STEPS] PROGMEM = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 17, 20, 24, 28, 32, 36, 41, 46, 51, 57, 63, 70, 76, 83, 91, 98, 106, 113, 121, 129, 138, 146, 154, 162, 170, 178, 185, 193, 200, 207, 213, 220, 225, 231, 235, 240, 244, 247, 250, 252, 253, 254, 255, 254, 253, 252, 250, 247, 244, 240, 235, 231, 225, 220, 213, 207, 200, 193, 185, 178, 170, 162, 154, 146, 138, 129, 121, 113, 106, 98, 91, 83, 76, 70, 63, 57, 51, 46, 41, 36, 32, 28, 24, 20, 17, 15, 12, 10, 8, 6, 5, 4, 3, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  1203. // Use this before the cie_lightness function.
  1204. static inline uint16_t scale_backlight(uint16_t v) {
  1205. return v / BACKLIGHT_LEVELS * get_backlight_level();
  1206. }
  1207. /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
  1208. * about 244 times per second.
  1209. */
  1210. ISR(TIMER1_OVF_vect)
  1211. {
  1212. uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
  1213. // resetting after one period to prevent ugly reset at overflow.
  1214. breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
  1215. uint8_t index = breathing_counter / interval % BREATHING_STEPS;
  1216. if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
  1217. ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
  1218. {
  1219. breathing_interrupt_disable();
  1220. }
  1221. set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
  1222. }
  1223. #endif // BACKLIGHT_BREATHING
  1224. __attribute__ ((weak))
  1225. void backlight_init_ports(void)
  1226. {
  1227. // Setup backlight pin as output and output to on state.
  1228. // DDRx |= n
  1229. _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
  1230. #if BACKLIGHT_ON_STATE == 0
  1231. // PORTx &= ~n
  1232. _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
  1233. #else
  1234. // PORTx |= n
  1235. _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
  1236. #endif
  1237. // I could write a wall of text here to explain... but TL;DW
  1238. // Go read the ATmega32u4 datasheet.
  1239. // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
  1240. // Pin PB7 = OCR1C (Timer 1, Channel C)
  1241. // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
  1242. // (i.e. start high, go low when counter matches.)
  1243. // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
  1244. // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
  1245. /*
  1246. 14.8.3:
  1247. "In fast PWM mode, the compare units allow generation of PWM waveforms on the OCnx pins. Setting the COMnx1:0 bits to two will produce a non-inverted PWM [..]."
  1248. "In fast PWM mode the counter is incremented until the counter value matches either one of the fixed values 0x00FF, 0x01FF, or 0x03FF (WGMn3:0 = 5, 6, or 7), the value in ICRn (WGMn3:0 = 14), or the value in OCRnA (WGMn3:0 = 15)."
  1249. */
  1250. TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010;
  1251. TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
  1252. // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
  1253. ICRx = TIMER_TOP;
  1254. backlight_init();
  1255. #ifdef BACKLIGHT_BREATHING
  1256. breathing_enable();
  1257. #endif
  1258. }
  1259. #endif // NO_HARDWARE_PWM
  1260. #else // backlight
  1261. __attribute__ ((weak))
  1262. void backlight_init_ports(void) {}
  1263. __attribute__ ((weak))
  1264. void backlight_set(uint8_t level) {}
  1265. #endif // backlight
  1266. #ifdef HD44780_ENABLED
  1267. #include "hd44780.h"
  1268. #endif
  1269. // Functions for spitting out values
  1270. //
  1271. void send_dword(uint32_t number) { // this might not actually work
  1272. uint16_t word = (number >> 16);
  1273. send_word(word);
  1274. send_word(number & 0xFFFFUL);
  1275. }
  1276. void send_word(uint16_t number) {
  1277. uint8_t byte = number >> 8;
  1278. send_byte(byte);
  1279. send_byte(number & 0xFF);
  1280. }
  1281. void send_byte(uint8_t number) {
  1282. uint8_t nibble = number >> 4;
  1283. send_nibble(nibble);
  1284. send_nibble(number & 0xF);
  1285. }
  1286. void send_nibble(uint8_t number) {
  1287. switch (number) {
  1288. case 0:
  1289. register_code(KC_0);
  1290. unregister_code(KC_0);
  1291. break;
  1292. case 1 ... 9:
  1293. register_code(KC_1 + (number - 1));
  1294. unregister_code(KC_1 + (number - 1));
  1295. break;
  1296. case 0xA ... 0xF:
  1297. register_code(KC_A + (number - 0xA));
  1298. unregister_code(KC_A + (number - 0xA));
  1299. break;
  1300. }
  1301. }
  1302. __attribute__((weak))
  1303. uint16_t hex_to_keycode(uint8_t hex)
  1304. {
  1305. hex = hex & 0xF;
  1306. if (hex == 0x0) {
  1307. return KC_0;
  1308. } else if (hex < 0xA) {
  1309. return KC_1 + (hex - 0x1);
  1310. } else {
  1311. return KC_A + (hex - 0xA);
  1312. }
  1313. }
  1314. void api_send_unicode(uint32_t unicode) {
  1315. #ifdef API_ENABLE
  1316. uint8_t chunk[4];
  1317. dword_to_bytes(unicode, chunk);
  1318. MT_SEND_DATA(DT_UNICODE, chunk, 5);
  1319. #endif
  1320. }
  1321. __attribute__ ((weak))
  1322. void led_set_user(uint8_t usb_led) {
  1323. }
  1324. __attribute__ ((weak))
  1325. void led_set_kb(uint8_t usb_led) {
  1326. led_set_user(usb_led);
  1327. }
  1328. __attribute__ ((weak))
  1329. void led_init_ports(void)
  1330. {
  1331. }
  1332. __attribute__ ((weak))
  1333. void led_set(uint8_t usb_led)
  1334. {
  1335. // Example LED Code
  1336. //
  1337. // // Using PE6 Caps Lock LED
  1338. // if (usb_led & (1<<USB_LED_CAPS_LOCK))
  1339. // {
  1340. // // Output high.
  1341. // DDRE |= (1<<6);
  1342. // PORTE |= (1<<6);
  1343. // }
  1344. // else
  1345. // {
  1346. // // Output low.
  1347. // DDRE &= ~(1<<6);
  1348. // PORTE &= ~(1<<6);
  1349. // }
  1350. #if defined(BACKLIGHT_CAPS_LOCK) && defined(BACKLIGHT_ENABLE)
  1351. // Use backlight as Caps Lock indicator
  1352. uint8_t bl_toggle_lvl = 0;
  1353. if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK) && !backlight_config.enable) {
  1354. // Turning Caps Lock ON and backlight is disabled in config
  1355. // Toggling backlight to the brightest level
  1356. bl_toggle_lvl = BACKLIGHT_LEVELS;
  1357. } else if (IS_LED_OFF(usb_led, USB_LED_CAPS_LOCK) && backlight_config.enable) {
  1358. // Turning Caps Lock OFF and backlight is enabled in config
  1359. // Toggling backlight and restoring config level
  1360. bl_toggle_lvl = backlight_config.level;
  1361. }
  1362. // Set level without modify backlight_config to keep ability to restore state
  1363. backlight_set(bl_toggle_lvl);
  1364. #endif
  1365. led_set_kb(usb_led);
  1366. }
  1367. //------------------------------------------------------------------------------
  1368. // Override these functions in your keymap file to play different tunes on
  1369. // different events such as startup and bootloader jump
  1370. __attribute__ ((weak))
  1371. void startup_user() {}
  1372. __attribute__ ((weak))
  1373. void shutdown_user() {}
  1374. //------------------------------------------------------------------------------