--- /dev/null
+#include QMK_KEYBOARD_H
+
+// uint8_t keyboard_leds(void)
+#include <tmk_core/protocol/arm_atsam/main_arm_atsam.h>
+
+
+#if ISSI3733_LED_COUNT == 119
+# define KEY_LED_COUNT 87
+#elif ISSI3733_LED_COUNT == 105
+# define KEY_LED_COUNT 67
+#endif
+
+#define min(x, y) (x < y ? x : y)
+
+
+extern issi3733_led_t *lede;
+extern issi3733_led_t led_map[];
+extern led_disp_t disp;
+
+enum ctrl_keycodes {
+ L_BRI = SAFE_RANGE, //LED Brightness Increase
+ L_BRD, //LED Brightness Decrease
+ L_PTN, //LED Pattern Select Next
+ L_PTP, //LED Pattern Select Previous
+ L_PSI, //LED Pattern Speed Increase
+ L_PSD, //LED Pattern Speed Decrease
+ L_T_MD, //LED Toggle Mode
+ L_T_ONF, //LED Toggle On / Off
+ L_ON, //LED On
+ L_OFF, //LED Off
+ L_T_BR, //LED Toggle Breath Effect
+ L_T_PTD, //LED Toggle Scrolling Pattern Direction
+ U_T_AUTO, //USB Extra Port Toggle Auto Detect / Always Active
+ U_T_AGCR, //USB Toggle Automatic GCR control
+ DBG_TOG, //DEBUG Toggle On / Off
+ DBG_MTRX, //DEBUG Toggle Matrix Prints
+ DBG_KBD, //DEBUG Toggle Keyboard Prints
+ DBG_MOU, //DEBUG Toggle Mouse Prints
+ MD_BOOT, //Restart into bootloader after hold timeout
+
+ L_SP_PR, //LED Splash Pattern Select Previous
+ L_SP_NE, //LED Splash Pattern Select Next
+
+ L_SP_WD, //LED Splash Widen Wavefront width
+ L_SP_NW, //LED Splash Narrow Wavefront width
+
+ L_SP_FA, //LED Splash wave travel speed faster (shorter period)
+ L_SP_SL, //LED Splash wave travel speed slower (longer period)
+
+ L_CP_PR, //LED Color Pattern Select Previous
+ L_CP_NX, //LEB Color Pattern Select Next
+};
+
+#define TG_NKRO MAGIC_TOGGLE_NKRO //Toggle 6KRO / NKRO mode
+#define ______ KC_TRNS
+
+keymap_config_t keymap_config;
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+ [0] = LAYOUT(
+ KC_ESC, 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_PSCR, KC_SLCK, KC_PAUS, \
+ KC_GRV, 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_INS, KC_HOME, KC_PGUP, \
+ 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_DEL, KC_END, KC_PGDN, \
+ KC_CAPS, 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_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_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, MO(1), KC_APP, KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT \
+ ),
+ [1] = LAYOUT(
+ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_MUTE, _______, _______, \
+ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_MPLY, KC_MSTP, KC_VOLU, \
+ L_T_BR, L_PSD, L_BRI, L_PSI, _______, _______, _______, U_T_AUTO,U_T_AGCR,_______, MO(2), _______, _______, _______, KC_MPRV, KC_MNXT, KC_VOLD, \
+ L_T_PTD, L_PTP, L_BRD, L_PTN, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+ _______, L_T_MD, L_T_ONF, _______, _______, MD_BOOT, TG_NKRO, _______, _______, _______, _______, _______, _______, \
+ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ \
+ ),
+ [2] = LAYOUT(
+ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+ L_CP_NX, L_SP_SL, L_SP_WD, L_SP_FA, _______, _______, L_CP_NX, L_SP_SL, L_SP_WD, L_SP_FA, _______, _______, _______, _______, _______, _______, _______, \
+ L_CP_PR, L_SP_PR, L_SP_NW, L_SP_NE, _______, _______, L_CP_PR, L_SP_PR, L_SP_NW, L_SP_NE, _______, _______, _______, \
+ _______, _______, _______, _______, _______, _______, TG_NKRO, _______, _______, _______, _______, _______, _______, \
+ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ \
+ ),
+ /*
+ [X] = LAYOUT(
+ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+ _______, _______, _______, _______, _______, _______, TG_NKRO, _______, _______, _______, _______, _______, _______, \
+ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ \
+ ),
+ */
+};
+
+// see: /tmk_core/common/keycode.h
+uint8_t KEYCODE_TO_LED_ID[256];
+uint8_t DISTANCE_MAP[KEY_LED_COUNT+1][KEY_LED_COUNT+1];
+struct user_led_t {
+ uint8_t state;
+ uint8_t r;
+ uint8_t g;
+ uint8_t b;
+} USER_LED[KEY_LED_COUNT] = {
+
+};
+
+struct {
+ uint8_t PATTERN_INDEX;
+ uint8_t WAVE_FRONT_WIDTH;
+ uint16_t WAVE_PERIOD;
+ uint8_t COLOR_PATTERN_INDEX;
+ uint8_t TRAVEL_DISTANCE;
+} USER_CONFIG = {
+ .PATTERN_INDEX = 1,
+ .WAVE_FRONT_WIDTH = 3,
+ .WAVE_PERIOD = 50,
+ .COLOR_PATTERN_INDEX = 0,
+ .TRAVEL_DISTANCE = 25,
+};
+
+uint8_t ktli(uint16_t keycode){
+ if(keycode < 256){
+ // the array is initialized in `matrix_init_user()`
+ return KEYCODE_TO_LED_ID[keycode];
+ }
+ switch(keycode){
+ // definition of MO(layer): quantum/quantum_keycodes.h: line 614
+ case MO(1): return 82;
+ }
+ return 0;
+};
+
+// Runs just one time when the keyboard initializes.
+static void init_keycode_to_led_map(void){
+ uint16_t LED_MAP[MATRIX_ROWS][MATRIX_COLS] = LAYOUT(
+ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,
+ 20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,
+ 36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,
+ 52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,
+#if KEY_LED_COUNT >= 87
+ 68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87
+#endif
+ );
+
+ uint16_t key = 0;
+ for(uint8_t y = 0; y < MATRIX_ROWS; ++y){
+ for(uint8_t x = 0; x < MATRIX_COLS; ++x){
+ key = keymaps[0][y][x];
+ if(key < 256){
+ KEYCODE_TO_LED_ID[key] = LED_MAP[y][x];
+ }
+ }
+ }
+}
+// https://docs.qmk.fm/#/feature_terminal
+#define KEY_POSITION_MAP_ROWS 6
+#define KEY_POSITION_MAP_COLUMNS 20
+static void init_distance_map(void){
+ uint16_t KEY_POSITION_MAP[KEY_POSITION_MAP_ROWS][KEY_POSITION_MAP_COLUMNS] = {
+ { KC_NO, KC_ESC, KC_NO, KC_F1, KC_F2, KC_F3, KC_F4, KC_NO, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_NO, KC_PSCR, KC_SLCK, KC_PAUS, },
+ // { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, },
+ { KC_NO, KC_GRV, 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_BSPC, KC_NO, KC_INS, KC_HOME, KC_PGUP, },
+ { KC_NO, 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_BSLS, KC_NO, KC_DEL, KC_END, KC_PGDN, },
+ { KC_NO, KC_CAPS, 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_ENT, KC_ENT, KC_NO, KC_NO, KC_NO, KC_NO, },
+ { KC_NO, 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_RSFT, KC_RSFT, KC_RSFT, KC_NO, KC_NO, KC_UP, KC_NO, },
+ { KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_SPC, KC_SPC, KC_SPC, KC_SPC, KC_SPC, KC_RALT, KC_NO, MO(1), KC_APP, KC_RCTL, KC_RCTL, KC_RCTL, KC_NO, KC_LEFT, KC_DOWN, KC_RIGHT, },
+ };
+ uint8_t columns = KEY_POSITION_MAP_COLUMNS;
+ uint8_t rows = KEY_POSITION_MAP_ROWS;
+
+ for(uint8_t y = 0; y < rows; ++y){
+ for(uint8_t x = 0; x < columns; ++x){
+ uint8_t id1 = ktli(KEY_POSITION_MAP[y][x]);
+
+ for(uint8_t j = y; j < rows; ++j){
+ for(uint8_t i = 0; i < columns; ++i){
+ uint8_t id2 = ktli(KEY_POSITION_MAP[j][i]);
+
+ if(id1 == id2) continue;
+
+ uint8_t dx = abs(i - x);
+ uint8_t dy = abs(j - y);
+ uint8_t dis = dx + dy;
+ if(i < x && j > y){
+ dis -= min(dx, dy);
+ }
+
+ uint8_t _dis = DISTANCE_MAP[id1][id2];
+ if(_dis && _dis <= dis) continue;
+ DISTANCE_MAP[id1][id2] = dis;
+ DISTANCE_MAP[id2][id1] = dis;
+ }
+ }
+ }
+ }
+}
+void matrix_init_user(void) {
+ init_keycode_to_led_map();
+ init_distance_map();
+};
+
+// /tmk_core/protocol/arm_atsam/led_matrix.c: line 244
+uint8_t led_enabled;
+float led_animation_speed;
+uint8_t led_animation_direction;
+uint8_t led_animation_orientation;
+uint8_t led_animation_breathing;
+uint8_t led_animation_breathe_cur;
+uint8_t breathe_step;
+uint8_t breathe_dir;
+uint64_t led_next_run;
+
+uint8_t led_animation_id;
+uint8_t led_lighting_mode;
+
+issi3733_led_t *led_cur;
+uint8_t led_per_run;
+float breathe_mult;
+
+// overrided /tmk_core/protocol/arm_atsam/led_matrix.c: line 484
+void rgb_matrix_init_user(void){
+ led_animation_speed = ANIMATION_SPEED_STEP * 15;
+ led_per_run = 15;
+}
+
+// overrided /tmk_core/protocol/arm_atsam/led_matrix.c: line 262
+void led_matrix_run(void)
+{
+ float ro;
+ float go;
+ float bo;
+ float po;
+ uint8_t led_this_run = 0;
+ led_setup_t *f = (led_setup_t*)led_setups[led_animation_id];
+
+ if (led_cur == 0) //Denotes start of new processing cycle in the case of chunked processing
+ {
+ led_cur = led_map;
+
+ disp.frame += 1;
+
+ breathe_mult = 1;
+
+ if (led_animation_breathing)
+ {
+ led_animation_breathe_cur += breathe_step * breathe_dir;
+
+ if (led_animation_breathe_cur >= BREATHE_MAX_STEP)
+ breathe_dir = -1;
+ else if (led_animation_breathe_cur <= BREATHE_MIN_STEP)
+ breathe_dir = 1;
+
+ //Brightness curve created for 256 steps, 0 - ~98%
+ breathe_mult = 0.000015 * led_animation_breathe_cur * led_animation_breathe_cur;
+ if (breathe_mult > 1) breathe_mult = 1;
+ else if (breathe_mult < 0) breathe_mult = 0;
+ }
+ }
+
+ uint8_t fcur = 0;
+ uint8_t fmax = 0;
+
+ //Frames setup
+ while (f[fcur].end != 1)
+ {
+ fcur++; //Count frames
+ }
+
+ fmax = fcur; //Store total frames count
+
+ struct user_led_t user_led_cur;
+ while (led_cur < lede && led_this_run < led_per_run)
+ {
+ ro = 0;
+ go = 0;
+ bo = 0;
+
+ uint8_t led_index = led_cur - led_map; // only this part differs from the original function.
+ if(led_index < KEY_LED_COUNT){ //
+ user_led_cur = USER_LED[led_index]; // `struct user_led_t USER_LED[]` is stored globally.
+ } //
+ //
+ if(led_index < KEY_LED_COUNT && user_led_cur.state){ // `user_led_cur` is just for convenience
+ ro = user_led_cur.r; //
+ go = user_led_cur.g; //
+ bo = user_led_cur.b; //
+ } //
+ else if (led_lighting_mode == LED_MODE_KEYS_ONLY && led_cur->scan == 255)
+ {
+ //Do not act on this LED
+ }
+ else if (led_lighting_mode == LED_MODE_NON_KEYS_ONLY && led_cur->scan != 255)
+ {
+ //Do not act on this LED
+ }
+ else if (led_lighting_mode == LED_MODE_INDICATORS_ONLY)
+ {
+ //Do not act on this LED (Only show indicators)
+ }
+ else
+ {
+ //Act on LED
+ for (fcur = 0; fcur < fmax; fcur++)
+ {
+
+ if (led_animation_orientation)
+ {
+ po = led_cur->py;
+ }
+ else
+ {
+ po = led_cur->px;
+ }
+
+ float pomod;
+ pomod = (float)(disp.frame % (uint32_t)(1000.0f / led_animation_speed)) / 10.0f * led_animation_speed;
+
+ //Add in any moving effects
+ if ((!led_animation_direction && f[fcur].ef & EF_SCR_R) || (led_animation_direction && (f[fcur].ef & EF_SCR_L)))
+ {
+ pomod *= 100.0f;
+ pomod = (uint32_t)pomod % 10000;
+ pomod /= 100.0f;
+
+ po -= pomod;
+
+ if (po > 100) po -= 100;
+ else if (po < 0) po += 100;
+ }
+ else if ((!led_animation_direction && f[fcur].ef & EF_SCR_L) || (led_animation_direction && (f[fcur].ef & EF_SCR_R)))
+ {
+ pomod *= 100.0f;
+ pomod = (uint32_t)pomod % 10000;
+ pomod /= 100.0f;
+ po += pomod;
+
+ if (po > 100) po -= 100;
+ else if (po < 0) po += 100;
+ }
+
+ //Check if LED's po is in current frame
+ if (po < f[fcur].hs) continue;
+ if (po > f[fcur].he) continue;
+ //note: < 0 or > 100 continue
+
+ //Calculate the po within the start-stop percentage for color blending
+ po = (po - f[fcur].hs) / (f[fcur].he - f[fcur].hs);
+
+ //Add in any color effects
+ if (f[fcur].ef & EF_OVER)
+ {
+ ro = (po * (f[fcur].re - f[fcur].rs)) + f[fcur].rs;// + 0.5;
+ go = (po * (f[fcur].ge - f[fcur].gs)) + f[fcur].gs;// + 0.5;
+ bo = (po * (f[fcur].be - f[fcur].bs)) + f[fcur].bs;// + 0.5;
+ }
+ else if (f[fcur].ef & EF_SUBTRACT)
+ {
+ ro -= (po * (f[fcur].re - f[fcur].rs)) + f[fcur].rs;// + 0.5;
+ go -= (po * (f[fcur].ge - f[fcur].gs)) + f[fcur].gs;// + 0.5;
+ bo -= (po * (f[fcur].be - f[fcur].bs)) + f[fcur].bs;// + 0.5;
+ }
+ else
+ {
+ ro += (po * (f[fcur].re - f[fcur].rs)) + f[fcur].rs;// + 0.5;
+ go += (po * (f[fcur].ge - f[fcur].gs)) + f[fcur].gs;// + 0.5;
+ bo += (po * (f[fcur].be - f[fcur].bs)) + f[fcur].bs;// + 0.5;
+ }
+ }
+ }
+
+ //Clamp values 0-255
+ if (ro > 255) ro = 255; else if (ro < 0) ro = 0;
+ if (go > 255) go = 255; else if (go < 0) go = 0;
+ if (bo > 255) bo = 255; else if (bo < 0) bo = 0;
+
+ if (led_animation_breathing)
+ {
+ ro *= breathe_mult;
+ go *= breathe_mult;
+ bo *= breathe_mult;
+ }
+
+ *led_cur->rgb.r = (uint8_t)ro;
+ *led_cur->rgb.g = (uint8_t)go;
+ *led_cur->rgb.b = (uint8_t)bo;
+
+#ifdef USB_LED_INDICATOR_ENABLE
+ if (keyboard_leds())
+ {
+ uint8_t kbled = keyboard_leds();
+ if (
+ #if USB_LED_NUM_LOCK_SCANCODE != 255
+ (led_cur->scan == USB_LED_NUM_LOCK_SCANCODE && kbled & (1<<USB_LED_NUM_LOCK)) ||
+ #endif //NUM LOCK
+ #if USB_LED_CAPS_LOCK_SCANCODE != 255
+ (led_cur->scan == USB_LED_CAPS_LOCK_SCANCODE && kbled & (1<<USB_LED_CAPS_LOCK)) ||
+ #endif //CAPS LOCK
+ #if USB_LED_SCROLL_LOCK_SCANCODE != 255
+ (led_cur->scan == USB_LED_SCROLL_LOCK_SCANCODE && kbled & (1<<USB_LED_SCROLL_LOCK)) ||
+ #endif //SCROLL LOCK
+ #if USB_LED_COMPOSE_SCANCODE != 255
+ (led_cur->scan == USB_LED_COMPOSE_SCANCODE && kbled & (1<<USB_LED_COMPOSE)) ||
+ #endif //COMPOSE
+ #if USB_LED_KANA_SCANCODE != 255
+ (led_cur->scan == USB_LED_KANA_SCANCODE && kbled & (1<<USB_LED_KANA)) ||
+ #endif //KANA
+ (0))
+ {
+ if (*led_cur->rgb.r > 127) *led_cur->rgb.r = 0;
+ else *led_cur->rgb.r = 255;
+ if (*led_cur->rgb.g > 127) *led_cur->rgb.g = 0;
+ else *led_cur->rgb.g = 255;
+ if (*led_cur->rgb.b > 127) *led_cur->rgb.b = 0;
+ else *led_cur->rgb.b = 255;
+ }
+ }
+#endif //USB_LED_INDICATOR_ENABLE
+
+ led_cur++;
+ led_this_run++;
+ }
+}
+
+#define KEY_STROKES_LENGTH 20
+struct {
+ bool alive;
+ uint8_t led_id;
+ uint32_t time;
+} KEY_STROKES[KEY_STROKES_LENGTH] = {{}};
+
+
+
+
+void set_led_rgb(uint8_t led_id, uint8_t r, uint8_t g, uint8_t b){
+ issi3733_led_t *target_led = (led_map + led_id);
+ *target_led->rgb.r = r;
+ *target_led->rgb.g = g;
+ *target_led->rgb.b = b;
+}
+
+
+uint8_t DISTANCE_FROM_LAST_KEYSTROKE[KEY_LED_COUNT+1];
+void calculate_keystroke_distance(void){
+ bool alive;
+ uint8_t led_id, period_passed;
+ uint32_t t;
+
+
+ for(uint8_t i = 0; i <= KEY_LED_COUNT; ++i){
+ DISTANCE_FROM_LAST_KEYSTROKE[i] = 0;
+ }
+
+ for(uint8_t i = 0; i < KEY_STROKES_LENGTH; ++i){
+ if(KEY_STROKES[i].alive){
+ t = timer_elapsed32(KEY_STROKES[i].time);
+ alive = 0;
+ led_id = KEY_STROKES[i].led_id;
+ period_passed = t / USER_CONFIG.WAVE_PERIOD;
+
+ uint8_t delta_period;
+ for(uint8_t j = 1; j <= KEY_LED_COUNT; ++j){
+ delta_period = period_passed - DISTANCE_MAP[led_id][j];
+ if(( delta_period < USER_CONFIG.WAVE_FRONT_WIDTH) && (
+ DISTANCE_MAP[led_id][j] <= USER_CONFIG.TRAVEL_DISTANCE
+ )){
+ switch(USER_CONFIG.PATTERN_INDEX){
+ case 3:
+ case 4:
+ case 5:
+ case 6:
+ DISTANCE_FROM_LAST_KEYSTROKE[j] += delta_period;
+ break;
+ default:
+ DISTANCE_FROM_LAST_KEYSTROKE[j] = 1;
+ break;
+ }
+ alive = 1;
+ }
+ }
+ KEY_STROKES[i].alive = alive;
+ }
+ }
+}
+
+#define COLOR_PATTERN_RGB_COUNT 18
+static uint8_t COLOR_PATTERNS[][COLOR_PATTERN_RGB_COUNT][3] = {
+ { // default rainbow color
+ {255, 0, 0}, {255, 0, 0}, {255, 127, 0},
+ {255, 127, 0}, {255, 255, 0}, {255, 255, 0},
+ {120, 255, 0}, {120, 255, 0}, { 0, 255, 0},
+ { 0, 255, 0}, { 0, 255, 120}, { 0, 255, 120},
+ { 0, 0, 255}, { 0, 0, 255}, { 75, 0, 130},
+ { 75, 0, 130}, { 43, 0, 130}, { 43, 0, 130},
+ }, { // light rainbow color
+ {248, 12, 18}, {238, 17, 0}, {255, 51, 17},
+ {255, 68, 32}, {255, 102, 68}, {255, 153, 51},
+ {254, 174, 45}, {204, 187, 51}, {208, 195, 16},
+ {170, 204, 34}, {105, 208, 37}, { 34, 204, 170},
+ { 18, 189, 185}, { 17, 170, 187}, { 68, 68, 221},
+ { 51, 17, 187}, { 59, 12, 189}, { 68, 34, 153},
+ }, { // white flat
+ {255, 255, 255}, {255, 255, 255}, {255, 255, 255},
+ {255, 255, 255}, {255, 255, 255}, {255, 255, 255},
+ {255, 255, 255}, {255, 255, 255}, {255, 255, 255},
+ {255, 255, 255}, {255, 255, 255}, {255, 255, 255},
+ {255, 255, 255}, {255, 255, 255}, {255, 255, 255},
+ {255, 255, 255}, {255, 255, 255}, {255, 255, 255},
+ }, { // white fade, cos curve
+ {255, 255, 255}, {255, 255, 255}, {252, 252, 252},
+ {247, 247, 247}, {240, 240, 240}, {232, 232, 232},
+ {221, 221, 221}, {209, 209, 209}, {196, 196, 196},
+ {181, 181, 181}, {164, 164, 164}, {147, 147, 147},
+ {128, 128, 128}, {108, 108, 108}, { 88, 88, 88},
+ { 66, 66, 66}, { 45, 45, 45}, { 23, 23, 23},
+ },
+};
+static const uint8_t COLOR_PATTERNS_COUNT = (
+ sizeof(COLOR_PATTERNS) / sizeof(COLOR_PATTERNS[0]));
+
+void set_user_led_rgb(uint8_t i, uint8_t r, uint8_t g, uint8_t b){
+ USER_LED[i-1].state = 1;
+ USER_LED[i-1].r = r;
+ USER_LED[i-1].g = g;
+ USER_LED[i-1].b = b;
+}
+void unset_user_led_rgb(uint8_t i){
+ USER_LED[i-1].state = 0;
+}
+void set_indicator_led_rgb(uint8_t i,
+ uint8_t layer, uint8_t r, uint8_t g, uint8_t b){
+ USER_LED[i-1].state |= 1 << layer;
+ USER_LED[i-1].r = r;
+ USER_LED[i-1].g = g;
+ USER_LED[i-1].b = b;
+}
+void unset_indicator_led_rgb(uint8_t i, uint8_t layer){
+ USER_LED[i-1].state &= ~(1 << layer);
+}
+
+void refresh_pattern_indicators(void){
+ static uint8_t GRV_123456[] = {
+ KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6,
+ };
+
+ if(layer_state >= 0x04){
+ for(uint8_t i = 0; i < 7; ++i){
+ if(i == USER_CONFIG.PATTERN_INDEX){
+ set_indicator_led_rgb(ktli(GRV_123456[i]), 2, 0, 0, 255);
+ } else{
+ set_indicator_led_rgb(ktli(GRV_123456[i]), 2, 0, 255, 0);
+ }
+ }
+ } else{
+ for(uint8_t i = 0; i < 7; ++i){
+ unset_indicator_led_rgb(ktli(GRV_123456[i]), 2);
+ }
+ }
+}
+void refresh_color_pattern_indicators(void){
+ static uint8_t ZXCVBNM_COMM_DOT[] = {
+ KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT,
+ };
+
+ if(layer_state >= 0x04){
+ uint8_t (*c)[3] = &COLOR_PATTERNS[USER_CONFIG.COLOR_PATTERN_INDEX][0];
+ for(uint8_t i = 0; i < 9; ++i){
+ set_indicator_led_rgb(ktli(ZXCVBNM_COMM_DOT[i]),
+ 2, c[i][0], c[i][1], c[i][2]);
+ }
+ } else{
+ for(uint8_t i = 0; i < 9; ++i){
+ unset_indicator_led_rgb(ktli(ZXCVBNM_COMM_DOT[i]), 2);
+ }
+ }
+}
+
+// Runs constantly in the background, in a loop.
+void matrix_scan_user(void) {
+ static uint32_t scan_timer = 0;
+ static uint8_t last_layer = 0;
+
+ uint8_t layer = 0;
+ if(layer_state >= 0x04){
+ layer = 2;
+ } else if(layer_state >= 0x02){
+ layer = 1;
+ }
+
+ calculate_keystroke_distance();
+
+
+ #define USE_PATTERN 0
+ #define BLACK_RGB 1
+ #define COLOR_RGB 2
+ uint8_t ci; // color index
+ uint8_t *rgb;
+ uint8_t handle_type;
+ uint8_t distance;
+ for(uint8_t i = 1; i <= KEY_LED_COUNT; ++i){
+ if(USER_LED[i-1].state >= 2) continue;
+
+ handle_type = USE_PATTERN;
+ distance = DISTANCE_FROM_LAST_KEYSTROKE[i];
+
+ switch(USER_CONFIG.PATTERN_INDEX){
+ case 0: handle_type = USE_PATTERN; break;
+ case 1: handle_type = distance ? USE_PATTERN : BLACK_RGB; break;
+ case 2: handle_type = distance ? BLACK_RGB : USE_PATTERN; break;
+ case 3: handle_type = distance ? COLOR_RGB : BLACK_RGB; break;
+ case 4: handle_type = distance ? COLOR_RGB : USE_PATTERN; break;
+ case 5:
+ case 6: handle_type = distance ? COLOR_RGB : USE_PATTERN; break;
+ }
+ switch(handle_type){
+ case USE_PATTERN: unset_user_led_rgb(i); break;
+ case BLACK_RGB: set_user_led_rgb(i, 0, 0, 0); break;
+ case COLOR_RGB:
+ ci = (DISTANCE_FROM_LAST_KEYSTROKE[i] * COLOR_PATTERN_RGB_COUNT /
+ USER_CONFIG.WAVE_FRONT_WIDTH) % COLOR_PATTERN_RGB_COUNT;
+ rgb = &COLOR_PATTERNS[USER_CONFIG.COLOR_PATTERN_INDEX][ci][0];
+
+ set_user_led_rgb(i, rgb[0], rgb[1], rgb[2]);
+ break;
+ }
+ }
+
+
+ // could be moved to process_record_user()
+ if(layer != last_layer){
+
+ static uint8_t QWEASDP[] = {
+ KC_Q, KC_W, KC_E, KC_A, KC_S, KC_D, KC_P,
+ };
+ static uint8_t YUIOHJKL[] = {
+ KC_Y, KC_U, KC_I, KC_O, KC_H, KC_J, KC_K, KC_L,
+ };
+
+ switch(last_layer){
+ case 1:
+ for(uint8_t i = 0; i < 7; ++i){
+ unset_indicator_led_rgb(ktli(QWEASDP[i]), 1);
+ }
+ break;
+ case 2:
+ for(uint8_t i = 0; i < 6; ++i){
+ unset_indicator_led_rgb(ktli(QWEASDP[i]), 2);
+ }
+ for(uint8_t i = 0; i < 8; ++i){
+ unset_indicator_led_rgb(ktli(YUIOHJKL[i]), 2);
+ }
+ unset_indicator_led_rgb(ktli(KC_TAB), 2);
+ unset_indicator_led_rgb(ktli(KC_CAPS), 2);
+ break;
+ }
+
+
+ switch(layer){
+ case 1:
+ for(uint8_t i = 0; i < 7; ++i){
+ set_indicator_led_rgb(ktli(QWEASDP[i]), 1, 255, 0, 0);
+ }
+ break;
+ case 2:
+ for(uint8_t i = 0; i < 6; ++i){
+ set_indicator_led_rgb(ktli(QWEASDP[i]), 2, 0, 255, 0);
+ }
+ for(uint8_t i = 0; i < 8; ++i){
+ set_indicator_led_rgb(ktli(YUIOHJKL[i]), 2, 0, 255, 0);
+ }
+ set_indicator_led_rgb(ktli(KC_TAB), 2, 0, 255, 0);
+ set_indicator_led_rgb(ktli(KC_CAPS), 2, 0, 255, 0);
+ break;
+ }
+
+ refresh_pattern_indicators();
+ refresh_color_pattern_indicators();
+ last_layer = layer;
+ }
+
+
+ switch(layer){
+ case 0:
+ if(timer_elapsed32(scan_timer) > 2000){
+ scan_timer = timer_read32();
+ } else if(timer_elapsed32(scan_timer) > 1000){
+ // set_user_led_rgb(ktli(KC_F5), 255, 255, 255);
+ }
+ break;
+ case 1:
+ break;
+ case 2:
+ break;
+ }
+
+};
+
+#define MODS_SHIFT (keyboard_report->mods & MOD_BIT(KC_LSHIFT) || keyboard_report->mods & MOD_BIT(KC_RSHIFT))
+#define MODS_CTRL (keyboard_report->mods & MOD_BIT(KC_LCTL) || keyboard_report->mods & MOD_BIT(KC_RCTRL))
+#define MODS_ALT (keyboard_report->mods & MOD_BIT(KC_LALT) || keyboard_report->mods & MOD_BIT(KC_RALT))
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+ static uint32_t key_timer;
+
+
+ switch (keycode) {
+ case L_BRI:
+ if (record->event.pressed) {
+ if (LED_GCR_STEP > LED_GCR_MAX - gcr_desired) gcr_desired = LED_GCR_MAX;
+ else gcr_desired += LED_GCR_STEP;
+ if (led_animation_breathing) gcr_breathe = gcr_desired;
+ }
+ return false;
+ case L_BRD:
+ if (record->event.pressed) {
+ if (LED_GCR_STEP > gcr_desired) gcr_desired = 0;
+ else gcr_desired -= LED_GCR_STEP;
+ if (led_animation_breathing) gcr_breathe = gcr_desired;
+ }
+ return false;
+ case L_PTN:
+ if (record->event.pressed) {
+ if (led_animation_id == led_setups_count - 1) led_animation_id = 0;
+ else led_animation_id++;
+ }
+ return false;
+ case L_PTP:
+ if (record->event.pressed) {
+ if (led_animation_id == 0) led_animation_id = led_setups_count - 1;
+ else led_animation_id--;
+ }
+ return false;
+ case L_PSI:
+ if (record->event.pressed) {
+ led_animation_speed += ANIMATION_SPEED_STEP;
+ }
+ return false;
+ case L_PSD:
+ if (record->event.pressed) {
+ led_animation_speed -= ANIMATION_SPEED_STEP;
+ if (led_animation_speed < 0) led_animation_speed = 0;
+ }
+ return false;
+ case L_T_MD:
+ if (record->event.pressed) {
+ led_lighting_mode++;
+ if (led_lighting_mode > LED_MODE_MAX_INDEX) led_lighting_mode = LED_MODE_NORMAL;
+ }
+ return false;
+ case L_T_ONF:
+ if (record->event.pressed) {
+ led_enabled = !led_enabled;
+ I2C3733_Control_Set(led_enabled);
+ }
+ return false;
+ case L_ON:
+ if (record->event.pressed) {
+ led_enabled = 1;
+ I2C3733_Control_Set(led_enabled);
+ }
+ return false;
+ case L_OFF:
+ if (record->event.pressed) {
+ led_enabled = 0;
+ I2C3733_Control_Set(led_enabled);
+ }
+ return false;
+ case L_T_BR:
+ if (record->event.pressed) {
+ led_animation_breathing = !led_animation_breathing;
+ if (led_animation_breathing) {
+ gcr_breathe = gcr_desired;
+ led_animation_breathe_cur = BREATHE_MIN_STEP;
+ breathe_dir = 1;
+ }
+ }
+ return false;
+ case L_T_PTD:
+ if (record->event.pressed) {
+ led_animation_direction = !led_animation_direction;
+ }
+ return false;
+ case U_T_AUTO:
+ if (record->event.pressed && MODS_SHIFT && MODS_CTRL) {
+ TOGGLE_FLAG_AND_PRINT(usb_extra_manual, "USB extra port manual mode");
+ }
+ return false;
+ case U_T_AGCR:
+ if (record->event.pressed && MODS_SHIFT && MODS_CTRL) {
+ TOGGLE_FLAG_AND_PRINT(usb_gcr_auto, "USB GCR auto mode");
+ }
+ return false;
+ case DBG_TOG:
+ if (record->event.pressed) {
+ TOGGLE_FLAG_AND_PRINT(debug_enable, "Debug mode");
+ }
+ return false;
+ case DBG_MTRX:
+ if (record->event.pressed) {
+ TOGGLE_FLAG_AND_PRINT(debug_matrix, "Debug matrix");
+ }
+ return false;
+ case DBG_KBD:
+ if (record->event.pressed) {
+ TOGGLE_FLAG_AND_PRINT(debug_keyboard, "Debug keyboard");
+ }
+ return false;
+ case DBG_MOU:
+ if (record->event.pressed) {
+ TOGGLE_FLAG_AND_PRINT(debug_mouse, "Debug mouse");
+ }
+ return false;
+ case MD_BOOT:
+ if (record->event.pressed) {
+ key_timer = timer_read32();
+ } else {
+ if (timer_elapsed32(key_timer) >= 500) {
+ reset_keyboard();
+ }
+ }
+ return false;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ case L_SP_PR: // previous dripple pattern
+ case L_SP_NE: // next dripple pattern
+ if (record->event.pressed) {
+#define PATTERN_COUNT 7
+ uint8_t incre = keycode == L_SP_PR ? PATTERN_COUNT-1 : 1;
+ USER_CONFIG.PATTERN_INDEX += incre;
+ USER_CONFIG.PATTERN_INDEX %= PATTERN_COUNT;
+
+ if(USER_CONFIG.PATTERN_INDEX <= 4){
+ USER_CONFIG.TRAVEL_DISTANCE = 25;
+ USER_CONFIG.COLOR_PATTERN_INDEX = 0;
+ USER_CONFIG.WAVE_PERIOD = 50;
+ }
+
+ switch(USER_CONFIG.PATTERN_INDEX){
+ case 0: // None
+ break;
+ case 1: // background off, wave on
+ USER_CONFIG.WAVE_FRONT_WIDTH = 2;
+ break;
+ case 2: // background on, wave off
+ USER_CONFIG.WAVE_FRONT_WIDTH = 5;
+ break;
+ case 3: // background off, rainbow wave
+ USER_CONFIG.WAVE_FRONT_WIDTH = 10;
+ break;
+ case 4: // background on, rainbow wave
+ USER_CONFIG.WAVE_FRONT_WIDTH = 10;
+ break;
+ case 5:
+ USER_CONFIG.WAVE_FRONT_WIDTH = 10;
+
+ USER_CONFIG.COLOR_PATTERN_INDEX = 2;
+ USER_CONFIG.TRAVEL_DISTANCE = 0;
+ USER_CONFIG.WAVE_PERIOD = 100;
+ break;
+ case 6:
+ USER_CONFIG.WAVE_FRONT_WIDTH = 25;
+
+ USER_CONFIG.COLOR_PATTERN_INDEX = 3;
+ USER_CONFIG.TRAVEL_DISTANCE = 2;
+ USER_CONFIG.WAVE_PERIOD = 10;
+ break;
+ }
+
+ // remove effect after changing pattern
+ for(int i = 0; i < KEY_STROKES_LENGTH; ++i){
+ KEY_STROKES[i].alive = 0;
+ }
+ refresh_pattern_indicators();
+ refresh_color_pattern_indicators();
+ }
+ return false;
+ case L_SP_WD:
+ case L_SP_NW:
+ if(record->event.pressed){
+ short incre = keycode == L_SP_WD ? 1 : -1;
+ USER_CONFIG.WAVE_FRONT_WIDTH += incre;
+ if(USER_CONFIG.WAVE_FRONT_WIDTH < 1){
+ USER_CONFIG.WAVE_FRONT_WIDTH = 1;
+ }
+ }
+ return false;
+ case L_SP_FA:
+ case L_SP_SL:
+ if(record->event.pressed){
+ short incre = keycode == L_SP_FA ? -1 : 1;
+
+ USER_CONFIG.WAVE_PERIOD += 10 * incre;
+ if(USER_CONFIG.WAVE_PERIOD < 10){
+ USER_CONFIG.WAVE_PERIOD = 10;
+ }
+ }
+ return false;
+ // these are the keys not in range 0x04 - 0x52
+ case L_CP_PR:
+ case L_CP_NX:
+ if(record->event.pressed){
+ uint8_t incre = keycode == L_CP_PR ? COLOR_PATTERNS_COUNT - 1 : 1;
+ USER_CONFIG.COLOR_PATTERN_INDEX += incre;
+ USER_CONFIG.COLOR_PATTERN_INDEX %= COLOR_PATTERNS_COUNT;
+ refresh_color_pattern_indicators();
+ }
+ return false;
+ default:
+ if (record->event.pressed){
+ uint8_t led_id = ktli(keycode);
+ if(led_id){
+ for(int i = 0; i < KEY_STROKES_LENGTH; ++i){
+ if(!KEY_STROKES[i].alive){
+ KEY_STROKES[i].alive = 1;
+ KEY_STROKES[i].led_id = led_id;
+ KEY_STROKES[i].time = timer_read32();
+ break;
+ }
+ }
+ }
+ }
+ return true; //Process all other keycodes normally
+ }
+}
projects / qmk_firmware.git / blobdiff