keyboards/helix/rev2/keymaps/froggy/keymap.c

   1 #include QMK_KEYBOARD_H
   2 #include "bootloader.h"
   3 #ifdef PROTOCOL_LUFA
   4 #include "lufa.h"
   5 #include "split_util.h"
   6 #endif
   7 #ifdef AUDIO_ENABLE
   8   #include "audio.h"
   9 #endif
  10 #ifdef SSD1306OLED
  11   #include "ssd1306.h"
  12 #endif
  13
  14 extern keymap_config_t keymap_config;
  15
  16 #ifdef RGBLIGHT_ENABLE
  17 //Following line allows macro to read current RGB settings
  18 extern rgblight_config_t rgblight_config;
  19 #endif
  20
  21 extern uint8_t is_master;
  22
  23 #define DELAY_TIME  75
  24 static uint16_t key_timer;
  25 static uint16_t tap_timer;
  26 static uint16_t delay_registered_code;
  27 static uint8_t delay_mat_row;
  28 static uint8_t delay_mat_col;
  29 static bool delay_key_stat;
  30 static bool delay_key_pressed;
  31 static bool tapping_key;
  32
  33 // Each layer gets a name for readability, which is then used in the keymap matrix below.
  34 // The underscores don't mean anything - you can have a layer called STUFF or any other name.
  35 // Layer names don't all need to be of the same length, obviously, and you can also skip them
  36 // entirely and just use numbers.
  37 #define _BASE 0
  38 #define _OPT 1
  39 #define _FUNC 2
  40 #define _SYM 3
  41 #define _NUM 4
  42
  43 bool RGBAnimation = false; //Flag for LED Layer color Refresh.
  44
  45 enum custom_keycodes {
  46   QWERTY = SAFE_RANGE,
  47   EISU,
  48   KANA,
  49   RGBRST,
  50   RGBOFF,
  51   RGB1,
  52   RGB2,
  53   RGB3,
  54   OPT_TAP_SP,
  55   DESKTOP,
  56   MAC,
  57   WIN,
  58 };
  59
  60 enum macro_keycodes {
  61   KC_SAMPLEMACRO,
  62 };
  63
  64
  65 // Fillers to make layering more clear
  66 #define _______ KC_TRNS
  67 #define XXXXXXX KC_NO
  68 //Macros
  69 #define M_SAMPLE M(KC_SAMPLEMACRO)
  70
  71 #if HELIX_ROWS == 5
  72 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  73
  74   /* Base
  75    * ,-----------------------------------------.             ,-----------------------------------------.
  76    * |  C+z |   ;  |   [  |   (  |   <  |   {  |             |      |      |      |      |      |      |
  77    * |------+------+------+------+------+------|             |------+------+------+------+------+------|
  78    * | KANA |   P  |   K  |   R  |   A  |   F  |             |      |      |      |      |      |      |
  79    * |------+------+------+------+------+------|             |------+------+------+------+------+------|
  80    * |  BS  |   D  |   T  |   H  |   E  |   O  |             |      |      |      |      |      |      |
  81    * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
  82    * | Shift|   Y  |   S  |   N  |   I  |   U  |Space |      |      |      |      |      |      |      |
  83    * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
  84    * | Ctrl | Alt  | Gui  | Sym  | Num  | OPT  | Ent  |      |      |      |      |      |      |      |
  85    * `-------------------------------------------------------------------------------------------------'
  86    */
  87   [_BASE] = LAYOUT( \
  88       LCTL(KC_Z),    KC_SCLN,       KC_LBRC,       KC_LPRN,   KC_LT,     KC_LCBR,                                _______,  _______,  _______,  _______,  _______,  _______, \
  89       KANA,          KC_P,          KC_K,          KC_R,      KC_A,      KC_F,                                   _______,  _______,  _______,  _______,  _______,  _______, \
  90       KC_BSPC,       KC_D,          KC_T,          KC_H,      KC_E,      KC_O,                                   _______,  _______,  _______,  _______,  _______,  _______, \
  91       OSM(MOD_LSFT), KC_Y,          KC_S,          KC_N,      KC_I,      KC_U,       KC_SPC, _______,  _______,  _______,  _______,  _______,  _______,  _______, \
  92       OSM(MOD_LCTL), OSM(MOD_LALT), OSM(MOD_LGUI), MO(_SYM),  MO(_NUM),  OPT_TAP_SP, KC_ENT, _______,  _______,  _______,  _______,  _______,  _______,  _______ \
  93       ),
  94
  95   /* Opt
  96    * ,-----------------------------------------.             ,-----------------------------------------.
  97    * |  Esc |  :   |  ]   |  )   |  >   |  }   |             |      |      |      |      |      |      |
  98    * |------+------+------+------+------+------|             |------+------+------+------+------+------|
  99    * |  EISU|   J  |   M  |   B  |   '  |  Tab |             |      |      |      |      |      |      |
 100    * |------+------+------+------+------+------|             |------+------+------+------+------+------|
 101    * |   .  |   V  |   C  |   L  |   Z  |  Q   |             |      |      |      |      |      |      |
 102    * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
 103    * |      |   X  |   G  |   W  |   -  |  Del | Esc  |      |      |      |      |      |      |      |
 104    * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
 105    * |      |      |      |   ,  | DTOP |      |      |      |      |      |      |      |      |      |
 106    * `-------------------------------------------------------------------------------------------------'
 107    */
 108   [_OPT] = LAYOUT( \
 109       KC_ESC,  KC_COLN,KC_RBRC, KC_RPRN,KC_GT,     KC_RCBR,                   _______,  _______,  _______,  _______,  _______,  _______, \
 110       EISU,    KC_J,   KC_M,    KC_B,   KC_QUOT,   KC_TAB,                    _______,  _______,  _______,  _______,  _______,  _______, \
 111       KC_DOT,  KC_V,   KC_C,    KC_L,   KC_Z,      KC_Q,                      _______,  _______,  _______,  _______,  _______,  _______, \
 112       _______, KC_X,   KC_G,    KC_W,   KC_MINUS,  KC_DEL,  KC_ESC,  _______, _______,  _______,  _______,  _______,  _______,  _______, \
 113       _______, _______,_______, KC_COMM,DESKTOP,   _______, _______, _______, _______,  _______,  _______,  _______,  _______,  _______ \
 114       ),
 115
 116   /* Func
 117    * ,-----------------------------------------.             ,-----------------------------------------.
 118    * |RGBRST|  Hue |      |  RST |  Mac |  Win |             |      |      |      |      |      |      |
 119    * |------+------+------+------+------+------|             |------+------+------+------+------+------|
 120    * | RGB1 | VAL+ |  F7  |  F8  |  F9  |      |             |      |      |      |      |      |      |
 121    * |------+------+------+------+------+------|             |------+------+------+------+------+------|
 122    * | RGB2 | VAL- |  F4  |  F5  |  F6  | F12  |             |      |      |      |      |      |      |
 123    * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
 124    * | RGB3 |  F10 |  F1  |  F2  |  F3  | F11  |      |      |      |      |      |      |      |      |
 125    * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
 126    * |RGBOFF|      |      |      |      |      |      |      |      |      |      |      |      |      |
 127    * `-------------------------------------------------------------------------------------------------'
 128    */
 129   [_FUNC] = LAYOUT( \
 130       RGBRST,RGB_HUI, _______, RESET,   MAC,     WIN,                         _______,  _______,  _______,  _______,  _______,  _______, \
 131       RGB1,  RGB_VAI, KC_F7,   KC_F8,   KC_F9,   _______,                     _______,  _______,  _______,  _______,  _______,  _______, \
 132       RGB2,  RGB_VAD, KC_F4,   KC_F5,   KC_F6,   KC_F12,                      _______,  _______,  _______,  _______,  _______,  _______, \
 133       RGB3,  KC_F10,  KC_F1,   KC_F2,   KC_F3,   KC_F11,   _______,  _______, _______,  _______,  _______,  _______,  _______,  _______, \
 134       RGBOFF,_______, _______, _______, _______, _______,  _______,  _______, _______,  _______,  _______,  _______,  _______,  _______ \
 135       ),
 136
 137   /* Sym
 138    * ,-----------------------------------------.             ,-----------------------------------------.
 139    * |  Ins |  GRV |      |  PU  |  PD  |   ^  |             |      |      |      |      |      |      |
 140    * |------+------+------+------+------+------|             |------+------+------+------+------+------|
 141    * |      |   \  |   #  |   =  |   ?  |   %  |             |      |      |      |      |      |      |
 142    * |------+------+------+------+------+------|             |------+------+------+------+------+------|
 143    * |      |   $  |  upA |   @  |   !  |   |  |             |      |      |      |      |      |      |
 144    * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
 145    * |  CL  |  <-  |  dwA |  ->  |   _  |   &  |      |      |      |      |      |      |      |      |
 146    * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
 147    * |      |      |  PS  |      |   ~  |      |      |      |      |      |      |      |      |      |
 148    * `-------------------------------------------------------------------------------------------------'
 149    */
 150   [_SYM] = LAYOUT( \
 151       KC_INS,  KC_GRV,  _______, KC_PGUP, KC_PGDN, KC_CIRC,                   _______,  _______,  _______,  _______,  _______,  _______, \
 152       _______, KC_BSLS, KC_HASH, KC_EQL,  KC_QUES, KC_PERC,                   _______,  _______,  _______,  _______,  _______,  _______, \
 153       _______, KC_DLR,  KC_UP,   KC_AT,   KC_EXLM, KC_PIPE,                   _______,  _______,  _______,  _______,  _______,  _______, \
 154       KC_CAPS, KC_LEFT, KC_DOWN, KC_RIGHT,KC_UNDS, KC_AMPR, _______, _______, _______,  _______,  _______,  _______,  _______,  _______, \
 155       _______, _______, KC_PSCR, _______, KC_TILD, _______, _______, _______, _______,  _______,  _______,  _______,  _______,  _______ \
 156       ),
 157
 158   /* Raise
 159    * ,-----------------------------------------.             ,-----------------------------------------.
 160    * |      |      | Func | home |  End |      |             |      |      |      |      |      |      |
 161    * |------+------+------+------+------+------|             |------+------+------+------+------+------|
 162    * |      |   *  |  7   |  8   |  9   |  -   |             |      |      |      |      |      |      |
 163    * |------+------+------+------+------+------|             |------+------+------+------+------+------|
 164    * |  .   |   /  |  4   |  5   |  6   |  +   |             |      |      |      |      |      |      |
 165    * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
 166    * |  LN  |  0   |  1   |  2   |  3   |C+S+F1|      |      |      |      |      |      |      |      |
 167    * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
 168    * |      |      |      |  ,   |      |      |      |      |      |      |      |      |      |      |
 169    * `-------------------------------------------------------------------------------------------------'
 170    */
 171   [_NUM] = LAYOUT( \
 172       _______,  _______, OSL(_FUNC), KC_HOME, KC_END,  _______,                          _______,  _______,  _______,  _______,  _______,  _______, \
 173       _______,  KC_ASTR, KC_P7,      KC_P8,   KC_P9,   KC_MINS,                          _______,  _______,  _______,  _______,  _______,  _______, \
 174       KC_PDOT,  KC_SLSH, KC_P4,      KC_P5,   KC_P6,   KC_PLUS,                          _______,  _______,  _______,  _______,  _______,  _______, \
 175       KC_NLCK,  KC_P0,   KC_P1,      KC_P2,   KC_P3,   LCTL(S(KC_F1)), _______, _______, _______,  _______,  _______,  _______,  _______,  _______, \
 176       _______,  _______, KC_PDOT,    KC_COMM, _______, _______,        _______, _______, _______,  _______,  _______,  _______,  _______,  _______ \
 177       )
 178 };
 179 #else
 180 #error "undefined keymaps"
 181 #endif
 182
 183
 184 #ifdef AUDIO_ENABLE
 185
 186 float tone_qwerty[][2]     = SONG(QWERTY_SOUND);
 187 float tone_dvorak[][2]     = SONG(DVORAK_SOUND);
 188 float tone_colemak[][2]    = SONG(COLEMAK_SOUND);
 189 float tone_plover[][2]     = SONG(PLOVER_SOUND);
 190 float tone_plover_gb[][2]  = SONG(PLOVER_GOODBYE_SOUND);
 191 float music_scale[][2]     = SONG(MUSIC_SCALE_SOUND);
 192 #endif
 193
 194 // define variables for reactive RGB
 195 //bool TOG_STATUS = false;
 196 int RGB_current_mode;
 197
 198 void persistent_default_layer_set(uint16_t default_layer) {
 199   eeconfig_update_default_layer(default_layer);
 200   default_layer_set(default_layer);
 201 }
 202
 203 bool find_mairix(uint16_t keycode, uint8_t *row, uint8_t *col){
 204   for(uint8_t i=0; i<MATRIX_ROWS; i++){
 205     for(uint8_t j=0; j<MATRIX_COLS; j++){
 206       if( pgm_read_word(&(keymaps[_BASE][i][j]))==keycode){
 207         *row = i;
 208         *col = j;
 209         return true;
 210       }
 211     }
 212   }
 213   return false;
 214 }
 215
 216 void unregister_delay_code(void){
 217   if(delay_registered_code){
 218     unregister_code(delay_registered_code);
 219     if (delay_registered_code & QK_LSFT){
 220       unregister_code(KC_LSFT);
 221     }
 222     if (delay_registered_code & QK_LCTL){
 223       unregister_code(KC_LCTL);
 224     }
 225     if (delay_registered_code & QK_LALT){
 226       unregister_code(KC_LALT);
 227     }
 228     if (delay_registered_code & QK_LGUI){
 229       unregister_code(KC_LGUI);
 230     }
 231     delay_registered_code=0;
 232   }
 233 }
 234
 235 void register_delay_code(uint8_t layer){
 236   if(delay_key_stat){
 237     unregister_delay_code();
 238
 239     uint16_t code = pgm_read_word(&(keymaps[layer][delay_mat_row][delay_mat_col]));
 240     if (code & QK_LSFT){
 241       register_code(KC_LSFT);
 242     }
 243     if (code & QK_LCTL){
 244       register_code(KC_LCTL);
 245     }
 246     if (code & QK_LALT){
 247       register_code(KC_LALT);
 248     }
 249     if (code & QK_LGUI){
 250       register_code(KC_LGUI);
 251     }
 252     register_code(code);
 253     delay_registered_code = code;
 254     delay_key_stat = false;
 255     tapping_key = true;
 256   }
 257 }
 258
 259 #ifdef RGBLIGHT_ENABLE
 260 struct keybuf {
 261   char col, row;
 262   char frame;
 263 };
 264 struct keybuf keybufs[256];
 265 unsigned char keybuf_begin, keybuf_end;
 266
 267 int col, row;
 268 #endif
 269
 270 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 271
 272   #ifdef RGBLIGHT_ENABLE
 273     col = record->event.key.col;
 274     row = record->event.key.row;
 275     if (record->event.pressed && ((row < 5 && is_master) || (row >= 5 && !is_master))) {
 276       int end = keybuf_end;
 277       keybufs[end].col = col;
 278       keybufs[end].row = row % 5;
 279       keybufs[end].frame = 0;
 280       keybuf_end ++;
 281     }
 282   #endif
 283
 284   if(tap_timer&&keycode!=OPT_TAP_SP){
 285     tapping_key = true;
 286   }
 287
 288   if(keycode==delay_registered_code){
 289       if (!record->event.pressed){
 290         unregister_delay_code();
 291       }
 292   }
 293
 294   switch (keycode) {
 295     case KC_SCLN:
 296     case KC_LBRC:
 297     case KC_LPRN:
 298     case KC_LT:
 299     case KC_LCBR:
 300     case KC_P:
 301     case KC_K:
 302     case KC_R:
 303     case KC_A:
 304     case KC_F:
 305     case KC_BSPC:
 306     case KC_D:
 307     case KC_T:
 308     case KC_H:
 309     case KC_E:
 310     case KC_O:
 311     case KC_Y:
 312     case KC_S:
 313     case KC_N:
 314     case KC_I:
 315     case KC_U:
 316     case LCTL(KC_Z):
 317     case KC_SPC:
 318       if (record->event.pressed) {
 319         register_delay_code(_BASE);
 320         if(find_mairix(keycode, &delay_mat_row, &delay_mat_col)){
 321           key_timer = timer_read();
 322           delay_key_stat = true;
 323           delay_key_pressed = true;
 324         }
 325       }else{
 326         delay_key_pressed = false;
 327       }
 328       return false;
 329       break;
 330     case OPT_TAP_SP:
 331       if (record->event.pressed) {
 332         tapping_key = false;
 333         register_delay_code(_OPT);
 334         layer_on(_OPT);
 335         tap_timer = timer_read();
 336       }else{
 337         layer_off(_OPT);
 338         if(tapping_key==false && timer_elapsed(tap_timer) < TAPPING_TERM){
 339           SEND_STRING(" ");
 340         }
 341         tap_timer = 0;
 342       }
 343       return false;
 344       break;
 345    case EISU:
 346       if (record->event.pressed) {
 347         if(keymap_config.swap_lalt_lgui==false){
 348           register_code(KC_LANG2);
 349         }else{
 350           SEND_STRING(SS_LALT("`"));
 351         }
 352       } else {
 353         unregister_code(KC_LANG2);
 354       }
 355       return false;
 356       break;
 357     case KANA:
 358       if (record->event.pressed) {
 359         if(keymap_config.swap_lalt_lgui==false){
 360           register_code(KC_LANG1);
 361         }else{
 362           SEND_STRING(SS_LALT("`"));
 363         }
 364       } else {
 365         unregister_code(KC_LANG1);
 366       }
 367       return false;
 368       break;
 369     case DESKTOP:
 370       if (record->event.pressed) {
 371         if(keymap_config.swap_lalt_lgui==false){
 372           register_code(KC_F11);
 373         }else{
 374           SEND_STRING(SS_LGUI("d"));
 375         }
 376       } else {
 377         unregister_code(KC_F11);
 378       }
 379       return false;
 380       break;
 381     case RGBRST:
 382       #ifdef RGBLIGHT_ENABLE
 383         if (record->event.pressed) {
 384           eeconfig_update_rgblight_default();
 385           rgblight_enable();
 386           RGB_current_mode = rgblight_config.mode;
 387           RGBAnimation = false;
 388         }
 389       #endif
 390       break;
 391     case RGBOFF:
 392       #ifdef RGBLIGHT_ENABLE
 393         if (record->event.pressed) {
 394           rgblight_disable();
 395         }
 396       #endif
 397       break;
 398     case RGB1:
 399       #ifdef RGBLIGHT_ENABLE
 400         if (record->event.pressed) {
 401           RGBAnimation = true;
 402           rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD);
 403           RGB_current_mode = rgblight_config.mode;
 404         }
 405       #endif
 406       break;
 407     case RGB2:
 408       #ifdef RGBLIGHT_ENABLE
 409         if (record->event.pressed) {
 410           RGBAnimation = true;
 411           rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL + 1);
 412           RGB_current_mode = rgblight_config.mode;
 413         }
 414       #endif
 415       break;
 416     case RGB3:
 417       #ifdef RGBLIGHT_ENABLE
 418         if (record->event.pressed) {
 419           RGBAnimation = true;
 420           rgblight_mode(RGBLIGHT_MODE_KNIGHT);
 421           RGB_current_mode = rgblight_config.mode;
 422         }
 423       #endif
 424       break;
 425     case MAC:
 426       if (record->event.pressed) {
 427         keymap_config.swap_lalt_lgui = false;
 428         keymap_config.swap_ralt_rgui = false;
 429         #ifdef AUDIO_ENABLE
 430           PLAY_SONG(ag_norm_song);
 431         #endif
 432       }
 433       break;
 434     case WIN:
 435       if (record->event.pressed) {
 436         keymap_config.swap_lalt_lgui = true;
 437         keymap_config.swap_ralt_rgui = true;
 438         #ifdef AUDIO_ENABLE
 439           PLAY_SONG(ag_swap_song);
 440         #endif
 441       }
 442       break;
 443     }
 444   return true;
 445 }
 446
 447
 448 //keyboard start-up code. Runs once when the firmware starts up.
 449 void matrix_init_user(void) {
 450     #ifdef AUDIO_ENABLE
 451         startup_user();
 452     #endif
 453     #ifdef RGBLIGHT_ENABLE
 454       RGB_current_mode = rgblight_config.mode;
 455     #endif
 456     //SSD1306 OLED init, make sure to add #define SSD1306OLED in config.h
 457     #ifdef SSD1306OLED
 458         iota_gfx_init(!has_usb());   // turns on the display
 459     #endif
 460 }
 461
 462
 463 #ifdef AUDIO_ENABLE
 464
 465 void startup_user()
 466 {
 467     _delay_ms(20); // gets rid of tick
 468 }
 469
 470 void shutdown_user()
 471 {
 472     _delay_ms(150);
 473     stop_all_notes();
 474 }
 475
 476 void music_on_user(void)
 477 {
 478     music_scale_user();
 479 }
 480
 481 void music_scale_user(void)
 482 {
 483     PLAY_SONG(music_scale);
 484 }
 485
 486 #endif
 487
 488
 489 //assign the right code to your layers for OLED display
 490 #define L_BASE 0
 491 #define L_OPT 2
 492 #define L_FUNC 4
 493 #define L_SYM 8
 494 #define L_NUM 16
 495 #define L_FNLAYER 64
 496 #define L_NUMLAY 128
 497 #define L_NLOWER 136
 498 #define L_NFNLAYER 192
 499 #define L_MOUSECURSOR 256
 500
 501 // LED Effect
 502 #ifdef RGBLIGHT_ENABLE
 503 unsigned char rgb[7][5][3];
 504 void led_ripple_effect(char r, char g, char b) {
 505     static int scan_count = -10;
 506     static int keys[] = { 6, 6, 6, 7, 7 };
 507     static int keys_sum[] = { 0, 6, 12, 18, 25 };
 508
 509     if (scan_count == -1) {
 510       rgblight_enable_noeeprom();
 511       rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
 512     } else if (scan_count >= 0 && scan_count < 5) {
 513       for (unsigned char c=keybuf_begin; c!=keybuf_end; c++) {
 514         int i = c;
 515         // FIXME:
 516
 517         int y = scan_count;
 518         int dist_y = abs(y - keybufs[i].row);
 519         for (int x=0; x<keys[y]; x++) {
 520           int dist = abs(x - keybufs[i].col) + dist_y;
 521           if (dist <= keybufs[i].frame) {
 522             int elevation = MAX(0, (8 + dist - keybufs[i].frame)) << 2;
 523             if (elevation) {
 524               if ((rgb[x][y][0] != 255) && r) { rgb[x][y][0] = MIN(255, elevation + rgb[x][y][0]); }
 525               if ((rgb[x][y][1] != 255) && g) { rgb[x][y][1] = MIN(255, elevation + rgb[x][y][1]); }
 526               if ((rgb[x][y][2] != 255) && b) { rgb[x][y][2] = MIN(255, elevation + rgb[x][y][2]); }
 527             }
 528           }
 529         }
 530       }
 531     } else if (scan_count == 5) {
 532       for (unsigned char c=keybuf_begin; c!=keybuf_end; c++) {
 533         int i = c;
 534         if (keybufs[i].frame < 18) {
 535           keybufs[i].frame ++;
 536         } else {
 537           keybuf_begin ++;
 538         }
 539       }
 540     } else if (scan_count >= 6 && scan_count <= 10) {
 541       int y = scan_count - 6;
 542       for (int x=0; x<keys[y]; x++) {
 543         int at = keys_sum[y] + ((y & 1) ? x : (keys[y] - x - 1));
 544         led[at].r = rgb[x][y][0];
 545         led[at].g = rgb[x][y][1];
 546         led[at].b = rgb[x][y][2];
 547       }
 548       rgblight_set();
 549     } else if (scan_count == 11) {
 550       memset(rgb, 0, sizeof(rgb));
 551     }
 552     scan_count++;
 553     if (scan_count >= 12) { scan_count = 0; }
 554 }
 555 #endif
 556
 557 uint8_t layer_state_old;
 558
 559 //runs every scan cycle (a lot)
 560 void matrix_scan_user(void) {
 561   #ifdef SSD1306OLED
 562     iota_gfx_task();  // this is what updates the display continuously
 563   #endif
 564
 565   if(delay_key_stat && (timer_elapsed(key_timer) > DELAY_TIME)){
 566     register_delay_code(_BASE);
 567     if(!delay_key_pressed){
 568       unregister_delay_code();
 569     }
 570   }
 571
 572   if(layer_state_old != layer_state){
 573     switch (layer_state) {
 574       case L_BASE:
 575         break;
 576       case L_OPT:
 577         register_delay_code(_OPT);
 578         break;
 579       case L_NUM:
 580         register_delay_code(_NUM);
 581         break;
 582       case L_SYM:
 583         register_delay_code(_SYM);
 584         break;
 585       case L_FUNC:
 586         register_delay_code(_FUNC);
 587         break;
 588     }
 589     layer_state_old = layer_state;
 590   }
 591
 592   #ifdef RGBLIGHT_ENABLE
 593     if(!RGBAnimation){
 594       switch (layer_state) {
 595         case L_BASE:
 596           #ifdef RGBLED_BACK
 597             led_ripple_effect(0,112,127);
 598           #else
 599             rgblight_setrgb(0,112,127);
 600           #endif
 601           break;
 602         case L_OPT:
 603           #ifdef RGBLED_BACK
 604             led_ripple_effect(127,0,100);
 605           #else
 606             rgblight_setrgb(127,0,100);
 607           #endif
 608           break;
 609         case L_NUM:
 610           #ifdef RGBLED_BACK
 611             led_ripple_effect(127,23,0);
 612           #else
 613             rgblight_setrgb(127,23,0);
 614           #endif
 615           break;
 616         case L_SYM:
 617           #ifdef RGBLED_BACK
 618             led_ripple_effect(0,127,0);
 619           #else
 620             rgblight_setrgb(0,127,0);
 621           #endif
 622           break;
 623         case L_FUNC:
 624           #ifdef RGBLED_BACK
 625             led_ripple_effect(127,0,61);
 626           #else
 627             rgblight_setrgb(127,0,61);
 628           #endif
 629           break;
 630         }
 631     }
 632   #endif
 633 }
 634
 635 //SSD1306 OLED update loop, make sure to add #define SSD1306OLED in config.h
 636 #ifdef SSD1306OLED
 637
 638 void matrix_update(struct CharacterMatrix *dest,
 639                           const struct CharacterMatrix *source) {
 640   if (memcmp(dest->display, source->display, sizeof(dest->display))) {
 641     memcpy(dest->display, source->display, sizeof(dest->display));
 642     dest->dirty = true;
 643   }
 644 }
 645
 646 // Render to OLED
 647 void render_status(struct CharacterMatrix *matrix) {
 648
 649   // froggy logo
 650   static char logo[4][1][17]=
 651   {
 652     {
 653       {0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f,0x70,0x71,0x72,0x73,0x74,0}
 654     },
 655     {
 656       {0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,0}
 657     },
 658     {
 659       {0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4,0}
 660     },
 661     {
 662       {0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0}
 663     }
 664   };
 665
 666   static char indctr[8][2][4]=
 667   {
 668     // white icon
 669     {
 670       {0x60,0x61,0x62,0},
 671       {0x63,0x64,0}
 672     },
 673     {
 674       {0x80,0x81,0x82,0},
 675       {0x83,0x84,0}
 676     },
 677     {
 678       {0xa0,0xa1,0xa2,0},
 679       {0xa3,0xa4,0}
 680     },
 681     {
 682       {0xc0,0xc1,0xc2,0},
 683       {0xc3,0xc4,0}
 684     },
 685     // Black icon
 686     {
 687       {0x75,0x76,0x77,0},
 688       {0x78,0x79,0}
 689     },
 690     {
 691       {0x95,0x96,0x97,0},
 692       {0x98,0x99,0}
 693     },
 694     {
 695       {0xb5,0xb6,0xb7,0},
 696       {0xb8,0xb9,0}
 697     },
 698     {
 699       {0xd5,0xd6,0xd7,0},
 700       {0xd8,0xd9,0}
 701     },
 702   };
 703
 704   int rown = 0;
 705   int rowf = 0;
 706   int rowa = 0;
 707   int rows = 0;
 708
 709   //Set Indicator icon
 710   if (host_keyboard_leds() & (1<<USB_LED_NUM_LOCK)) { rown = 4; } else { rown = 0; }
 711   if (host_keyboard_leds() & (1<<USB_LED_CAPS_LOCK)) { rowa = 4; } else { rowa = 0; }
 712   if (host_keyboard_leds() & (1<<USB_LED_SCROLL_LOCK)) { rows = 4; } else { rows = 0; }
 713   if (layer_state == L_FUNC) { rowf = 4; }
 714
 715   matrix_write(matrix, indctr[rown]  [0]);
 716   matrix_write(matrix, indctr[rowf]  [1]);
 717   matrix_write(matrix, logo  [0]     [0]);
 718   matrix_write(matrix, indctr[rown+1][0]);
 719   matrix_write(matrix, indctr[rowf+1][1]);
 720   matrix_write(matrix, logo  [1]     [0]);
 721   matrix_write(matrix, indctr[rowa+2][0]);
 722   matrix_write(matrix, indctr[rows+2][1]);
 723   matrix_write(matrix, logo  [2]     [0]);
 724   matrix_write(matrix, indctr[rowa+3][0]);
 725   matrix_write(matrix, indctr[rows+3][1]);
 726   matrix_write(matrix, logo  [3]     [0]);
 727
 728 }
 729
 730 void iota_gfx_task_user(void) {
 731   struct CharacterMatrix matrix;
 732
 733 #if DEBUG_TO_SCREEN
 734   if (debug_enable) {
 735     return;
 736   }
 737 #endif
 738
 739   matrix_clear(&matrix);
 740   if(is_master){
 741     render_status(&matrix);
 742   }
 743   matrix_update(&display, &matrix);
 744 }
 745
 746 #endif