quantum.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853
  1. #include "quantum.h"
  2. static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
  3. switch (code) {
  4. case QK_MODS ... QK_MODS_MAX:
  5. break;
  6. default:
  7. return;
  8. }
  9. if (code & QK_LCTL)
  10. f(KC_LCTL);
  11. if (code & QK_LSFT)
  12. f(KC_LSFT);
  13. if (code & QK_LALT)
  14. f(KC_LALT);
  15. if (code & QK_LGUI)
  16. f(KC_LGUI);
  17. if (code & QK_RCTL)
  18. f(KC_RCTL);
  19. if (code & QK_RSFT)
  20. f(KC_RSFT);
  21. if (code & QK_RALT)
  22. f(KC_RALT);
  23. if (code & QK_RGUI)
  24. f(KC_RGUI);
  25. }
  26. void register_code16 (uint16_t code) {
  27. do_code16 (code, register_code);
  28. register_code (code);
  29. }
  30. void unregister_code16 (uint16_t code) {
  31. unregister_code (code);
  32. do_code16 (code, unregister_code);
  33. }
  34. __attribute__ ((weak))
  35. bool process_action_kb(keyrecord_t *record) {
  36. return true;
  37. }
  38. __attribute__ ((weak))
  39. bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
  40. return process_record_user(keycode, record);
  41. }
  42. __attribute__ ((weak))
  43. bool process_record_user(uint16_t keycode, keyrecord_t *record) {
  44. return true;
  45. }
  46. void reset_keyboard(void) {
  47. clear_keyboard();
  48. #ifdef AUDIO_ENABLE
  49. stop_all_notes();
  50. shutdown_user();
  51. #endif
  52. wait_ms(250);
  53. #ifdef CATERINA_BOOTLOADER
  54. *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
  55. #endif
  56. bootloader_jump();
  57. }
  58. // Shift / paren setup
  59. #ifndef LSPO_KEY
  60. #define LSPO_KEY KC_9
  61. #endif
  62. #ifndef RSPC_KEY
  63. #define RSPC_KEY KC_0
  64. #endif
  65. static bool shift_interrupted[2] = {0, 0};
  66. bool process_record_quantum(keyrecord_t *record) {
  67. /* This gets the keycode from the key pressed */
  68. keypos_t key = record->event.key;
  69. uint16_t keycode;
  70. #if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
  71. /* TODO: Use store_or_get_action() or a similar function. */
  72. if (!disable_action_cache) {
  73. uint8_t layer;
  74. if (record->event.pressed) {
  75. layer = layer_switch_get_layer(key);
  76. update_source_layers_cache(key, layer);
  77. } else {
  78. layer = read_source_layers_cache(key);
  79. }
  80. keycode = keymap_key_to_keycode(layer, key);
  81. } else
  82. #endif
  83. keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
  84. // This is how you use actions here
  85. // if (keycode == KC_LEAD) {
  86. // action_t action;
  87. // action.code = ACTION_DEFAULT_LAYER_SET(0);
  88. // process_action(record, action);
  89. // return false;
  90. // }
  91. if (!(
  92. process_record_kb(keycode, record) &&
  93. #ifdef MIDI_ENABLE
  94. process_midi(keycode, record) &&
  95. #endif
  96. #ifdef AUDIO_ENABLE
  97. process_music(keycode, record) &&
  98. #endif
  99. #ifdef TAP_DANCE_ENABLE
  100. process_tap_dance(keycode, record) &&
  101. #endif
  102. #ifndef DISABLE_LEADER
  103. process_leader(keycode, record) &&
  104. #endif
  105. #ifndef DISABLE_CHORDING
  106. process_chording(keycode, record) &&
  107. #endif
  108. #ifdef UNICODE_ENABLE
  109. process_unicode(keycode, record) &&
  110. #endif
  111. #ifdef UCIS_ENABLE
  112. process_ucis(keycode, record) &&
  113. #endif
  114. #ifdef UNICODEMAP_ENABLE
  115. process_unicode_map(keycode, record) &&
  116. #endif
  117. true)) {
  118. return false;
  119. }
  120. // Shift / paren setup
  121. switch(keycode) {
  122. case RESET:
  123. if (record->event.pressed) {
  124. reset_keyboard();
  125. }
  126. return false;
  127. break;
  128. case DEBUG:
  129. if (record->event.pressed) {
  130. print("\nDEBUG: enabled.\n");
  131. debug_enable = true;
  132. }
  133. return false;
  134. break;
  135. #ifdef RGBLIGHT_ENABLE
  136. case RGB_TOG:
  137. if (record->event.pressed) {
  138. rgblight_toggle();
  139. }
  140. return false;
  141. break;
  142. case RGB_MOD:
  143. if (record->event.pressed) {
  144. rgblight_step();
  145. }
  146. return false;
  147. break;
  148. case RGB_HUI:
  149. if (record->event.pressed) {
  150. rgblight_increase_hue();
  151. }
  152. return false;
  153. break;
  154. case RGB_HUD:
  155. if (record->event.pressed) {
  156. rgblight_decrease_hue();
  157. }
  158. return false;
  159. break;
  160. case RGB_SAI:
  161. if (record->event.pressed) {
  162. rgblight_increase_sat();
  163. }
  164. return false;
  165. break;
  166. case RGB_SAD:
  167. if (record->event.pressed) {
  168. rgblight_decrease_sat();
  169. }
  170. return false;
  171. break;
  172. case RGB_VAI:
  173. if (record->event.pressed) {
  174. rgblight_increase_val();
  175. }
  176. return false;
  177. break;
  178. case RGB_VAD:
  179. if (record->event.pressed) {
  180. rgblight_decrease_val();
  181. }
  182. return false;
  183. break;
  184. #endif
  185. case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
  186. if (record->event.pressed) {
  187. // MAGIC actions (BOOTMAGIC without the boot)
  188. if (!eeconfig_is_enabled()) {
  189. eeconfig_init();
  190. }
  191. /* keymap config */
  192. keymap_config.raw = eeconfig_read_keymap();
  193. switch (keycode)
  194. {
  195. case MAGIC_SWAP_CONTROL_CAPSLOCK:
  196. keymap_config.swap_control_capslock = true;
  197. break;
  198. case MAGIC_CAPSLOCK_TO_CONTROL:
  199. keymap_config.capslock_to_control = true;
  200. break;
  201. case MAGIC_SWAP_LALT_LGUI:
  202. keymap_config.swap_lalt_lgui = true;
  203. break;
  204. case MAGIC_SWAP_RALT_RGUI:
  205. keymap_config.swap_ralt_rgui = true;
  206. break;
  207. case MAGIC_NO_GUI:
  208. keymap_config.no_gui = true;
  209. break;
  210. case MAGIC_SWAP_GRAVE_ESC:
  211. keymap_config.swap_grave_esc = true;
  212. break;
  213. case MAGIC_SWAP_BACKSLASH_BACKSPACE:
  214. keymap_config.swap_backslash_backspace = true;
  215. break;
  216. case MAGIC_HOST_NKRO:
  217. keymap_config.nkro = true;
  218. break;
  219. case MAGIC_SWAP_ALT_GUI:
  220. keymap_config.swap_lalt_lgui = true;
  221. keymap_config.swap_ralt_rgui = true;
  222. break;
  223. case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
  224. keymap_config.swap_control_capslock = false;
  225. break;
  226. case MAGIC_UNCAPSLOCK_TO_CONTROL:
  227. keymap_config.capslock_to_control = false;
  228. break;
  229. case MAGIC_UNSWAP_LALT_LGUI:
  230. keymap_config.swap_lalt_lgui = false;
  231. break;
  232. case MAGIC_UNSWAP_RALT_RGUI:
  233. keymap_config.swap_ralt_rgui = false;
  234. break;
  235. case MAGIC_UNNO_GUI:
  236. keymap_config.no_gui = false;
  237. break;
  238. case MAGIC_UNSWAP_GRAVE_ESC:
  239. keymap_config.swap_grave_esc = false;
  240. break;
  241. case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
  242. keymap_config.swap_backslash_backspace = false;
  243. break;
  244. case MAGIC_UNHOST_NKRO:
  245. keymap_config.nkro = false;
  246. break;
  247. case MAGIC_UNSWAP_ALT_GUI:
  248. keymap_config.swap_lalt_lgui = false;
  249. keymap_config.swap_ralt_rgui = false;
  250. break;
  251. case MAGIC_TOGGLE_NKRO:
  252. keymap_config.nkro = !keymap_config.nkro;
  253. break;
  254. default:
  255. break;
  256. }
  257. eeconfig_update_keymap(keymap_config.raw);
  258. clear_keyboard(); // clear to prevent stuck keys
  259. return false;
  260. }
  261. break;
  262. case KC_LSPO: {
  263. if (record->event.pressed) {
  264. shift_interrupted[0] = false;
  265. register_mods(MOD_BIT(KC_LSFT));
  266. }
  267. else {
  268. #ifdef DISABLE_SPACE_CADET_ROLLOVER
  269. if (get_mods() & MOD_BIT(KC_RSFT)) {
  270. shift_interrupted[0] = true;
  271. shift_interrupted[1] = true;
  272. }
  273. #endif
  274. if (!shift_interrupted[0]) {
  275. register_code(LSPO_KEY);
  276. unregister_code(LSPO_KEY);
  277. }
  278. unregister_mods(MOD_BIT(KC_LSFT));
  279. }
  280. return false;
  281. // break;
  282. }
  283. case KC_RSPC: {
  284. if (record->event.pressed) {
  285. shift_interrupted[1] = false;
  286. register_mods(MOD_BIT(KC_RSFT));
  287. }
  288. else {
  289. #ifdef DISABLE_SPACE_CADET_ROLLOVER
  290. if (get_mods() & MOD_BIT(KC_LSFT)) {
  291. shift_interrupted[0] = true;
  292. shift_interrupted[1] = true;
  293. }
  294. #endif
  295. if (!shift_interrupted[1]) {
  296. register_code(RSPC_KEY);
  297. unregister_code(RSPC_KEY);
  298. }
  299. unregister_mods(MOD_BIT(KC_RSFT));
  300. }
  301. return false;
  302. // break;
  303. }
  304. default: {
  305. shift_interrupted[0] = true;
  306. shift_interrupted[1] = true;
  307. break;
  308. }
  309. }
  310. return process_action_kb(record);
  311. }
  312. const bool ascii_to_qwerty_shift_lut[0x80] PROGMEM = {
  313. 0, 0, 0, 0, 0, 0, 0, 0,
  314. 0, 0, 0, 0, 0, 0, 0, 0,
  315. 0, 0, 0, 0, 0, 0, 0, 0,
  316. 0, 0, 0, 0, 0, 0, 0, 0,
  317. 0, 1, 1, 1, 1, 1, 1, 0,
  318. 1, 1, 1, 1, 0, 0, 0, 0,
  319. 0, 0, 0, 0, 0, 0, 0, 0,
  320. 0, 0, 1, 0, 1, 0, 1, 1,
  321. 1, 1, 1, 1, 1, 1, 1, 1,
  322. 1, 1, 1, 1, 1, 1, 1, 1,
  323. 1, 1, 1, 1, 1, 1, 1, 1,
  324. 1, 1, 1, 0, 0, 0, 1, 1,
  325. 0, 0, 0, 0, 0, 0, 0, 0,
  326. 0, 0, 0, 0, 0, 0, 0, 0,
  327. 0, 0, 0, 0, 0, 0, 0, 0,
  328. 0, 0, 0, 1, 1, 1, 1, 0
  329. };
  330. const uint8_t ascii_to_qwerty_keycode_lut[0x80] PROGMEM = {
  331. 0, 0, 0, 0, 0, 0, 0, 0,
  332. KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
  333. 0, 0, 0, 0, 0, 0, 0, 0,
  334. 0, 0, 0, KC_ESC, 0, 0, 0, 0,
  335. KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
  336. KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
  337. KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
  338. KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
  339. KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
  340. KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
  341. KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
  342. KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
  343. KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
  344. KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
  345. KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
  346. KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
  347. };
  348. /* for users whose OSes are set to Colemak */
  349. #if 0
  350. #include "keymap_colemak.h"
  351. const bool ascii_to_colemak_shift_lut[0x80] PROGMEM = {
  352. 0, 0, 0, 0, 0, 0, 0, 0,
  353. 0, 0, 0, 0, 0, 0, 0, 0,
  354. 0, 0, 0, 0, 0, 0, 0, 0,
  355. 0, 0, 0, 0, 0, 0, 0, 0,
  356. 0, 1, 1, 1, 1, 1, 1, 0,
  357. 1, 1, 1, 1, 0, 0, 0, 0,
  358. 0, 0, 0, 0, 0, 0, 0, 0,
  359. 0, 0, 1, 0, 1, 0, 1, 1,
  360. 1, 1, 1, 1, 1, 1, 1, 1,
  361. 1, 1, 1, 1, 1, 1, 1, 1,
  362. 1, 1, 1, 1, 1, 1, 1, 1,
  363. 1, 1, 1, 0, 0, 0, 1, 1,
  364. 0, 0, 0, 0, 0, 0, 0, 0,
  365. 0, 0, 0, 0, 0, 0, 0, 0,
  366. 0, 0, 0, 0, 0, 0, 0, 0,
  367. 0, 0, 0, 1, 1, 1, 1, 0
  368. };
  369. const uint8_t ascii_to_colemak_keycode_lut[0x80] PROGMEM = {
  370. 0, 0, 0, 0, 0, 0, 0, 0,
  371. KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
  372. 0, 0, 0, 0, 0, 0, 0, 0,
  373. 0, 0, 0, KC_ESC, 0, 0, 0, 0,
  374. KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
  375. KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
  376. KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
  377. KC_8, KC_9, CM_SCLN, CM_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
  378. KC_2, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
  379. CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
  380. CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
  381. CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
  382. KC_GRV, CM_A, CM_B, CM_C, CM_D, CM_E, CM_F, CM_G,
  383. CM_H, CM_I, CM_J, CM_K, CM_L, CM_M, CM_N, CM_O,
  384. CM_P, CM_Q, CM_R, CM_S, CM_T, CM_U, CM_V, CM_W,
  385. CM_X, CM_Y, CM_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
  386. };
  387. #endif
  388. void send_string(const char *str) {
  389. while (1) {
  390. uint8_t keycode;
  391. uint8_t ascii_code = pgm_read_byte(str);
  392. if (!ascii_code) break;
  393. keycode = pgm_read_byte(&ascii_to_qwerty_keycode_lut[ascii_code]);
  394. if (pgm_read_byte(&ascii_to_qwerty_shift_lut[ascii_code])) {
  395. register_code(KC_LSFT);
  396. register_code(keycode);
  397. unregister_code(keycode);
  398. unregister_code(KC_LSFT);
  399. }
  400. else {
  401. register_code(keycode);
  402. unregister_code(keycode);
  403. }
  404. ++str;
  405. }
  406. }
  407. void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
  408. if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
  409. layer_on(layer3);
  410. } else {
  411. layer_off(layer3);
  412. }
  413. }
  414. void tap_random_base64(void) {
  415. #if defined(__AVR_ATmega32U4__)
  416. uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
  417. #else
  418. uint8_t key = rand() % 64;
  419. #endif
  420. switch (key) {
  421. case 0 ... 25:
  422. register_code(KC_LSFT);
  423. register_code(key + KC_A);
  424. unregister_code(key + KC_A);
  425. unregister_code(KC_LSFT);
  426. break;
  427. case 26 ... 51:
  428. register_code(key - 26 + KC_A);
  429. unregister_code(key - 26 + KC_A);
  430. break;
  431. case 52:
  432. register_code(KC_0);
  433. unregister_code(KC_0);
  434. break;
  435. case 53 ... 61:
  436. register_code(key - 53 + KC_1);
  437. unregister_code(key - 53 + KC_1);
  438. break;
  439. case 62:
  440. register_code(KC_LSFT);
  441. register_code(KC_EQL);
  442. unregister_code(KC_EQL);
  443. unregister_code(KC_LSFT);
  444. break;
  445. case 63:
  446. register_code(KC_SLSH);
  447. unregister_code(KC_SLSH);
  448. break;
  449. }
  450. }
  451. void matrix_init_quantum() {
  452. #ifdef BACKLIGHT_ENABLE
  453. backlight_init_ports();
  454. #endif
  455. matrix_init_kb();
  456. }
  457. void matrix_scan_quantum() {
  458. #ifdef AUDIO_ENABLE
  459. matrix_scan_music();
  460. #endif
  461. #ifdef TAP_DANCE_ENABLE
  462. matrix_scan_tap_dance();
  463. #endif
  464. matrix_scan_kb();
  465. }
  466. #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
  467. static const uint8_t backlight_pin = BACKLIGHT_PIN;
  468. #if BACKLIGHT_PIN == B7
  469. # define COM1x1 COM1C1
  470. # define OCR1x OCR1C
  471. #elif BACKLIGHT_PIN == B6
  472. # define COM1x1 COM1B1
  473. # define OCR1x OCR1B
  474. #elif BACKLIGHT_PIN == B5
  475. # define COM1x1 COM1A1
  476. # define OCR1x OCR1A
  477. #else
  478. # error "Backlight pin not supported - use B5, B6, or B7"
  479. #endif
  480. __attribute__ ((weak))
  481. void backlight_init_ports(void)
  482. {
  483. // Setup backlight pin as output and output low.
  484. // DDRx |= n
  485. _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
  486. // PORTx &= ~n
  487. _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
  488. // Use full 16-bit resolution.
  489. ICR1 = 0xFFFF;
  490. // I could write a wall of text here to explain... but TL;DW
  491. // Go read the ATmega32u4 datasheet.
  492. // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
  493. // Pin PB7 = OCR1C (Timer 1, Channel C)
  494. // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
  495. // (i.e. start high, go low when counter matches.)
  496. // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
  497. // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
  498. TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
  499. TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
  500. backlight_init();
  501. #ifdef BACKLIGHT_BREATHING
  502. breathing_defaults();
  503. #endif
  504. }
  505. __attribute__ ((weak))
  506. void backlight_set(uint8_t level)
  507. {
  508. // Prevent backlight blink on lowest level
  509. // PORTx &= ~n
  510. _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
  511. if ( level == 0 ) {
  512. // Turn off PWM control on backlight pin, revert to output low.
  513. TCCR1A &= ~(_BV(COM1x1));
  514. OCR1x = 0x0;
  515. } else if ( level == BACKLIGHT_LEVELS ) {
  516. // Turn on PWM control of backlight pin
  517. TCCR1A |= _BV(COM1x1);
  518. // Set the brightness
  519. OCR1x = 0xFFFF;
  520. } else {
  521. // Turn on PWM control of backlight pin
  522. TCCR1A |= _BV(COM1x1);
  523. // Set the brightness
  524. OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
  525. }
  526. #ifdef BACKLIGHT_BREATHING
  527. breathing_intensity_default();
  528. #endif
  529. }
  530. #ifdef BACKLIGHT_BREATHING
  531. #define BREATHING_NO_HALT 0
  532. #define BREATHING_HALT_OFF 1
  533. #define BREATHING_HALT_ON 2
  534. static uint8_t breath_intensity;
  535. static uint8_t breath_speed;
  536. static uint16_t breathing_index;
  537. static uint8_t breathing_halt;
  538. void breathing_enable(void)
  539. {
  540. if (get_backlight_level() == 0)
  541. {
  542. breathing_index = 0;
  543. }
  544. else
  545. {
  546. // Set breathing_index to be at the midpoint (brightest point)
  547. breathing_index = 0x20 << breath_speed;
  548. }
  549. breathing_halt = BREATHING_NO_HALT;
  550. // Enable breathing interrupt
  551. TIMSK1 |= _BV(OCIE1A);
  552. }
  553. void breathing_pulse(void)
  554. {
  555. if (get_backlight_level() == 0)
  556. {
  557. breathing_index = 0;
  558. }
  559. else
  560. {
  561. // Set breathing_index to be at the midpoint + 1 (brightest point)
  562. breathing_index = 0x21 << breath_speed;
  563. }
  564. breathing_halt = BREATHING_HALT_ON;
  565. // Enable breathing interrupt
  566. TIMSK1 |= _BV(OCIE1A);
  567. }
  568. void breathing_disable(void)
  569. {
  570. // Disable breathing interrupt
  571. TIMSK1 &= ~_BV(OCIE1A);
  572. backlight_set(get_backlight_level());
  573. }
  574. void breathing_self_disable(void)
  575. {
  576. if (get_backlight_level() == 0)
  577. {
  578. breathing_halt = BREATHING_HALT_OFF;
  579. }
  580. else
  581. {
  582. breathing_halt = BREATHING_HALT_ON;
  583. }
  584. //backlight_set(get_backlight_level());
  585. }
  586. void breathing_toggle(void)
  587. {
  588. if (!is_breathing())
  589. {
  590. if (get_backlight_level() == 0)
  591. {
  592. breathing_index = 0;
  593. }
  594. else
  595. {
  596. // Set breathing_index to be at the midpoint + 1 (brightest point)
  597. breathing_index = 0x21 << breath_speed;
  598. }
  599. breathing_halt = BREATHING_NO_HALT;
  600. }
  601. // Toggle breathing interrupt
  602. TIMSK1 ^= _BV(OCIE1A);
  603. // Restore backlight level
  604. if (!is_breathing())
  605. {
  606. backlight_set(get_backlight_level());
  607. }
  608. }
  609. bool is_breathing(void)
  610. {
  611. return (TIMSK1 && _BV(OCIE1A));
  612. }
  613. void breathing_intensity_default(void)
  614. {
  615. //breath_intensity = (uint8_t)((uint16_t)100 * (uint16_t)get_backlight_level() / (uint16_t)BACKLIGHT_LEVELS);
  616. breath_intensity = ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2));
  617. }
  618. void breathing_intensity_set(uint8_t value)
  619. {
  620. breath_intensity = value;
  621. }
  622. void breathing_speed_default(void)
  623. {
  624. breath_speed = 4;
  625. }
  626. void breathing_speed_set(uint8_t value)
  627. {
  628. bool is_breathing_now = is_breathing();
  629. uint8_t old_breath_speed = breath_speed;
  630. if (is_breathing_now)
  631. {
  632. // Disable breathing interrupt
  633. TIMSK1 &= ~_BV(OCIE1A);
  634. }
  635. breath_speed = value;
  636. if (is_breathing_now)
  637. {
  638. // Adjust index to account for new speed
  639. breathing_index = (( (uint8_t)( (breathing_index) >> old_breath_speed ) ) & 0x3F) << breath_speed;
  640. // Enable breathing interrupt
  641. TIMSK1 |= _BV(OCIE1A);
  642. }
  643. }
  644. void breathing_speed_inc(uint8_t value)
  645. {
  646. if ((uint16_t)(breath_speed - value) > 10 )
  647. {
  648. breathing_speed_set(0);
  649. }
  650. else
  651. {
  652. breathing_speed_set(breath_speed - value);
  653. }
  654. }
  655. void breathing_speed_dec(uint8_t value)
  656. {
  657. if ((uint16_t)(breath_speed + value) > 10 )
  658. {
  659. breathing_speed_set(10);
  660. }
  661. else
  662. {
  663. breathing_speed_set(breath_speed + value);
  664. }
  665. }
  666. void breathing_defaults(void)
  667. {
  668. breathing_intensity_default();
  669. breathing_speed_default();
  670. breathing_halt = BREATHING_NO_HALT;
  671. }
  672. /* Breathing Sleep LED brighness(PWM On period) table
  673. * (64[steps] * 4[duration]) / 64[PWM periods/s] = 4 second breath cycle
  674. *
  675. * http://www.wolframalpha.com/input/?i=%28sin%28+x%2F64*pi%29**8+*+255%2C+x%3D0+to+63
  676. * (0..63).each {|x| p ((sin(x/64.0*PI)**8)*255).to_i }
  677. */
  678. static const uint8_t breathing_table[64] PROGMEM = {
  679. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 6, 10,
  680. 15, 23, 32, 44, 58, 74, 93, 113, 135, 157, 179, 199, 218, 233, 245, 252,
  681. 255, 252, 245, 233, 218, 199, 179, 157, 135, 113, 93, 74, 58, 44, 32, 23,
  682. 15, 10, 6, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  683. };
  684. ISR(TIMER1_COMPA_vect)
  685. {
  686. // OCR1x = (pgm_read_byte(&breathing_table[ ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F ] )) * breath_intensity;
  687. uint8_t local_index = ( (uint8_t)( (breathing_index++) >> breath_speed ) ) & 0x3F;
  688. if (((breathing_halt == BREATHING_HALT_ON) && (local_index == 0x20)) || ((breathing_halt == BREATHING_HALT_OFF) && (local_index == 0x3F)))
  689. {
  690. // Disable breathing interrupt
  691. TIMSK1 &= ~_BV(OCIE1A);
  692. }
  693. OCR1x = (uint16_t)(((uint16_t)pgm_read_byte(&breathing_table[local_index]) * 257)) >> breath_intensity;
  694. }
  695. #endif // breathing
  696. #else // backlight
  697. __attribute__ ((weak))
  698. void backlight_init_ports(void)
  699. {
  700. }
  701. __attribute__ ((weak))
  702. void backlight_set(uint8_t level)
  703. {
  704. }
  705. #endif // backlight
  706. __attribute__ ((weak))
  707. void led_set_user(uint8_t usb_led) {
  708. }
  709. __attribute__ ((weak))
  710. void led_set_kb(uint8_t usb_led) {
  711. led_set_user(usb_led);
  712. }
  713. __attribute__ ((weak))
  714. void led_init_ports(void)
  715. {
  716. }
  717. __attribute__ ((weak))
  718. void led_set(uint8_t usb_led)
  719. {
  720. // Example LED Code
  721. //
  722. // // Using PE6 Caps Lock LED
  723. // if (usb_led & (1<<USB_LED_CAPS_LOCK))
  724. // {
  725. // // Output high.
  726. // DDRE |= (1<<6);
  727. // PORTE |= (1<<6);
  728. // }
  729. // else
  730. // {
  731. // // Output low.
  732. // DDRE &= ~(1<<6);
  733. // PORTE &= ~(1<<6);
  734. // }
  735. led_set_kb(usb_led);
  736. }
  737. //------------------------------------------------------------------------------
  738. // Override these functions in your keymap file to play different tunes on
  739. // different events such as startup and bootloader jump
  740. __attribute__ ((weak))
  741. void startup_user() {}
  742. __attribute__ ((weak))
  743. void shutdown_user() {}
  744. //------------------------------------------------------------------------------