diff options
| author | QMK Bot <hello@qmk.fm> | 2021-03-17 17:02:38 +0000 |
|---|---|---|
| committer | QMK Bot <hello@qmk.fm> | 2021-03-17 17:02:38 +0000 |
| commit | 3367705ac2fe18fb7901dabca9a65c3f110852c7 (patch) | |
| tree | 53351bd8ffa6b39208425bc579dd66f64b44ce12 | |
| parent | 66713446026e43899ff94c305dbca7907d2dc3bc (diff) | |
| parent | 6e79767f5aa0bad763639846d44c69d3990c7cbe (diff) | |
| download | qmk_firmware-3367705ac2fe18fb7901dabca9a65c3f110852c7.tar.gz qmk_firmware-3367705ac2fe18fb7901dabca9a65c3f110852c7.zip | |
Merge remote-tracking branch 'origin/master' into develop
5 files changed, 908 insertions, 0 deletions
diff --git a/keyboards/dztech/dz65rgb/keymaps/jumper149/config.h b/keyboards/dztech/dz65rgb/keymaps/jumper149/config.h new file mode 100644 index 000000000..d9d295dfa --- /dev/null +++ b/keyboards/dztech/dz65rgb/keymaps/jumper149/config.h | |||
| @@ -0,0 +1,63 @@ | |||
| 1 | /* Copyright 2021 Felix Springer | ||
| 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 | #pragma once | ||
| 17 | |||
| 18 | #define FORCE_NKRO | ||
| 19 | |||
| 20 | #ifdef RGB_MATRIX_ENABLE | ||
| 21 | |||
| 22 | #define DISABLE_RGB_MATRIX_ALPHAS_MODS | ||
| 23 | #define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN | ||
| 24 | #define DISABLE_RGB_MATRIX_BREATHING | ||
| 25 | #define DISABLE_RGB_MATRIX_BAND_SAT | ||
| 26 | #define DISABLE_RGB_MATRIX_BAND_VAL | ||
| 27 | #define DISABLE_RGB_MATRIX_BAND_PINWHEEL_SAT | ||
| 28 | #define DISABLE_RGB_MATRIX_BAND_PINWHEEL_VAL | ||
| 29 | #define DISABLE_RGB_MATRIX_BAND_SPIRAL_SAT | ||
| 30 | #define DISABLE_RGB_MATRIX_BAND_SPIRAL_VAL | ||
| 31 | #define DISABLE_RGB_MATRIX_CYCLE_ALL | ||
| 32 | #define DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT | ||
| 33 | #define DISABLE_RGB_MATRIX_CYCLE_UP_DOWN | ||
| 34 | #define DISABLE_RGB_MATRIX_CYCLE_OUT_IN | ||
| 35 | #define DISABLE_RGB_MATRIX_CYCLE_OUT_IN_DUAL | ||
| 36 | #define DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON | ||
| 37 | #define DISABLE_RGB_MATRIX_DUAL_BEACON | ||
| 38 | #define DISABLE_RGB_MATRIX_CYCLE_PINWHEEL | ||
| 39 | #define DISABLE_RGB_MATRIX_CYCLE_SPIRAL | ||
| 40 | #define DISABLE_RGB_MATRIX_RAINBOW_BEACON | ||
| 41 | #define DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS | ||
| 42 | #define DISABLE_RGB_MATRIX_RAINDROPS | ||
| 43 | #define DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS | ||
| 44 | #define DISABLE_RGB_MATRIX_TYPING_HEATMAP | ||
| 45 | #define DISABLE_RGB_MATRIX_DIGITAL_RAIN | ||
| 46 | #define DISABLE_RGB_MATRIX_SOLID_REACTIVE | ||
| 47 | #define DISABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE | ||
| 48 | #define DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE | ||
| 49 | #define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE | ||
| 50 | #define DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS | ||
| 51 | #define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS | ||
| 52 | #define DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS | ||
| 53 | #define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS | ||
| 54 | #define DISABLE_RGB_MATRIX_SPLASH | ||
| 55 | #define DISABLE_RGB_MATRIX_MULTISPLASH | ||
| 56 | #define DISABLE_RGB_MATRIX_SOLID_SPLASH | ||
| 57 | #define DISABLE_RGB_MATRIX_SOLID_MULTISPLASH | ||
| 58 | |||
| 59 | // Fix RGB_MATRIX_STARTUP, because RGB_MATRIX_CYCLE_ALL is disabled. | ||
| 60 | // The actual handling of RGB_EFFECTs is done in keymap.c | ||
| 61 | #undef RGB_MATRIX_STARTUP_MODE | ||
| 62 | |||
| 63 | #endif | ||
diff --git a/keyboards/dztech/dz65rgb/keymaps/jumper149/keymap.c b/keyboards/dztech/dz65rgb/keymaps/jumper149/keymap.c new file mode 100644 index 000000000..b166a5629 --- /dev/null +++ b/keyboards/dztech/dz65rgb/keymaps/jumper149/keymap.c | |||
| @@ -0,0 +1,120 @@ | |||
| 1 | /* Copyright 2021 Felix Springer | ||
| 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 QMK_KEYBOARD_H | ||
| 17 | |||
| 18 | enum layers_user { | ||
| 19 | _QWERTY, | ||
| 20 | _AD, | ||
| 21 | _VI, | ||
| 22 | _FN, | ||
| 23 | _KB | ||
| 24 | }; | ||
| 25 | |||
| 26 | enum keycodes_user { | ||
| 27 | _BASEEF = SAFE_RANGE, | ||
| 28 | _KITTEF | ||
| 29 | }; | ||
| 30 | |||
| 31 | int selected_mode_user = RGB_MATRIX_CUSTOM_base_effect; // for layer_state_set_user() | ||
| 32 | bool process_record_user(uint16_t keycode, keyrecord_t * record) { | ||
| 33 | switch (keycode) { | ||
| 34 | case _BASEEF: | ||
| 35 | if (record->event.pressed) { | ||
| 36 | selected_mode_user = RGB_MATRIX_CUSTOM_base_effect; | ||
| 37 | } | ||
| 38 | return false; | ||
| 39 | case _KITTEF: | ||
| 40 | if (record->event.pressed) { | ||
| 41 | selected_mode_user = RGB_MATRIX_CUSTOM_kitt_effect; | ||
| 42 | } | ||
| 43 | return false; | ||
| 44 | default: | ||
| 45 | return true; | ||
| 46 | } | ||
| 47 | } | ||
| 48 | |||
| 49 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | ||
| 50 | [_QWERTY] = LAYOUT_65_ansi( | ||
| 51 | KC_GRAVE, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_HOME, | ||
| 52 | KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, KC_PGUP, | ||
| 53 | KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KC_PGDN, | ||
| 54 | KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP, KC_END, | ||
| 55 | KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, MO(_FN), KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT | ||
| 56 | ), | ||
| 57 | [_AD] = LAYOUT_65_ansi( | ||
| 58 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_DEL, | ||
| 59 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_INS, | ||
| 60 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_HOME, | ||
| 61 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_END, | ||
| 62 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ | ||
| 63 | ), | ||
| 64 | [_VI] = LAYOUT_65_ansi( | ||
| 65 | KC_ESC, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, | ||
| 66 | _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_PGUP, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, | ||
| 67 | KC_ESC, XXXXXXX, XXXXXXX, KC_PGDN, XXXXXXX, XXXXXXX, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, XXXXXXX, XXXXXXX, _______, XXXXXXX, | ||
| 68 | _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_FIND, _______, _______, XXXXXXX, | ||
| 69 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ | ||
| 70 | ), | ||
| 71 | [_FN] = LAYOUT_65_ansi( | ||
| 72 | XXXXXXX, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_DEL, KC_INS, | ||
| 73 | XXXXXXX, KC_MUTE, KC_VOLU, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_PSCR, KC_SLCK, KC_PAUS, XXXXXXX, KC_PSTE, | ||
| 74 | CTL_T(KC_CAPS), KC_BRID, KC_VOLD, KC_BRIU, XXXXXXX, XXXXXXX, TG(_AD), TG(_VI), XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_COPY, | ||
| 75 | KC_LSFT, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_APP, XXXXXXX, XXXXXXX, XXXXXXX, KC_RSFT, KC_MSTP, KC_CUT, | ||
| 76 | KC_LCTL, KC_LGUI, KC_LALT, XXXXXXX, MO(_KB), XXXXXXX, KC_RCTL, KC_MPRV, KC_MPLY, KC_MNXT | ||
| 77 | ), | ||
| 78 | [_KB] = LAYOUT_65_ansi( | ||
| 79 | XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_SPI, RGB_SPD, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RESET, XXXXXXX, | ||
| 80 | XXXXXXX, RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, | ||
| 81 | XXXXXXX, XXXXXXX, RGB_SAI, RGB_SAD, XXXXXXX, XXXXXXX, _BASEEF, _KITTEF, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, EEP_RST, XXXXXXX, | ||
| 82 | KC_LSFT, RGB_VAI, RGB_VAD, XXXXXXX, XXXXXXX, XXXXXXX, NK_TOGG, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_RSFT, XXXXXXX, XXXXXXX, | ||
| 83 | XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX | ||
| 84 | ) | ||
| 85 | /* | ||
| 86 | [_LEDS] = LAYOUT_65_ansi( | ||
| 87 | 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 , 12 , 13 , 14 , | ||
| 88 | 15 , 16 Q, 17 W, 18 E, 19 R, 20 T, 21 Y, 22 U, 23 I, 24 O, 25 P, 26 , 27 , 28 , 29 , | ||
| 89 | 30 , 31 A, 32 S, 33 D, 34 F, 35 G, 36 H, 37 J, 38 K, 39 L, 40 , 41 , 42 , 43 , | ||
| 90 | 44 , 45 Z, 46 X, 47 C, 48 V, 49 B, 50 N, 51 M, 52 , 53 , 54 , 55 , 56 , 57 , | ||
| 91 | 58 , 59 , 60 , 61 , 62 , 63 , 64 , 65 , 66 , 67 | ||
| 92 | ) | ||
| 93 | */ | ||
| 94 | }; | ||
| 95 | |||
| 96 | layer_state_t layer_state_set_user(layer_state_t state) { | ||
| 97 | switch (get_highest_layer(state)) { | ||
| 98 | case _QWERTY: | ||
| 99 | rgb_matrix_mode(selected_mode_user); | ||
| 100 | break; | ||
| 101 | case _AD: | ||
| 102 | if (selected_mode_user == RGB_MATRIX_CUSTOM_base_effect) { | ||
| 103 | rgb_matrix_mode(RGB_MATRIX_CUSTOM_base_ad_effect); | ||
| 104 | } else { | ||
| 105 | rgb_matrix_mode(selected_mode_user); | ||
| 106 | } | ||
| 107 | break; | ||
| 108 | case _VI: | ||
| 109 | rgb_matrix_mode(RGB_MATRIX_CUSTOM_vi_effect); | ||
| 110 | break; | ||
| 111 | case _FN: | ||
| 112 | rgb_matrix_mode(RGB_MATRIX_CUSTOM_fn_indicator); | ||
| 113 | break; | ||
| 114 | case _KB: | ||
| 115 | rgb_matrix_mode(RGB_MATRIX_CUSTOM_kb_indicator); | ||
| 116 | break; | ||
| 117 | } | ||
| 118 | |||
| 119 | return state; | ||
| 120 | } | ||
diff --git a/keyboards/dztech/dz65rgb/keymaps/jumper149/readme.md b/keyboards/dztech/dz65rgb/keymaps/jumper149/readme.md new file mode 100644 index 000000000..d87258731 --- /dev/null +++ b/keyboards/dztech/dz65rgb/keymaps/jumper149/readme.md | |||
| @@ -0,0 +1,24 @@ | |||
| 1 | # jumper149's DZ65RGB v2 | ||
| 2 | |||
| 3 | Run commands in the root directory of this repository. | ||
| 4 | |||
| 5 | ``` | ||
| 6 | ./bin/qmk compile && sudo dfu-programmer atmega32u4 erase && sudo dfu-programmer atmega32u4 flash ./dztech_dz65rgb_v2_jumper149.hex && sudo dfu-programmer atmega32u4 reset | ||
| 7 | ``` | ||
| 8 | |||
| 9 | ## build | ||
| 10 | |||
| 11 | ``` | ||
| 12 | ./bin/qmk compile | ||
| 13 | ``` | ||
| 14 | |||
| 15 | ## flash | ||
| 16 | |||
| 17 | Use `qmk flash` or if it is broken (unknown reason) you can try this workaround. | ||
| 18 | I personally had some problems on ArchLinux, that I didn't debug any further though. | ||
| 19 | |||
| 20 | ``` | ||
| 21 | sudo dfu-programmer atmega32u4 erase | ||
| 22 | sudo dfu-programmer atmega32u4 flash ./dztech_dz65rgb_v2_jumper149.hex | ||
| 23 | sudo dfu-programmer atmega32u4 reset | ||
| 24 | ``` | ||
diff --git a/keyboards/dztech/dz65rgb/keymaps/jumper149/rgb_matrix_user.inc b/keyboards/dztech/dz65rgb/keymaps/jumper149/rgb_matrix_user.inc new file mode 100644 index 000000000..8d99ff948 --- /dev/null +++ b/keyboards/dztech/dz65rgb/keymaps/jumper149/rgb_matrix_user.inc | |||
| @@ -0,0 +1,700 @@ | |||
| 1 | /* Copyright 2021 Felix Springer | ||
| 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 | RGB_MATRIX_EFFECT(base_effect) | ||
| 17 | RGB_MATRIX_EFFECT(base_ad_effect) | ||
| 18 | RGB_MATRIX_EFFECT(vi_effect) | ||
| 19 | RGB_MATRIX_EFFECT(fn_indicator) | ||
| 20 | RGB_MATRIX_EFFECT(kb_indicator) | ||
| 21 | RGB_MATRIX_EFFECT(kitt_effect) | ||
| 22 | |||
| 23 | #ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS | ||
| 24 | |||
| 25 | /* | ||
| 26 | [_LEDS] = LAYOUT_65_ansi( | ||
| 27 | 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 , 12 , 13 , 14 , | ||
| 28 | 15 , 16 Q, 17 W, 18 E, 19 R, 20 T, 21 Y, 22 U, 23 I, 24 O, 25 P, 26 , 27 , 28 , 29 , | ||
| 29 | 30 , 31 A, 32 S, 33 D, 34 F, 35 G, 36 H, 37 J, 38 K, 39 L, 40 , 41 , 42 , 43 , | ||
| 30 | 44 , 45 Z, 46 X, 47 C, 48 V, 49 B, 50 N, 51 M, 52 , 53 , 54 , 55 , 56 , 57 , | ||
| 31 | 58 , 59 , 60 , 61 , 62 , 63 , 64 , 65 , 66 , 67 | ||
| 32 | ) | ||
| 33 | */ | ||
| 34 | |||
| 35 | // variable for startup animation | ||
| 36 | bool BASE_EFFECT_NOT_STARTED_YET = true; | ||
| 37 | uint8_t base_effect_startup_counter = 255; | ||
| 38 | |||
| 39 | static HSV base_effect_math(HSV hsv, uint8_t i, uint8_t time) { | ||
| 40 | |||
| 41 | if (BASE_EFFECT_NOT_STARTED_YET) { | ||
| 42 | base_effect_startup_counter = 0; | ||
| 43 | BASE_EFFECT_NOT_STARTED_YET = false; | ||
| 44 | } | ||
| 45 | |||
| 46 | // startup animation | ||
| 47 | if (base_effect_startup_counter < 255) { | ||
| 48 | |||
| 49 | // jump to correct indices for alpha keys | ||
| 50 | if (i == 0) { // only run for one key (key 0 is an arbitrary choice) | ||
| 51 | if (base_effect_startup_counter == 0) { | ||
| 52 | base_effect_startup_counter = 1; | ||
| 53 | } else if (base_effect_startup_counter == 1) { | ||
| 54 | base_effect_startup_counter = 17; | ||
| 55 | } else if (base_effect_startup_counter == 26) { | ||
| 56 | base_effect_startup_counter = 31; | ||
| 57 | } else if (base_effect_startup_counter == 40) { | ||
| 58 | base_effect_startup_counter = 45; | ||
| 59 | } else if (base_effect_startup_counter == 52) { | ||
| 60 | base_effect_startup_counter = 100; | ||
| 61 | } else if (base_effect_startup_counter == 120) { | ||
| 62 | base_effect_startup_counter = 255; | ||
| 63 | } else { | ||
| 64 | base_effect_startup_counter++; | ||
| 65 | } | ||
| 66 | } | ||
| 67 | |||
| 68 | // overwrite some highlit keys | ||
| 69 | if (3 + 39 - i < base_effect_startup_counter - 100 && i >= 36 && i <= 39) { | ||
| 70 | hsv.s = hsv.s; | ||
| 71 | } else if (3 + 39 - i < base_effect_startup_counter - 100 && i >= 31 && i <= 34) { | ||
| 72 | hsv.s = hsv.s; | ||
| 73 | // light up alpha keys | ||
| 74 | } else if (i < base_effect_startup_counter && i >= 16 && i <= 25) { | ||
| 75 | hsv.s = 0; | ||
| 76 | } else if (31 + 39 - i < base_effect_startup_counter && i >= 31 && i <= 39) { | ||
| 77 | hsv.s = 0; | ||
| 78 | } else if (i < base_effect_startup_counter && i >= 45 && i <= 51) { | ||
| 79 | hsv.s = 0; | ||
| 80 | // light up number row | ||
| 81 | } else if (12 + 1 - i < base_effect_startup_counter - 100 && i == 2) { | ||
| 82 | hsv.s = 0; | ||
| 83 | hsv.v = 1 * (hsv.v / 8); | ||
| 84 | } else if (12 + 1 - i < base_effect_startup_counter - 100 && i == 3) { | ||
| 85 | hsv.s = 0; | ||
| 86 | hsv.v = 2 * (hsv.v / 8); | ||
| 87 | } else if (12 + 1 - i < base_effect_startup_counter - 100 && i == 4) { | ||
| 88 | hsv.s = 0; | ||
| 89 | hsv.v = 3 * (hsv.v / 8); | ||
| 90 | } else if (12 + 1 - i < base_effect_startup_counter - 100 && i >= 5 && i <= 8) { | ||
| 91 | hsv.v = hsv.v; | ||
| 92 | } else if (12 + 1 - i < base_effect_startup_counter - 100 && i == 9) { | ||
| 93 | hsv.s = 0; | ||
| 94 | hsv.v = 3 * (hsv.v / 8); | ||
| 95 | } else if (12 + 1 - i < base_effect_startup_counter - 100 && i == 10) { | ||
| 96 | hsv.s = 0; | ||
| 97 | hsv.v = 2 * (hsv.v / 8); | ||
| 98 | } else if (12 + 1 - i < base_effect_startup_counter - 100 && i == 11) { | ||
| 99 | hsv.s = 0; | ||
| 100 | hsv.v = 1 * (hsv.v / 8); | ||
| 101 | // light up punctuation keys | ||
| 102 | } else if (27 + 1 - i < base_effect_startup_counter - 100 && i >= 26 && i <= 27) { | ||
| 103 | hsv.s = 0; | ||
| 104 | hsv.v = hsv.v / 8; | ||
| 105 | } else if (41 + 2 - i < base_effect_startup_counter - 100 && i >= 40 && i <= 41) { | ||
| 106 | hsv.s = 0; | ||
| 107 | hsv.v = hsv.v / 8; | ||
| 108 | } else if (54 + 3 - i < base_effect_startup_counter - 100 && i >= 52 && i <= 54) { | ||
| 109 | hsv.s = 0; | ||
| 110 | hsv.v = hsv.v / 8; | ||
| 111 | // rest | ||
| 112 | } else { | ||
| 113 | hsv.v = 0; | ||
| 114 | } | ||
| 115 | |||
| 116 | } else { | ||
| 117 | |||
| 118 | switch (i) { | ||
| 119 | |||
| 120 | // number row | ||
| 121 | case 0: | ||
| 122 | hsv.v = 0; | ||
| 123 | break; | ||
| 124 | case 1: | ||
| 125 | hsv.v = 0; | ||
| 126 | break; | ||
| 127 | case 2: | ||
| 128 | hsv.s = 0; | ||
| 129 | hsv.v = 1 * (hsv.v / 8); | ||
| 130 | break; | ||
| 131 | case 3: | ||
| 132 | hsv.s = 0; | ||
| 133 | hsv.v = 2 * (hsv.v / 8); | ||
| 134 | break; | ||
| 135 | case 4: | ||
| 136 | hsv.s = 0; | ||
| 137 | hsv.v = 3 * (hsv.v / 8); | ||
| 138 | break; | ||
| 139 | case 5: | ||
| 140 | hsv.v = hsv.v; | ||
| 141 | break; | ||
| 142 | case 6: | ||
| 143 | hsv.v = hsv.v; | ||
| 144 | break; | ||
| 145 | case 7: | ||
| 146 | hsv.v = hsv.v; | ||
| 147 | break; | ||
| 148 | case 8: | ||
| 149 | hsv.v = hsv.v; | ||
| 150 | break; | ||
| 151 | case 9: | ||
| 152 | hsv.s = 0; | ||
| 153 | hsv.v = 3 * (hsv.v / 8); | ||
| 154 | break; | ||
| 155 | case 10: | ||
| 156 | hsv.s = 0; | ||
| 157 | hsv.v = 2 * (hsv.v / 8); | ||
| 158 | break; | ||
| 159 | case 11: | ||
| 160 | hsv.s = 0; | ||
| 161 | hsv.v = 1 * (hsv.v / 8); | ||
| 162 | break; | ||
| 163 | case 12: | ||
| 164 | hsv.v = 0; | ||
| 165 | break; | ||
| 166 | |||
| 167 | // punctuation keys | ||
| 168 | case 26: | ||
| 169 | hsv.s = 0; | ||
| 170 | hsv.v = hsv.v / 8; | ||
| 171 | break; | ||
| 172 | case 27: | ||
| 173 | hsv.s = 0; | ||
| 174 | hsv.v = hsv.v / 8; | ||
| 175 | break; | ||
| 176 | case 40: | ||
| 177 | hsv.s = 0; | ||
| 178 | hsv.v = hsv.v / 8; | ||
| 179 | break; | ||
| 180 | case 41: | ||
| 181 | hsv.s = 0; | ||
| 182 | hsv.v = hsv.v / 8; | ||
| 183 | break; | ||
| 184 | case 52: | ||
| 185 | hsv.s = 0; | ||
| 186 | hsv.v = hsv.v / 8; | ||
| 187 | break; | ||
| 188 | case 53: | ||
| 189 | hsv.s = 0; | ||
| 190 | hsv.v = hsv.v / 8; | ||
| 191 | break; | ||
| 192 | case 54: | ||
| 193 | hsv.s = 0; | ||
| 194 | hsv.v = hsv.v / 8; | ||
| 195 | break; | ||
| 196 | |||
| 197 | default: | ||
| 198 | if ( | ||
| 199 | (i > 15 && i <= 25) || | ||
| 200 | (i > 30 && i <= 39) || | ||
| 201 | (i > 44 && i <= 51) | ||
| 202 | ) { | ||
| 203 | if (i > 35 && i <= 39) { | ||
| 204 | hsv.s = hsv.s; | ||
| 205 | } else if (i > 30 && i <= 34) { | ||
| 206 | hsv.s = hsv.s; | ||
| 207 | } else { | ||
| 208 | hsv.s = 0; | ||
| 209 | } | ||
| 210 | } else { | ||
| 211 | hsv.v = 0; | ||
| 212 | } | ||
| 213 | break; | ||
| 214 | |||
| 215 | } | ||
| 216 | |||
| 217 | } | ||
| 218 | |||
| 219 | return hsv; | ||
| 220 | } | ||
| 221 | |||
| 222 | bool base_effect(effect_params_t* params) { | ||
| 223 | return effect_runner_i(params, &base_effect_math); | ||
| 224 | } | ||
| 225 | |||
| 226 | static HSV base_ad_effect_math(HSV hsv, uint8_t i, uint8_t time) { | ||
| 227 | |||
| 228 | // no startup animation | ||
| 229 | if (BASE_EFFECT_NOT_STARTED_YET) { | ||
| 230 | base_effect_startup_counter = 255; // act like startup is already completed | ||
| 231 | BASE_EFFECT_NOT_STARTED_YET = false; | ||
| 232 | } | ||
| 233 | |||
| 234 | switch (i) { | ||
| 235 | |||
| 236 | // delete | ||
| 237 | case 14: | ||
| 238 | hsv.h = 0; | ||
| 239 | hsv.s = 255; | ||
| 240 | break; | ||
| 241 | |||
| 242 | // insert | ||
| 243 | case 29: | ||
| 244 | hsv.h = 255/3; | ||
| 245 | hsv.s = 255; | ||
| 246 | break; | ||
| 247 | |||
| 248 | // home | ||
| 249 | case 43: | ||
| 250 | hsv.s = 0; | ||
| 251 | break; | ||
| 252 | |||
| 253 | // end | ||
| 254 | case 57: | ||
| 255 | hsv.s = 255; | ||
| 256 | break; | ||
| 257 | |||
| 258 | default: | ||
| 259 | hsv = base_effect_math(hsv, i, time); | ||
| 260 | break; | ||
| 261 | |||
| 262 | } | ||
| 263 | |||
| 264 | return hsv; | ||
| 265 | } | ||
| 266 | |||
| 267 | bool base_ad_effect(effect_params_t* params) { | ||
| 268 | return effect_runner_i(params, &base_ad_effect_math); | ||
| 269 | } | ||
| 270 | |||
| 271 | static HSV vi_effect_math(HSV hsv, uint8_t i, uint8_t time) { | ||
| 272 | |||
| 273 | // no startup animation | ||
| 274 | if (BASE_EFFECT_NOT_STARTED_YET) { | ||
| 275 | base_effect_startup_counter = 255; // act like startup is already completed | ||
| 276 | BASE_EFFECT_NOT_STARTED_YET = false; | ||
| 277 | } | ||
| 278 | |||
| 279 | switch (i) { | ||
| 280 | |||
| 281 | // hjkl | ||
| 282 | case 36: | ||
| 283 | break; | ||
| 284 | case 37: | ||
| 285 | break; | ||
| 286 | case 38: | ||
| 287 | break; | ||
| 288 | case 39: | ||
| 289 | break; | ||
| 290 | |||
| 291 | // page up | ||
| 292 | case 22: | ||
| 293 | hsv.s = 0; | ||
| 294 | break; | ||
| 295 | |||
| 296 | // page down | ||
| 297 | case 33: | ||
| 298 | hsv.s = 0; | ||
| 299 | break; | ||
| 300 | |||
| 301 | // find | ||
| 302 | case 54: | ||
| 303 | hsv.s = 0; | ||
| 304 | break; | ||
| 305 | |||
| 306 | default: | ||
| 307 | hsv.v = 0; | ||
| 308 | break; | ||
| 309 | |||
| 310 | } | ||
| 311 | |||
| 312 | return hsv; | ||
| 313 | } | ||
| 314 | |||
| 315 | bool vi_effect(effect_params_t* params) { | ||
| 316 | return effect_runner_i(params, &vi_effect_math); | ||
| 317 | } | ||
| 318 | |||
| 319 | static HSV fn_indicator_math(HSV hsv, uint8_t i, uint8_t time) { | ||
| 320 | |||
| 321 | // cancel base effect startup | ||
| 322 | base_effect_startup_counter = 255; | ||
| 323 | |||
| 324 | switch (i) { | ||
| 325 | |||
| 326 | // F1 - F12 | ||
| 327 | case 1: | ||
| 328 | hsv.h = 0 * 255 / 3; | ||
| 329 | hsv.s = 255; | ||
| 330 | break; | ||
| 331 | case 2: | ||
| 332 | hsv.h = 0 * 255 / 3; | ||
| 333 | hsv.s = 255; | ||
| 334 | break; | ||
| 335 | case 3: | ||
| 336 | hsv.h = 0 * 255 / 3; | ||
| 337 | hsv.s = 255; | ||
| 338 | break; | ||
| 339 | case 4: | ||
| 340 | hsv.h = 0 * 255 / 3; | ||
| 341 | hsv.s = 255; | ||
| 342 | break; | ||
| 343 | case 5: | ||
| 344 | hsv.h = 1 * 255 / 3; | ||
| 345 | hsv.s = 255; | ||
| 346 | break; | ||
| 347 | case 6: | ||
| 348 | hsv.h = 1 * 255 / 3; | ||
| 349 | hsv.s = 255; | ||
| 350 | break; | ||
| 351 | case 7: | ||
| 352 | hsv.h = 1 * 255 / 3; | ||
| 353 | hsv.s = 255; | ||
| 354 | break; | ||
| 355 | case 8: | ||
| 356 | hsv.h = 1 * 255 / 3; | ||
| 357 | hsv.s = 255; | ||
| 358 | break; | ||
| 359 | case 9: | ||
| 360 | hsv.h = 2 * 255 / 3; | ||
| 361 | hsv.s = 255; | ||
| 362 | break; | ||
| 363 | case 10: | ||
| 364 | hsv.h = 2 * 255 / 3; | ||
| 365 | hsv.s = 255; | ||
| 366 | break; | ||
| 367 | case 11: | ||
| 368 | hsv.h = 2 * 255 / 3; | ||
| 369 | hsv.s = 255; | ||
| 370 | break; | ||
| 371 | case 12: | ||
| 372 | hsv.h = 2 * 255 / 3; | ||
| 373 | hsv.s = 255; | ||
| 374 | break; | ||
| 375 | |||
| 376 | // delete/insert | ||
| 377 | case 13: | ||
| 378 | hsv.h = 0; | ||
| 379 | hsv.s = 255; | ||
| 380 | break; | ||
| 381 | case 14: | ||
| 382 | hsv.h = 1 * (255 / 3); | ||
| 383 | hsv.s = 255; | ||
| 384 | break; | ||
| 385 | |||
| 386 | // paste/copy/cut | ||
| 387 | case 29: | ||
| 388 | hsv.s = 0; | ||
| 389 | break; | ||
| 390 | case 43: | ||
| 391 | hsv.h = 200; | ||
| 392 | hsv.s = 255; | ||
| 393 | break; | ||
| 394 | case 57: | ||
| 395 | hsv.h = 0; | ||
| 396 | hsv.s = 255; | ||
| 397 | break; | ||
| 398 | |||
| 399 | // print/scroll/pause | ||
| 400 | case 25: | ||
| 401 | hsv.s = 0; | ||
| 402 | break; | ||
| 403 | case 26: | ||
| 404 | hsv.s = 0; | ||
| 405 | break; | ||
| 406 | case 27: | ||
| 407 | hsv.s = 0; | ||
| 408 | break; | ||
| 409 | |||
| 410 | // caps lock | ||
| 411 | case 30: | ||
| 412 | hsv.s = 0; | ||
| 413 | break; | ||
| 414 | |||
| 415 | // modifier | ||
| 416 | case 44: | ||
| 417 | hsv.s = 0; | ||
| 418 | hsv.v = hsv.v / 2; | ||
| 419 | break; | ||
| 420 | case 55: | ||
| 421 | hsv.s = 0; | ||
| 422 | hsv.v = hsv.v / 2; | ||
| 423 | break; | ||
| 424 | case 58: | ||
| 425 | hsv.s = 0; | ||
| 426 | hsv.v = hsv.v / 2; | ||
| 427 | break; | ||
| 428 | case 59: | ||
| 429 | hsv.s = 0; | ||
| 430 | hsv.v = hsv.v / 2; | ||
| 431 | break; | ||
| 432 | case 60: | ||
| 433 | hsv.s = 0; | ||
| 434 | hsv.v = hsv.v / 2; | ||
| 435 | break; | ||
| 436 | case 64: | ||
| 437 | hsv.s = 0; | ||
| 438 | hsv.v = hsv.v / 2; | ||
| 439 | break; | ||
| 440 | |||
| 441 | // volume | ||
| 442 | case 18: // mute | ||
| 443 | hsv.h = 0; | ||
| 444 | break; | ||
| 445 | case 17: // increase | ||
| 446 | hsv.s = 255; | ||
| 447 | break; | ||
| 448 | case 32: // decrease | ||
| 449 | hsv.s = 0; | ||
| 450 | break; | ||
| 451 | |||
| 452 | // brightness | ||
| 453 | case 33: // increase | ||
| 454 | hsv.s = 255; | ||
| 455 | break; | ||
| 456 | case 31: // decrease | ||
| 457 | hsv.s = 0; | ||
| 458 | break; | ||
| 459 | |||
| 460 | // media | ||
| 461 | case 65: // previous | ||
| 462 | hsv.s = 0; | ||
| 463 | break; | ||
| 464 | case 67: // next | ||
| 465 | hsv.s = 0; | ||
| 466 | break; | ||
| 467 | case 56: // stop | ||
| 468 | hsv.h = 0; | ||
| 469 | break; | ||
| 470 | case 66: // play/pause | ||
| 471 | hsv.h = 255/3; | ||
| 472 | break; | ||
| 473 | |||
| 474 | // menu | ||
| 475 | case 51: | ||
| 476 | hsv.s = 0; | ||
| 477 | break; | ||
| 478 | |||
| 479 | // toggle AD layer | ||
| 480 | case 36: | ||
| 481 | hsv.h = 0; | ||
| 482 | break; | ||
| 483 | |||
| 484 | // toggle VI layer | ||
| 485 | case 37: | ||
| 486 | hsv.h = 255/3; | ||
| 487 | break; | ||
| 488 | |||
| 489 | // KB layer | ||
| 490 | case 62: | ||
| 491 | hsv.h = time; | ||
| 492 | hsv.s = 255; | ||
| 493 | break; | ||
| 494 | |||
| 495 | // no function | ||
| 496 | default: | ||
| 497 | hsv.v = 0; | ||
| 498 | break; | ||
| 499 | |||
| 500 | } | ||
| 501 | |||
| 502 | return hsv; | ||
| 503 | } | ||
| 504 | |||
| 505 | bool fn_indicator(effect_params_t* params) { | ||
| 506 | return effect_runner_i(params, &fn_indicator_math); | ||
| 507 | } | ||
| 508 | |||
| 509 | static HSV kb_indicator_math(HSV hsv, uint8_t i, uint8_t time) { | ||
| 510 | |||
| 511 | // cancel base effect startup | ||
| 512 | base_effect_startup_counter = 255; | ||
| 513 | |||
| 514 | switch (i) { | ||
| 515 | |||
| 516 | // test HSV | ||
| 517 | case 14: | ||
| 518 | break; | ||
| 519 | case 29: | ||
| 520 | break; | ||
| 521 | case 43: | ||
| 522 | break; | ||
| 523 | case 57: | ||
| 524 | break; | ||
| 525 | case 67: | ||
| 526 | break; | ||
| 527 | |||
| 528 | // toggle RGB | ||
| 529 | case 16: | ||
| 530 | hsv.s = 0; | ||
| 531 | if (time < (255 / 2)) { | ||
| 532 | hsv.v = 255; | ||
| 533 | } else { | ||
| 534 | hsv.v = 0; | ||
| 535 | } | ||
| 536 | break; | ||
| 537 | |||
| 538 | // cycle effect | ||
| 539 | case 17: | ||
| 540 | hsv.s = 255; | ||
| 541 | hsv.v = 255; | ||
| 542 | if (time < (255 / 3)) { | ||
| 543 | hsv.h = 0; | ||
| 544 | } else if (time < (2 * 255 / 3)) { | ||
| 545 | hsv.h = 255 / 3; | ||
| 546 | } else { | ||
| 547 | hsv.h = 2 * 255 / 3; | ||
| 548 | } | ||
| 549 | break; | ||
| 550 | |||
| 551 | // adjust hue | ||
| 552 | case 18: | ||
| 553 | hsv.h = time; | ||
| 554 | hsv.s = 255; | ||
| 555 | hsv.v = 255; | ||
| 556 | break; | ||
| 557 | case 19: | ||
| 558 | hsv.h = 255 - time; | ||
| 559 | hsv.s = 255; | ||
| 560 | hsv.v = 255; | ||
| 561 | break; | ||
| 562 | |||
| 563 | // adjust saturation | ||
| 564 | case 32: | ||
| 565 | hsv.s = 255; | ||
| 566 | hsv.v = 255; | ||
| 567 | break; | ||
| 568 | case 33: | ||
| 569 | hsv.s = 0; | ||
| 570 | hsv.v = 255; | ||
| 571 | break; | ||
| 572 | |||
| 573 | // adjust value | ||
| 574 | case 45: | ||
| 575 | hsv.v = 255; | ||
| 576 | break; | ||
| 577 | case 46: | ||
| 578 | hsv.v = 63; | ||
| 579 | break; | ||
| 580 | |||
| 581 | // adjust speed | ||
| 582 | case 4: | ||
| 583 | if (((time / 8) % 2) == 0) { | ||
| 584 | hsv.v = 255; | ||
| 585 | } else { | ||
| 586 | hsv.v = 63; | ||
| 587 | } | ||
| 588 | break; | ||
| 589 | case 5: | ||
| 590 | if (((time / 16) % 2) == 0) { | ||
| 591 | hsv.v = 63; | ||
| 592 | } else { | ||
| 593 | hsv.v = 255; | ||
| 594 | } | ||
| 595 | break; | ||
| 596 | |||
| 597 | // set main effect | ||
| 598 | case 36: // BASE | ||
| 599 | hsv.s = 0; | ||
| 600 | break; | ||
| 601 | case 37: // KITT | ||
| 602 | hsv.h = 0; | ||
| 603 | hsv.s = 255; | ||
| 604 | if (time < 128) { | ||
| 605 | hsv.v = time; | ||
| 606 | } else { | ||
| 607 | hsv.v = 255 - time; | ||
| 608 | } | ||
| 609 | break; | ||
| 610 | |||
| 611 | // reset (for flashing) | ||
| 612 | case 13: | ||
| 613 | hsv.s = 0; | ||
| 614 | if (time < 16) { | ||
| 615 | hsv.v = 255 - time * 128 / 16; | ||
| 616 | } else { | ||
| 617 | hsv.v = 127; | ||
| 618 | } | ||
| 619 | break; | ||
| 620 | |||
| 621 | // reset (reinitialize EEPROM) | ||
| 622 | case 42: | ||
| 623 | hsv.s = 0; | ||
| 624 | hsv.v = 127; | ||
| 625 | break; | ||
| 626 | |||
| 627 | // shift | ||
| 628 | case 44: | ||
| 629 | hsv.s = 0; | ||
| 630 | hsv.v = 63; | ||
| 631 | break; | ||
| 632 | case 55: | ||
| 633 | hsv.s = 0; | ||
| 634 | hsv.v = 63; | ||
| 635 | break; | ||
| 636 | |||
| 637 | // no function | ||
| 638 | default: | ||
| 639 | hsv.v = 0; | ||
| 640 | |||
| 641 | } | ||
| 642 | |||
| 643 | return hsv; | ||
| 644 | } | ||
| 645 | |||
| 646 | bool kb_indicator(effect_params_t* params) { | ||
| 647 | return effect_runner_i(params, &kb_indicator_math); | ||
| 648 | } | ||
| 649 | |||
| 650 | uint8_t led_count = 7; | ||
| 651 | uint8_t led_first = 33; | ||
| 652 | static uint8_t time_to_led(uint8_t time, uint8_t led_behind) { | ||
| 653 | uint16_t led_time = led_count * time; | ||
| 654 | uint16_t step = ((2 * led_count + (led_time / 128)) - led_behind) % (2 * led_count); | ||
| 655 | uint8_t led; | ||
| 656 | if (step < led_count) { | ||
| 657 | led = step; | ||
| 658 | } else { | ||
| 659 | led = led_count - 1 - (step - led_count); | ||
| 660 | } | ||
| 661 | return led; | ||
| 662 | } | ||
| 663 | |||
| 664 | static HSV kitt_effect_math(HSV hsv, uint8_t i, uint8_t time) { | ||
| 665 | |||
| 666 | // reset base effect startup | ||
| 667 | if (i == 0) { | ||
| 668 | BASE_EFFECT_NOT_STARTED_YET = true; | ||
| 669 | } | ||
| 670 | |||
| 671 | hsv.h = 0; | ||
| 672 | hsv.s = 255; | ||
| 673 | |||
| 674 | if (i >= led_first && i < led_first + led_count) { | ||
| 675 | uint8_t j = i - led_first; | ||
| 676 | if (j == time_to_led(time, 0)) { | ||
| 677 | hsv.v = hsv.v; | ||
| 678 | } else if (j == time_to_led(time, 1)) { | ||
| 679 | hsv.v = hsv.v/2; | ||
| 680 | } else if (j == time_to_led(time, 2)) { | ||
| 681 | hsv.v = hsv.v/4; | ||
| 682 | } else if (j == time_to_led(time, 3)) { | ||
| 683 | hsv.v = hsv.v/8; | ||
| 684 | } else { | ||
| 685 | hsv.v = 0; | ||
| 686 | } | ||
| 687 | } else { | ||
| 688 | hsv.v = 0; | ||
| 689 | } | ||
| 690 | |||
| 691 | return hsv; | ||
| 692 | } | ||
| 693 | |||
| 694 | bool kitt_effect(effect_params_t* params) { | ||
| 695 | return effect_runner_i(params, &kitt_effect_math); | ||
| 696 | } | ||
| 697 | |||
| 698 | #endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS | ||
| 699 | |||
| 700 | // vim: syntax=c | ||
diff --git a/keyboards/dztech/dz65rgb/keymaps/jumper149/rules.mk b/keyboards/dztech/dz65rgb/keymaps/jumper149/rules.mk new file mode 100644 index 000000000..6245023e8 --- /dev/null +++ b/keyboards/dztech/dz65rgb/keymaps/jumper149/rules.mk | |||
| @@ -0,0 +1 @@ | |||
| RGB_MATRIX_CUSTOM_USER = yes | |||
