logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

v0x_dualencoder.c (3106B)

    

  1. /* Copyright 2020 imchipwood
  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"
  18. void keyboard_pre_init_kb(void) {
  19.     // Set LED IO as outputs
  20.     gpio_set_pin_output(LED_00);
  21.     gpio_set_pin_output(LED_01);
  22.     keyboard_pre_init_user();
  23. }
  25. bool shutdown_kb(bool jump_to_bootloader) {
  26.     if (!shutdown_user(jump_to_bootloader)) {
  27.         return false;
  28.     }
  29.     // Shutdown LEDs
  30.     gpio_write_pin_low(LED_00);
  31.     gpio_write_pin_low(LED_01);
  32.     return true;
  33. }
  35. layer_state_t layer_state_set_kb(layer_state_t state) {
  36.     // Layer LEDs act as binary indication of current layer
  37.     uint8_t layer = get_highest_layer(state);
  38.     gpio_write_pin(LED_00, layer & 0b1);
  39.     gpio_write_pin(LED_01, (layer >> 1) & 0b1);
  40.     return layer_state_set_user(state);
  41. }
  43. // Optional override functions below.
  44. // You can leave any or all of these undefined.
  45. // These are only required if you want to perform custom actions.
  47. void matrix_init_kb(void) {
  48.     // put your keyboard start-up code here
  49.     // runs once when the firmware starts up
  50.     uint8_t led_delay_ms = 80;
  51.     for (int i = 0; i < 2; i++) {
  52.         gpio_write_pin_high(LED_00);
  53.         gpio_write_pin_high(LED_01);
  54.         wait_ms(led_delay_ms);
  55.         gpio_write_pin_low(LED_00);
  56.         gpio_write_pin_low(LED_01);
  57.         if (i < 1) {
  58.             wait_ms(led_delay_ms);
  59.         }
  60.     }
  62.     matrix_init_user();
  63. }
  65. bool encoder_update_kb(uint8_t index, bool clockwise) {
  66.     if (!encoder_update_user(index, clockwise)) { return false; }
  68.     if (index == 0) {
  69.         switch (get_highest_layer(layer_state)) {
  70.             case 0:
  71.                 if (clockwise) {
  72.                     tap_code(KC_MS_R);
  73.                 } else {
  74.                     tap_code(KC_MS_L);
  75.                 }
  76.                 break;
  78.             default:
  79.                 if (clockwise) {
  80.                     tap_code(KC_EQL);
  81.                 } else {
  82.                     tap_code(KC_MINS);
  83.                 }
  84.                 break;
  85.         }
  86.     } else if (index == 1) {
  87.         switch (get_highest_layer(layer_state)) {
  88.             case 0:
  89.                 if (clockwise) {
  90.                     tap_code(KC_VOLU);
  91.                 } else {
  92.                     tap_code(KC_VOLD);
  93.                 }
  94.                 break;
  96.             default:
  97.                 if (clockwise) {
  98.                     tap_code(KC_RIGHT);
  99.                 } else {
  100.                     tap_code(KC_LEFT);
  101.                 }
  102.                 break;
  103.         }
  104.     }
  105.     return true;
  106. }