Use FIRMWARE_FORMAT for "Checking file size" message (#8121 )

[Keymap] Adding ergodash/rev1:nopunin10did (#8098 )
* Adding ergodash/rev1:nopunin10did * Update keyboards/ergodash/rev1/keymaps/nopunin10did/keymap.c * Update keyboards/ergodash/rev1/keymaps/nopunin10did/keymap.c * Update keyboards/ergodash/rev1/keymaps/nopunin10did/readme.md
2020-02-10 04:19:08 +11:00 · 2020-02-08 19:54:10 -08:00 · 2020-02-08 23:58:28 +01:00 · 2020-02-08 11:07:43 -08:00 · 2020-02-08 10:25:50 -08:00 · 2020-02-08 13:43:55 +01:00
180 changed files with 3530 additions and 5414 deletions
@@ -0,0 +1,28 @@
 name: CLI CI
 on:
  push:
    branches:
    - master
    - future
  pull_request:
    paths:
    - 'lib/python/**'
    - 'bin/qmk'
    - 'requirements.txt'
    - '.github/workflows/cli.yml'
 jobs:
  test:
    runs-on: ubuntu-latest
    container: qmkfm/base_container
    steps:
    - uses: actions/checkout@v1
      with:
        submodules: recursive
    - name: Install dependencies
      run: pip3 install -r requirements.txt
    - name: Run tests
      run: bin/qmk pytest
@@ -81,7 +81,7 @@ qmk cformat [file1] [file2] [...] [fileN]
 ## `qmk compile`
-This command allows you to compile firmware from any directory. You can compile JSON exports from <https://config.qmk.fm> or compile keymaps in the repo.
+This command allows you to compile firmware from any directory. You can compile JSON exports from <https://config.qmk.fm>, compile keymaps in the repo, or compile the keyboard in the current working directory.
 **Usage for Configurator Exports**:
@@ -95,6 +95,53 @@ qmk compile <configuratorExport.json>
 qmk compile -kb <keyboard_name> -km <keymap_name>
 ```
 **Usage in Keyboard Directory**:  
 Must be in keyboard directory with a default keymap, or in keymap directory for keyboard, or supply one with `--keymap <keymap_name>`
 ```
 qmk compile
 ```
 **Example**:
 ```
 $ qmk config compile.keymap=default
 $ cd ~/qmk_firmware/keyboards/planck/rev6
 $ qmk compile
 Ψ Compiling keymap with make planck/rev6:default
 ...
 ```
 or with optional keymap argument
 ```
 $ cd ~/qmk_firmware/keyboards/clueboard/66/rev4 
 $ qmk compile -km 66_iso
 Ψ Compiling keymap with make clueboard/66/rev4:66_iso
 ...
 ```
 or in keymap directory
 ```
 $ cd ~/qmk_firmware/keyboards/gh60/satan/keymaps/colemak
 $ qmk compile
 Ψ Compiling keymap with make make gh60/satan:colemak
 ...
 ```
 **Usage in Layout Directory**:  
 Must be under `qmk_firmware/layouts/`, and in a keymap folder.
 ```
 qmk compile -kb <keyboard_name>
 ```
 **Example**:
 ```
 $ cd ~/qmk_firmware/layouts/community/60_ansi/mechmerlin-ansi
 $ qmk compile -kb dz60
 Ψ Compiling keymap with make dz60:mechmerlin-ansi
 ...
 ```
 ## `qmk flash`
 This command is similar to `qmk compile`, but can also target a bootloader. The bootloader is optional, and is set to `:flash` by default.
@@ -208,14 +208,11 @@ This is a reference only. Each group of keys links to the page documenting their
 ## [Quantum Keycodes](quantum_keycodes.md#qmk-keycodes)
-|Key            |Aliases    |Description                                                          |
+|Key           |Aliases  |Description                                            |
-|---------------|-----------|---------------------------------------------------------------------|
+|--------------|---------|-------------------------------------------------------|
-|`RESET`        |           |Put the keyboard into DFU mode for flashing                          |
+|`RESET`       |         |Put the keyboard into bootloader mode for flashing     |
-|`DEBUG`        |           |Toggle debug mode                                                    |
+|`DEBUG`       |         |Toggle debug mode                                      |
-|`EEPROM_RESET` |`EEP_RST`  |Resets EEPROM state by reinitializing it                             |
+|`EEPROM_RESET`|`EEP_RST`|Reinitializes the keyboard's EEPROM (persistent memory)|
 |`KC_GESC`      |`GRAVE_ESC`|Escape when tapped, <code>&#96;</code> when pressed with Shift or GUI|
 |`KC_LEAD`      |           |The [Leader key](feature_leader_key.md)                              |
 |`KC_LOCK`      |           |The [Lock key](feature_key_lock.md)                                  |
 ## [Audio Keys](feature_audio.md)
@@ -289,7 +286,7 @@ This is a reference only. Each group of keys links to the page documenting their
 ## [Dynamic Macros](feature_dynamic_macros.md)
-|Key              |Alias    |Description                                       |
+|Key              |Aliases  |Description                                       |
 |-----------------|---------|--------------------------------------------------|
 |`DYN_REC_START1` |`DM_REC1`|Start recording Macro 1                           |
 |`DYN_REC_START2` |`DM_REC2`|Start recording Macro 2                           |
@@ -297,6 +294,18 @@ This is a reference only. Each group of keys links to the page documenting their
 |`DYN_MACRO_PLAY2`|`DM_PLY2`|Replay Macro 2                                    |
 |`DYN_REC_STOP`   |`DM_RSTP`|Finish the macro that is currently being recorded.|
 ## [Grave Escape](feature_grave_esc.md)
 |Key        |Aliases  |Description                                                       |
 |-----------|---------|------------------------------------------------------------------|
 |`GRAVE_ESC`|`KC_GESC`|Escape when pressed, <code>&#96;</code> when Shift or GUI are held|
 ## [Key Lock](feature_key_lock.md)
 |Key      |Description                                                   |
 |---------|--------------------------------------------------------------|
 |`KC_LOCK`|Hold down the next key pressed, until the key is pressed again|
 ## [Layer Switching](feature_advanced_keycodes.md#switching-and-toggling-layers)
 |Key             |Description                                                                       |
@@ -310,6 +319,12 @@ This is a reference only. Each group of keys links to the page documenting their
 |`TO(layer)`     |Turns on `layer` and turns off all other layers, except the default layer |
 |`TT(layer)`     |Normally acts like MO unless it's tapped multiple times, which toggles `layer` on |
 ## [Leader Key](feature_leader_key.md)
 |Key      |Description             |
 |---------|------------------------|
 |`KC_LEAD`|Begins a leader sequence|
 ## [Mouse Keys](feature_mouse_keys.md)
 |Key             |Aliases  |Description                |
@@ -8,11 +8,8 @@ On this page we have documented keycodes between `0x00FF` and `0xFFFF` which are
 ## QMK Keycodes
-|Key            |Aliases    |Description                                                          |
+|Key           |Aliases  |Description                                            |
-|---------------|-----------|---------------------------------------------------------------------|
+|--------------|---------|-------------------------------------------------------|
-|`RESET`        |           |Put the keyboard into DFU mode for flashing                          |
+|`RESET`       |         |Put the keyboard into bootloader mode for flashing     |
-|`DEBUG`        |           |Toggle debug mode                                                    |
+|`DEBUG`       |         |Toggle debug mode                                      |
-|`EEPROM_RESET` |`EEP_RST`  |Resets EEPROM state by reinitializing it                             |
+|`EEPROM_RESET`|`EEP_RST`|Reinitializes the keyboard's EEPROM (persistent memory)|
 |`KC_GESC`      |`GRAVE_ESC`|Escape when tapped, <code>&#96;</code> when pressed with Shift or GUI|
 |`KC_LEAD`      |           |The [Leader key](feature_leader_key.md)                              |
 |`KC_LOCK`      |           |The [Lock key](feature_key_lock.md)                                  |
@@ -6,7 +6,6 @@ tmk_core/protocol/lufa
 tmk_core/protocol/midi
 tmk_core/protocol/midi/bytequeue
 tmk_core/protocol/midi/Config
 tmk_core/protocol/pjrc
 tmk_core/protocol/usb_hid
 tmk_core/protocol/vusb
 tmk_core/tool
@@ -16,147 +16,53 @@
 #include QMK_KEYBOARD_H
 // Layer shorthand
-enum layer {
+enum layer_names {
-  _1U,
+    _BASE,
-  _FN,
+    _FN,
  _HHKB,
  _7U,
  _2UARROW,
  _625UARROW,
 };
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-/* 1uGrid
+    /* Base Layer
- * .-----------------------------------------------------------------------------------------------------------------------------.
+     * .-----------------------------------------------------------------------------------------------------------------------------.
- * | ESC    | 1      | 2      | 3      | 4      | 5      | -      | =      | 6      | 7      | 8      | 9      | 0      | BACKSP |
+     * | ESC    | 1      | 2      | 3      | 4      | 5      | -      | =      | 6      | 7      | 8      | 9      | 0      | BACKSP |
- * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
+     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
- * | TAB    | Q      | W      | E      | R      | T      | [      | ]      | Y      | U      | I      | O      | P      | '      |
+     * | TAB    | Q      | W      | E      | R      | T      | [      | ]      | Y      | U      | I      | O      | P      | '      |
- * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------|
+     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------|
- * | CAP LK | A      | S      | D      | F      | G      | HOME   | PG UP  | H      | J      | K      | L      | ;      | ENTER  |
+     * | CAP LK | A      | S      | D      | F      | G      | HOME   | PG UP  | H      | J      | K      | L      | ;      | ENTER  |
- * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------------------------+--------|
+     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------------------------+--------|
- * | LSHIFT | Z      | X      | C      | V      | B      | END    | PG DN  | N      | M      | ,      | .      | /      | RSHIFT |
+     * | LSHIFT | Z      | X      | C      | V      | B      | END    | PG DN  | N      | M      | ,      | .      | /      | RSHIFT |
- * |--------+--------+--------+--------+--------+-----------------+--------+--------+--------+-----------------+--------+--------|
+     * |--------+--------+--------+--------+--------+-----------------+--------+--------+--------+-----------------+--------+--------|
- * | LCTRL  | LGUI   | FN     | LALT   | SPACE  | SPACE  | SPACE  | SPACE  | SPACE  | SPACE  | RIGHT  | DOWN   | UP     | RIGHT  |
+     * | LCTRL  | LGUI   | FN     | LALT   | SPACE  | SPACE  | SPACE  | SPACE  | SPACE  | LEFT   | DOWN   | UP     | RIGHT  | RCTRL  |
- * '-----------------------------------------------------------------------------------------------------------------------------'
+     * '-----------------------------------------------------------------------------------------------------------------------------'
- */
+     */
    [_BASE] = LAYOUT_ortho_5x14(
        KC_ESC,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_MINS, KC_EQL,  KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC,
        KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_LBRC, KC_RBRC, KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_QUOT,
        KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_HOME, KC_PGUP, KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_ENT,
        KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_END,  KC_PGDN, KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,
        KC_LCTL, KC_LGUI, MO(_FN), KC_LALT, KC_SPC,  KC_SPC,  KC_SPC,  KC_SPC,  KC_SPC,  KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT, KC_RCTL
    ),
- [_1U] = LAYOUT_ortho_5x14(
+    /* Function Layer
-  KC_ESC,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_MINS, KC_EQL,  KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC, \
+     * .-----------------------------------------------------------------------------------------------------------------------------.
-  KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_LBRC, KC_RBRC, KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_QUOT, \
+     * | `      | F1     | F2     | F3     | F4     | F5     | F6     | F7     | F8     | F9     | F10    | F11    | F12    | DEL    |
-  KC_LCTL, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_HOME, KC_PGUP, KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_ENT,  \
+     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
-  KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_END,  KC_PGDN, KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT, \
+     * |        |        | MENU   |        |        |        |        |        |        |        |        |        | PRT SC |        |
-  KC_LCTL, KC_LGUI, MO(1),   KC_LALT, KC_SPC,  KC_SPC,  KC_SPC,  KC_SPC,  KC_SPC,  KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT, KC_RCTL  \
+     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------|
- ),
+     * |        |        |        |        |        |        |        |        |        |        |        |        |        | RESET  |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------------------------+--------|
     * |        |        |        |        |        |        |        |        |        | MUTE   | VOL DN | VOL UP | \      |        |
     * |--------+--------+--------+--------+--------+-----------------+--------+--------+--------+-----------------+--------+--------|
     * |        |        |        |        |        |        |        |        |        |        |        |        |        |        |
     * '-----------------------------------------------------------------------------------------------------------------------------'
     */
    [_FN] = LAYOUT_ortho_5x14(
        KC_GRV,  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_APP,  _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_PSCR, _______,
        _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, RESET,
        _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_MUTE, KC_VOLD, KC_VOLU, KC_BSLS, _______,
        _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
    )
 /* HHKB
 * .-----------------------------------------------------------------------------------------------------------------------------.
 * | ESC    | 1      | 2      | 3      | 4      | 5      | -      | =      | 6      | 7      | 8      | 9      | 0      | BACKSP |
 * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
 * | TAB    | Q      | W      | E      | R      | T      | [      | ]      | Y      | U      | I      | O      | P      | '      |
 * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------|
 * | CAP LK | A      | S      | D      | F      | G      | HOME   | PG UP  | H      | J      | K      | L      | ;      | ENTER  |
 * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------------------------+--------|
 * | LSHIFT | Z      | X      | C      | V      | B      | END    | PG DN  | N      | M      | ,      | .      | /      | RSHIFT |
 * |--------+--------+--------+--------+--------+-----------------+--------+--------+--------+-----------------+--------+--------|
 * |        | LCTRL  | FN     | LALT   | LGUI   |      SPACE      |      SPACE      | LEFT   | DOWN  | UP      | RIGHT  |        |
 * '-----------------------------------------------------------------------------------------------------------------------------'
 */
 [_HHKB] = LAYOUT_ortho_hhkb(
  KC_ESC, KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    _______, _______, KC_6,   KC_7,    KC_8,    KC_9,    KC_0,    KC_BSLS, \
  KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    _______, _______, KC_Y,   KC_U,    KC_I,    KC_O,    KC_P,    KC_BSPC, \
  KC_LCTL, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    _______, _______, KC_H,   KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, \
  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_LCTL, MO(1),   KC_LALT, KC_LGUI,       KC_SPC,         KC_SPC,      KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT           \
 ),
  /* 7u HHKB
 * .-----------------------------------------------------------------------------------------------------------------------------.
 * | ESC    | 1      | 2      | 3      | 4      | 5      | -      | =      | 6      | 7      | 8      | 9      | 0      | BACKSP |
 * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
 * | TAB    | Q      | W      | E      | R      | T      | [      | ]      | Y      | U      | I      | O      | P      | '      |
 * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------|
 * | CAP LK | A      | S      | D      | F      | G      | HOME   | PG UP  | H      | J      | K      | L      | ;      | ENTER  |
 * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------------------------+--------|
 * | LSHIFT | Z      | X      | C      | V      | B      | END    | PG DN  | N      | M      | ,      | .      | /      | RSHIFT |
 * |--------+--------+--------+--------+--------+-----------------+--------+--------+--------+-----------------+--------+--------|
 * |        | LCTRL  | LALT       |                             SPACE                            | RALT        | FN     |        |
 * '-----------------------------------------------------------------------------------------------------------------------------'
 */
 [_7U] = LAYOUT_ortho_7u(
  KC_ESC, KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    _______, _______, KC_6,   KC_7,    KC_8,    KC_9,    KC_0,    KC_BSLS, \
  KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    _______, _______, KC_Y,   KC_U,    KC_I,    KC_O,    KC_P,    KC_BSPC, \
  KC_LCTL, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    _______, _______, KC_H,   KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, \
  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_LCTL, KC_LALT,                                KC_SPC,                                 KC_RALT, MO(1)             \
 ),
 /* 2x2u Space with Arrows
 * .-----------------------------------------------------------------------------------------------------------------------------.
 * | ESC    | 1      | 2      | 3      | 4      | 5      | 6      | 7      | 8      | 9      | 0      | -      | =      | BACKSP |
 * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
 * | TAB    | Q      | W      | E      | R      | T      | Y      | U      | I      | O      | P      | [      | ]      | \      |
 * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------|
 * | CAP LK | A      | S      | D      | F      | G      | H      | J      | K      | L      | ;      | "      | ENTER  | PG UP  |
 * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------------------------+--------|
 * | LSHIFT | Z      | X      | C      | V      | B      | N      | M      | ,      | .      | /      | SHIFT  | UP     | PG DN  |
 * |--------+--------+--------+--------+--------+-----------------+--------+--------+--------+-----------------+--------+--------|
 * | LCTRL  | LGUI   | FN     | LALT   |      SPACE      |      SPACE      | RALT   | RGUI   | RCTRL  | LEFT   | DOWN   | RIGHT  |
 * '-----------------------------------------------------------------------------------------------------------------------------'
 */
 [_2UARROW] = LAYOUT_2u_arrow(
  KC_ESC,  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_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_QUOT, \
  KC_LCTL, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_BSLS, KC_ENT,  KC_PGUP, \
  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_PGDN, \
  KC_LCTL, KC_LGUI, MO(1),   KC_LALT,     KC_SPC,          KC_SPC,        KC_RALT, KC_RGUI, KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT \
 ),
  /* 6.25u Space with Arrows
 * .-----------------------------------------------------------------------------------------------------------------------------.
 * | ESC    | 1      | 2      | 3      | 4      | 5      | 6      | 7      | 8      | 9      | 0      | -      | =      | BACKSP |
 * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
 * | TAB    | Q      | W      | E      | R      | T      | Y      | U      | I      | O      | P      | [      | ]      | \      |
 * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------|
 * | CAP LK | A      | S      | D      | F      | G      | H      | J      | K      | L      | ;      | "      | ENTER  | PG UP  |
 * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------------------------+--------|
 * | LSHIFT | Z      | X      | C      | V      | B      | N      | M      | ,      | .      | /      | SHIFT  | UP     | PG DN  |
 * |--------+--------+--------+--------+--------+-----------------+--------+--------+--------+-----------------+--------+--------|
 * | LCTRL  | LGUI   | LALT   |                        SPACE                        | FN     | RCTRL  | LEFT   | DOWN   | RIGHT  |
 * '-----------------------------------------------------------------------------------------------------------------------------'
 */
 [_625UARROW] = LAYOUT_625u_arrow(
  KC_ESC,  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_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_QUOT, \
  KC_LCTL, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_BSLS, KC_ENT,  KC_PGUP, \
  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_PGDN, \
  KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                      MO(1),   KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT \
 ),
 /* FUNCTION
 * .-----------------------------------------------------------------------------------------------------------------------------.
 * |        |        |        |        |        |        |        |        |        |        |        |        |        |        |
 * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
 * |        |        |        |        |        |        |        |        |        |        |        |        |        |        |
 * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------|
 * |        |        |        |        |        |        |        |        |        |        |        |        |        |        |
 * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------------------------+--------|
 * |        |        |        |        |        |        |        |        |        |        |        |        |        |        |
 * |--------+--------+--------+--------+--------+-----------------+--------+--------+--------+-----------------+--------+--------|
 * |        |        |        |        |        |        |        |        |        |        |        |        |        |        |
 * '-----------------------------------------------------------------------------------------------------------------------------'
 */
 [_FN] = LAYOUT_ortho_5x14(
  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
 )
 };
@@ -0,0 +1,68 @@
 /*
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include QMK_KEYBOARD_H
 // Layer shorthand
 enum layer {
    _BASE,
    _FN,
 };
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    /* Base Layer
     * .-----------------------------------------------------------------------------------------------------------------------------.
     * | ESC    | 1      | 2      | 3      | 4      | 5      | 6      | 7      | 8      | 9      | 0      | -      | =      | BACKSP |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
     * | TAB    | Q      | W      | E      | R      | T      | Y      | U      | I      | O      | P      | [      | ]      | \      |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------|
     * | CAP LK | A      | S      | D      | F      | G      | H      | J      | K      | L      | ;      | "      | ENTER  | PG UP  |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------------------------+--------|
     * | LSHIFT | Z      | X      | C      | V      | B      | N      | M      | ,      | .      | /      | SHIFT  | UP     | PG DN  |
     * |--------+--------+--------+--------+--------+-----------------+--------+--------+--------+-----------------+--------+--------|
     * | LCTRL  | LGUI   | FN     | LALT   |      SPACE      |      SPACE      | RALT   | RGUI   | RCTRL  | LEFT   | DOWN   | RIGHT  |
     * '-----------------------------------------------------------------------------------------------------------------------------'
     */
    [_BASE] = LAYOUT_2u_arrow(
        KC_ESC,  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_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_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_PGUP,
        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_PGDN,
        KC_LCTL, KC_LGUI, MO(_FN), KC_LALT,          KC_SPC,  KC_SPC,           KC_RALT, KC_RGUI, KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT
    ),
    /* Function Layer
     * .-----------------------------------------------------------------------------------------------------------------------------.
     * | `      | F1     | F2     | F3     | F4     | F5     | F6     | F7     | F8     | F9     | F10    | F11    | F12    | DEL    |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
     * |        |        | MENU   |        |        |        |        |        |        |        | PRT SC |        |        |        |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------|
     * |        |        |        |        |        |        |        |        |        |        |        |        |        | HOME   |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------------------------+--------|
     * |        |        |        |        |        |        |        | MUTE   | VOL DN | VOL UP |        |        |        | END    |
     * |--------+--------+--------+--------+--------+-----------------+--------+--------+--------+-----------------+--------+--------|
     * |        |        |        |        |                 |                 |        |        | RESET  |        |        |        |
     * '-----------------------------------------------------------------------------------------------------------------------------'
     */
    [_FN] = LAYOUT_2u_arrow(
        KC_GRV,  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_APP,  _______, _______, _______, _______, _______, _______, _______, KC_PSCR, _______, _______, _______,
        _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_HOME, 
        _______, _______, _______, _______, _______, _______, _______, KC_MUTE, KC_VOLD, KC_VOLU, _______, _______, _______, KC_END,
        _______, _______, _______, _______,          _______, _______,          _______, _______, RESET,   _______, _______, _______
    )
 };
@@ -0,0 +1 @@
 # The default_2u_arrow keymap for Boardwalk
@@ -0,0 +1,68 @@
 /*
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include QMK_KEYBOARD_H
 // Layer shorthand
 enum layer {
    _BASE,
    _FN,
 };
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    /* Base Layer
     * .-----------------------------------------------------------------------------------------------------------------------------.
     * | ESC    | 1      | 2      | 3      | 4      | 5      | 6      | 7      | 8      | 9      | 0      | -      | =      | BACKSP |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
     * | TAB    | Q      | W      | E      | R      | T      | Y      | U      | I      | O      | P      | [      | ]      | \      |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------|
     * | CAP LK | A      | S      | D      | F      | G      | H      | J      | K      | L      | ;      | "      | ENTER  | PG UP  |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------------------------+--------|
     * | LSHIFT | Z      | X      | C      | V      | B      | N      | M      | ,      | .      | /      | SHIFT  | UP     | PG DN  |
     * |--------+--------+--------+--------+--------+-----------------+--------+--------+--------+-----------------+--------+--------|
     * | LCTRL  | LGUI   | LALT   |                        SPACE                        | FN     | RCTRL  | LEFT   | DOWN   | RIGHT  |
     * '-----------------------------------------------------------------------------------------------------------------------------'
     */
    [_BASE] = LAYOUT_625u_arrow(
        KC_ESC,  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_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_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_PGUP, 
        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_PGDN, 
        KC_LCTL, KC_LGUI, KC_LALT,                        KC_SPC,                        MO(_FN), KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT  
    ),
    /* Function Layer
     * .-----------------------------------------------------------------------------------------------------------------------------.
     * | `      | F1     | F2     | F3     | F4     | F5     | F6     | F7     | F8     | F9     | F10    | F11    | F12    | DEL    |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
     * |        |        | MENU   |        |        |        |        |        |        |        | PRT SC |        |        |        |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------|
     * |        |        |        |        |        |        |        |        |        |        |        |        |        | HOME   |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------------------------+--------|
     * |        |        |        |        |        |        |        | MUTE   | VOL DN | VOL UP |        |        |        | END    |
     * |--------+--------+--------+--------+--------+-----------------+--------+--------+--------+-----------------+--------+--------|
     * |        |        |        |                                                     |        | RESET  |        |        |        |
     * '-----------------------------------------------------------------------------------------------------------------------------'
     */
    [_FN] = LAYOUT_625u_arrow(
        KC_GRV,  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_APP,  _______, _______, _______, _______, _______, _______, _______, KC_PSCR, _______, _______, _______,
        _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_HOME, 
        _______, _______, _______, _______, _______, _______, _______, KC_MUTE, KC_VOLD, KC_VOLU, _______, _______, _______, KC_END,
        _______, _______, _______,                        _______,                       _______, RESET,   _______, _______, _______
    )
 };
@@ -0,0 +1 @@
 # The default_625u_arrow keymap for Boardwalk
@@ -0,0 +1,68 @@
 /*
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include QMK_KEYBOARD_H
 // Layer shorthand
 enum layer {
    _BASE,
    _FN,
 };
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    /* Base Layer
     * .-----------------------------------------------------------------------------------------------------------------------------.
     * | ESC    | 1      | 2      | 3      | 4      | 5      | -      | =      | 6      | 7      | 8      | 9      | 0      | BACKSP |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
     * | TAB    | Q      | W      | E      | R      | T      | [      | ]      | Y      | U      | I      | O      | P      | '      |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------|
     * | CAP LK | A      | S      | D      | F      | G      | HOME   | PG UP  | H      | J      | K      | L      | ;      | ENTER  |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------------------------+--------|
     * | LSHIFT | Z      | X      | C      | V      | B      | END    | PG DN  | N      | M      | ,      | .      | /      | RSHIFT |
     * '--------+--------+--------+--------+--------+-----------------+--------+--------+--------+-----------------+--------+--------'
     *          | LCTRL  | LALT       |                             SPACE                            | RALT        | FN     |
     *          '-----------------------------------------------------------------------------------------------------------'
     */
    [_BASE] = LAYOUT_ortho_7u(
        KC_ESC,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_MINS, KC_EQL,  KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC,
        KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_LBRC, KC_RBRC, KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_QUOT,
        KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_HOME, KC_PGUP, KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_ENT,
        KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_END,  KC_PGDN, KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,
                 KC_LCTL, KC_LALT,                                 KC_SPC,                                 KC_RALT, MO(_FN)
    ),
    /* Function Layer
     * .-----------------------------------------------------------------------------------------------------------------------------.
     * | `      | F1     | F2     | F3     | F4     | F5     | F6     | F7     | F8     | F9     | F10    | F11    | F12    | DEL    |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
     * |        |        | MENU   |        |        |        |        |        |        |        |        |        | PRT SC |        |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------|
     * |        |        |        |        |        |        |        |        |        |        |        |        |        | RESET  |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------------------------+--------|
     * |        |        |        |        |        |        |        |        |        | MUTE   | VOL DN | VOL UP | \      |        |
     * '--------+--------+--------+--------+--------+-----------------+--------+--------+--------+-----------------+--------+--------'
     *          |        |            |                                                              |             |        |
     *          '-----------------------------------------------------------------------------------------------------------'
     */
    [_FN] = LAYOUT_ortho_7u(
        KC_GRV,  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_APP,  _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_PSCR, _______,
        _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, RESET,
        _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_MUTE, KC_VOLD, KC_VOLU, KC_BSLS, _______,
                 _______, _______,                                 _______,                                _______, _______
    )
 };
@@ -0,0 +1 @@
 # The default_ortho_7u keymap for Boardwalk
@@ -0,0 +1,68 @@
 /*
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include QMK_KEYBOARD_H
 // Layer shorthand
 enum layer {
    _BASE,
    _FN,
 };
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    /* Base Layer
     * .-----------------------------------------------------------------------------------------------------------------------------.
     * | ESC    | 1      | 2      | 3      | 4      | 5      | -      | =      | 6      | 7      | 8      | 9      | 0      | BACKSP |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
     * | TAB    | Q      | W      | E      | R      | T      | [      | ]      | Y      | U      | I      | O      | P      | '      |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------|
     * | CAP LK | A      | S      | D      | F      | G      | HOME   | PG UP  | H      | J      | K      | L      | ;      | ENTER  |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------------------------+--------|
     * | LSHIFT | Z      | X      | C      | V      | B      | END    | PG DN  | N      | M      | ,      | .      | /      | RSHIFT |
     * '--------+--------+--------+--------+--------+-----------------+--------+--------+--------+-----------------+--------+--------'
     *          | LCTRL  | FN     | LALT   | LGUI   |      SPACE      |      SPACE      | LEFT   | DOWN  | UP      | RIGHT  |
     *          '-----------------------------------------------------------------------------------------------------------'
     */
    [_BASE] = LAYOUT_ortho_hhkb(
        KC_ESC,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_MINS, KC_EQL,  KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC,
        KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_LBRC, KC_RBRC, KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_QUOT,
        KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_HOME, KC_PGUP, KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_ENT,
        KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_END,  KC_PGDN, KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,
                 KC_LCTL, MO(_FN), KC_LALT, KC_LGUI,          KC_SPC,  KC_SPC,           KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT
    ),
    /* Function Layer
     * .-----------------------------------------------------------------------------------------------------------------------------.
     * | `      | F1     | F2     | F3     | F4     | F5     | F6     | F7     | F8     | F9     | F10    | F11    | F12    | DEL    |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
     * |        |        | MENU   |        |        |        |        |        |        |        |        |        | PRT SC |        |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------|
     * |        |        |        |        |        |        |        |        |        |        |        |        |        | RESET  |
     * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------------------------+--------|
     * |        |        |        |        |        |        |        |        |        | MUTE   | VOL DN | VOL UP | \      |        |
     * '--------+--------+--------+--------+--------+-----------------+--------+--------+--------+-----------------+--------+--------'
     *          |        |        |        |        |                 |                 |        |        |        |        |        
     *          '-----------------------------------------------------------------------------------------------------------'
     */
    [_FN] = LAYOUT_ortho_hhkb(
        KC_GRV,  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_APP,  _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_PSCR, _______,
        _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, RESET,
        _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_MUTE, KC_VOLD, KC_VOLU, KC_BSLS, _______,
                 _______, _______, _______, _______,          _______, _______,          _______, _______, _______, _______
    )
 };
@@ -0,0 +1 @@
 # The default_ortho_hhkb keymap for Boardwalk
@@ -1,13 +1,13 @@
 # Boardwalk
-![Boardwalk](https://i.imgur.com/CQj3b9E.jpg)
+![Boardwalk](https://i.imgur.com/CQj3b9El.jpg)
 The Boardwalk is a 60% ortholinear keyboard, designed around Ergodox keycap sets and to fit into many standard 60% cases. The project was inspired by OLKB’s Atomic keyboard, which used larger 2u mods, but u/shensmobile
 decided to switch to 1.5u keys so that Ergodox sets would provide excellent compatibility. The rest of the board can be covered using standard key sizes from 60% sets.
-Keyboard Maintainer: QMK Community  
+* Keyboard Maintainer: QMK Community
-Hardware Supported: Boardwalk Ortholinear PCB  
+* Hardware Supported: Boardwalk Ortholinear PCB
-Hardware Availability: [panc.co](https://www.panc.co/boardwalk-group-buy.html)
+* Hardware Availability: [panc.co](https://www.panc.co/boardwalk-group-buy.html)
 Make example for this keyboard (after setting up your build environment):
@@ -141,8 +141,6 @@ inline bool board_is_master(board_info_t* board) {
    return false;
 }
 inline uint8_t matrix_rows(void) { return MATRIX_ROWS; }
 inline uint8_t matrix2board(uint8_t row) { return row % NUM_ROWS; }
 inline uint8_t board_index(uint8_t row) { return row / NUM_ROWS; }
@@ -13,3 +13,5 @@
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "chidori.h"
@@ -13,47 +13,45 @@
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #pragma once
 #include "quantum.h"
 // clang-format off
 #define LAYOUT( \
-        L01, L02, L03, L04, L05, L06, R01, R02, R03, R04, R05, R06, \
+    L01, L02, L03, L04, L05, L06, R01, R02, R03, R04, R05, R06, \
-        L07, L08, L09, L10, L11, L12, R07, R08, R09, R10, R11, R12, \
+    L07, L08, L09, L10, L11, L12, R07, R08, R09, R10, R11, R12, \
-        L13, L14, L15, L16, L17, L18, R13, R14, R15, R16, R17, R18, \
+    L13, L14, L15, L16, L17, L18, R13, R14, R15, R16, R17, R18, \
-        L19, L20, L21, L22, L23, L24, R19, R20, R21, R22, R23, R24  \
+    L19, L20, L21, L22, L23, L24, R19, R20, R21, R22, R23, R24  \
-    ) \
+) { \
-    { \
+    { L01, L02, L03, L04, L05, L06 }, \
-        { L01, L02, L03, L04, L05, L06 }, \
+    { L07, L08, L09, L10, L11, L12 }, \
-        { L07, L08, L09, L10, L11, L12 }, \
+    { L13, L14, L15, L16, L17, L18 }, \
-        { L13, L14, L15, L16, L17, L18 }, \
+    { L19, L20, L21, L22, L23, L24 }, \
-        { L19, L20, L21, L22, L23, L24 }, \
+    { R01, R02, R03, R04, R05, R06 }, \
-        { R01, R02, R03, R04, R05, R06 }, \
+    { R07, R08, R09, R10, R11, R12 }, \
-        { R07, R08, R09, R10, R11, R12 }, \
+    { R13, R14, R15, R16, R17, R18 }, \
-        { R13, R14, R15, R16, R17, R18 }, \
+    { R19, R20, R21, R22, R23, R24 }  \
-        { R19, R20, R21, R22, R23, R24 }  \
+}
    }
 #define LAYOUT_extended( \
-        L01, L02, L03, L04, L05, L06, M01, M02, M03, M04, M05, M06, R01, R02, R03, R04, R05, R06, \
+    L01, L02, L03, L04, L05, L06, M01, M02, M03, M04, M05, M06, R01, R02, R03, R04, R05, R06, \
-        L07, L08, L09, L10, L11, L12, M07, M08, M09, M10, M11, M12, R07, R08, R09, R10, R11, R12, \
+    L07, L08, L09, L10, L11, L12, M07, M08, M09, M10, M11, M12, R07, R08, R09, R10, R11, R12, \
-        L13, L14, L15, L16, L17, L18, M13, M14, M15, M16, M17, M18, R13, R14, R15, R16, R17, R18, \
+    L13, L14, L15, L16, L17, L18, M13, M14, M15, M16, M17, M18, R13, R14, R15, R16, R17, R18, \
-        L19, L20, L21, L22, L23, L24, M19, M20, M21, M22, M23, M24, R19, R20, R21, R22, R23, R24  \
+    L19, L20, L21, L22, L23, L24, M19, M20, M21, M22, M23, M24, R19, R20, R21, R22, R23, R24  \
-    ) \
+) { \
-    { \
+    { L01, L02, L03, L04, L05, L06 }, \
-        { L01, L02, L03, L04, L05, L06 }, \
+    { L07, L08, L09, L10, L11, L12 }, \
-        { L07, L08, L09, L10, L11, L12 }, \
+    { L13, L14, L15, L16, L17, L18 }, \
-        { L13, L14, L15, L16, L17, L18 }, \
+    { L19, L20, L21, L22, L23, L24 }, \
-        { L19, L20, L21, L22, L23, L24 }, \
+    { M01, M02, M03, M04, M05, M06 }, \
-        { M01, M02, M03, M04, M05, M06 }, \
+    { M07, M08, M09, M10, M11, M12 }, \
-        { M07, M08, M09, M10, M11, M12 }, \
+    { M13, M14, M15, M16, M17, M18 }, \
-        { M13, M14, M15, M16, M17, M18 }, \
+    { M19, M20, M21, M22, M23, M24 }, \
-        { M19, M20, M21, M22, M23, M24 }, \
+    { R01, R02, R03, R04, R05, R06 }, \
-        { R01, R02, R03, R04, R05, R06 }, \
+    { R07, R08, R09, R10, R11, R12 }, \
-        { R07, R08, R09, R10, R11, R12 }, \
+    { R13, R14, R15, R16, R17, R18 }, \
-        { R13, R14, R15, R16, R17, R18 }, \
+    { R19, R20, R21, R22, R23, R24 }  \
-        { R19, R20, R21, R22, R23, R24 }  \
+}
    }
 // clang-format on
@@ -162,15 +162,9 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
    return true;
 }
-void led_set_user(uint8_t usb_led) {
+bool led_update_user(led_t led_state) {
-    if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK)) {
+    board_set_led_by_index(0, LED_YELLOW, led_state.caps_lock);
-        board_set_led_by_index(0, LED_YELLOW, true);
+    board_set_led_by_index(1, LED_YELLOW, led_state.scroll_lock);
-    } else {
+
-        board_set_led_by_index(0, LED_YELLOW, false);
+    return false;
    }
    if (IS_LED_ON(usb_led, USB_LED_SCROLL_LOCK)) {
        board_set_led_by_index(1, LED_YELLOW, true);
    } else {
        board_set_led_by_index(1, LED_YELLOW, false);
    }
 }
@@ -162,20 +162,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
    return true;
 }
-void led_set_user(uint8_t usb_led) {
+bool led_update_user(led_t led_state) {
-    if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK)) {
+    board_set_led_by_index(0, LED_YELLOW, led_state.caps_lock);
-        board_set_led_by_index(0, LED_YELLOW, true);
+    board_set_led_by_index(1, LED_YELLOW, led_state.scroll_lock);
-    } else {
+    board_set_led_by_index(2, LED_YELLOW, led_state.num_lock);
-        board_set_led_by_index(0, LED_YELLOW, false);
+
-    }
+    return false;
    if (IS_LED_ON(usb_led, USB_LED_SCROLL_LOCK)) {
        board_set_led_by_index(1, LED_YELLOW, true);
    } else {
        board_set_led_by_index(1, LED_YELLOW, false);
    }
    if (IS_LED_ON(usb_led, USB_LED_NUM_LOCK)) {
        board_set_led_by_index(2, LED_YELLOW, true);
    } else {
        board_set_led_by_index(2, LED_YELLOW, false);
    }
 }
@@ -14,100 +14,23 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-#include <stdint.h>
+
 #include <stdbool.h>
 #include "wait.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 #include "matrix.h"
 #include "debounce.h"
 #include "quantum.h"
 #include "matrix.h"
 #include "board.h"
-#if (MATRIX_COLS <= 8)
+void matrix_init_custom(void) {
 #    define print_matrix_header() print("\nr/c 01234567\n")
 #    define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
 #    define matrix_bitpop(i) bitpop(matrix[i])
 #    define ROW_SHIFTER ((uint8_t)1)
 #elif (MATRIX_COLS <= 16)
 #    define print_matrix_header() print("\nr/c 0123456789ABCDEF\n")
 #    define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row))
 #    define matrix_bitpop(i) bitpop16(matrix[i])
 #    define ROW_SHIFTER ((uint16_t)1)
 #elif (MATRIX_COLS <= 32)
 #    define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
 #    define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row))
 #    define matrix_bitpop(i) bitpop32(matrix[i])
 #    define ROW_SHIFTER ((uint32_t)1)
 #endif
 #ifdef MATRIX_MASKED
 extern const matrix_row_t matrix_mask[];
 #endif
 /* matrix state(1:on, 0:off) */
 static matrix_row_t raw_matrix[MATRIX_ROWS];  // raw values
 static matrix_row_t matrix[MATRIX_ROWS];      // debounced values
 __attribute__((weak)) void matrix_init_quantum(void) { matrix_init_kb(); }
 __attribute__((weak)) void matrix_scan_quantum(void) { matrix_scan_kb(); }
 __attribute__((weak)) void matrix_init_kb(void) { matrix_init_user(); }
 __attribute__((weak)) void matrix_scan_kb(void) { matrix_scan_user(); }
 __attribute__((weak)) void matrix_init_user(void) {}
 __attribute__((weak)) void matrix_scan_user(void) {}
 inline matrix_row_t matrix_get_row(uint8_t row) {
    // Matrix mask lets you disable switches in the returned matrix data. For example, if you have a
    // switch blocker installed and the switch is always pressed.
 #ifdef MATRIX_MASKED
    return matrix[row] & matrix_mask[row];
 #else
    return matrix[row];
 #endif
 }
 void matrix_print(void) {
    print_matrix_header();
    for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
        phex(row);
        print(": ");
        print_matrix_row(row);
        print("\n");
    }
 }
 void matrix_init(void) {
    // initialize key pins
    board_init();
    // initialize matrix state: all keys off
    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
        raw_matrix[i] = 0;
        matrix[i]     = 0;
    }
    debounce_init(MATRIX_ROWS);
    matrix_init_quantum();
 }
-uint8_t matrix_scan(void) {
+bool matrix_scan_custom(matrix_row_t current_matrix[]) {
    bool changed = false;
    // Set row, read cols
    for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) {
-        changed |= board_read_cols_on_row(raw_matrix, current_row);
+        changed |= board_read_cols_on_row(current_matrix, current_row);
    }
-    debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
+    return changed;
    matrix_scan_quantum();
    return 1;
 }
@@ -1,9 +1,5 @@
 # MCU name
 MCU = atmega328p
 ARCH = AVR8
 F_USB = $(F_CPU)
 OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
 # Bootloader selection
 #   Teensy       halfkay
@@ -36,7 +32,7 @@ AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
 HD44780_ENABLE = no        # Enable support for HD44780 based LCDs
-CUSTOM_MATRIX = yes
+CUSTOM_MATRIX = lite
 # project specific files
 SRC += matrix.c
@@ -109,21 +109,10 @@ section at the end of this file).
 * (e.g. HID), but never want to send any data. This option saves a couple
 * of bytes in flash memory and the transmit buffers in RAM.
 */
 #define USB_CFG_INTR_POLL_INTERVAL      1
 /* If you compile a version with endpoint 1 (interrupt-in), this is the poll
 * interval. The value is in milliseconds and must not be less than 10 ms for
 * low speed devices.
 */
 #define USB_CFG_IS_SELF_POWERED         0
 /* Define this to 1 if the device has its own power supply. Set it to 0 if the
 * device is powered from the USB bus.
 */
 // max power draw with maxed white underglow measured at 120 mA (peaks)
 #define USB_CFG_MAX_BUS_POWER           100
 /* Set this variable to the maximum USB bus power consumption of your device.
 * The value is in milliamperes. [It will be divided by two since USB
 * communicates power requirements in units of 2 mA.]
 */
 #define USB_CFG_IMPLEMENT_FN_WRITE      1
 /* Set this to 1 if you want usbFunctionWrite() to be called for control-out
 * transfers. Set it to 0 if you don't need it and want to save a couple of
@@ -219,7 +208,7 @@ section at the end of this file).
 /* -------------------------- Device Description --------------------------- */
-#define USB_CFG_VENDOR_ID       (VENDOR_ID & 0xED), ((VENDOR_ID >> 8) & 0xFE)
+#define USB_CFG_VENDOR_ID       (VENDOR_ID & 0xFF), ((VENDOR_ID >> 8) & 0xFF)
 /* USB vendor ID for the device, low byte first. If you have registered your
 * own Vendor ID, define it here. Otherwise you may use one of obdev's free
 * shared VID/PID pairs. Be sure to read USB-IDs-for-free.txt for rules!
@@ -228,7 +217,7 @@ section at the end of this file).
 * with libusb: 0x16c0/0x5dc.  Use this VID/PID pair ONLY if you understand
 * the implications!
 */
-#define USB_CFG_DEVICE_ID       (PRODUCT_ID & 0x00), ((PRODUCT_ID >> 8) & 0x00)
+#define USB_CFG_DEVICE_ID       (PRODUCT_ID & 0xFF), ((PRODUCT_ID >> 8) & 0xFF)
 /* This is the ID of the product, low byte first. It is interpreted in the
 * scope of the vendor ID. If you have registered your own VID with usb.org
 * or if you have licensed a PID from somebody else, define it here. Otherwise
@@ -239,10 +228,10 @@ section at the end of this file).
 * with libusb: 0x16c0/0x5dc.  Use this VID/PID pair ONLY if you understand
 * the implications!
 */
-#define USB_CFG_DEVICE_VERSION  0x00, 0x01
+#define USB_CFG_DEVICE_VERSION  (DEVICE_VER & 0xFF), ((DEVICE_VER >> 8) & 0xFF)
 /* Version number of the device: Minor number first, then major number.
 */
-#define USB_CFG_VENDOR_NAME     'k','a','g','i','z','a','r','a','y','a'
+#define USB_CFG_VENDOR_NAME     'K','a','g','i','z','a','r','a','y','a'
 #define USB_CFG_VENDOR_NAME_LEN 10
 /* These two values define the vendor name returned by the USB device. The name
 * must be given as a list of characters under single quotes. The characters
@@ -258,8 +247,8 @@ section at the end of this file).
 * the macros. See the file USB-IDs-for-free.txt before you assign a name if
 * you use a shared VID/PID.
 */
-//#define USB_CFG_SERIAL_NUMBER   'd','m','9','r','e','c','o','r','d','s','.','c','o','m',':','p','1'
+/*#define USB_CFG_SERIAL_NUMBER   'N', 'o', 'n', 'e' */
-//#define USB_CFG_SERIAL_NUMBER_LEN   17
+/*#define USB_CFG_SERIAL_NUMBER_LEN   0 */
 /* Same as above for the serial number. If you don't want a serial number,
 * undefine the macros.
 * It may be useful to provide the serial number through other means than at
@@ -16,9 +16,6 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-#ifndef CONFIG_H
+#pragma once
 #define CONFIG_H
 #include "config_common.h"
 #endif
@@ -1,5 +1,4 @@
-#ifndef ERGO42_H
+#pragma once
 #define ERGO42_H
 #include "quantum.h"
@@ -7,7 +6,6 @@
    #include "rev1.h"
 #endif
 // Used to create a keymap using only KC_ prefixed keys
 #define LAYOUT_kc_ortho_4x14( \
    L00, L01, L02, L03, L04, L05, L06, R00, R01, R02, R03, R04, R05, R06, \
@@ -23,5 +21,3 @@
    )
 #define LAYOUT_kc LAYOUT_kc_ortho_4x14
 #endif
@@ -1,162 +0,0 @@
 #include <util/twi.h>
 #include <avr/io.h>
 #include <stdlib.h>
 #include <avr/interrupt.h>
 #include <util/twi.h>
 #include <stdbool.h>
 #include "i2c.h"
 #ifdef USE_I2C
 // Limits the amount of we wait for any one i2c transaction.
 // Since were running SCL line 100kHz (=> 10μs/bit), and each transactions is
 // 9 bits, a single transaction will take around 90μs to complete.
 //
 // (F_CPU/SCL_CLOCK)  =>  # of μC cycles to transfer a bit
 // poll loop takes at least 8 clock cycles to execute
 #define I2C_LOOP_TIMEOUT (9+1)*(F_CPU/SCL_CLOCK)/8
 #define BUFFER_POS_INC() (slave_buffer_pos = (slave_buffer_pos+1)%SLAVE_BUFFER_SIZE)
 volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];
 static volatile uint8_t slave_buffer_pos;
 static volatile bool slave_has_register_set = false;
 // Wait for an i2c operation to finish
 inline static
 void i2c_delay(void) {
  uint16_t lim = 0;
  while(!(TWCR & (1<<TWINT)) && lim < I2C_LOOP_TIMEOUT)
    lim++;
  // easier way, but will wait slightly longer
  // _delay_us(100);
 }
 // Setup twi to run at 100kHz
 void i2c_master_init(void) {
  // no prescaler
  TWSR = 0;
  // Set TWI clock frequency to SCL_CLOCK. Need TWBR>10.
  // Check datasheets for more info.
  TWBR = ((F_CPU/SCL_CLOCK)-16)/2;
 }
 // Start a transaction with the given i2c slave address. The direction of the
 // transfer is set with I2C_READ and I2C_WRITE.
 // returns: 0 => success
 //          1 => error
 uint8_t i2c_master_start(uint8_t address) {
  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA);
  i2c_delay();
  // check that we started successfully
  if ( (TW_STATUS != TW_START) && (TW_STATUS != TW_REP_START))
    return 1;
  TWDR = address;
  TWCR = (1<<TWINT) | (1<<TWEN);
  i2c_delay();
  if ( (TW_STATUS != TW_MT_SLA_ACK) && (TW_STATUS != TW_MR_SLA_ACK) )
    return 1; // slave did not acknowledge
  else
    return 0; // success
 }
 // Finish the i2c transaction.
 void i2c_master_stop(void) {
  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
  uint16_t lim = 0;
  while(!(TWCR & (1<<TWSTO)) && lim < I2C_LOOP_TIMEOUT)
    lim++;
 }
 // Write one byte to the i2c slave.
 // returns 0 => slave ACK
 //         1 => slave NACK
 uint8_t i2c_master_write(uint8_t data) {
  TWDR = data;
  TWCR = (1<<TWINT) | (1<<TWEN);
  i2c_delay();
  // check if the slave acknowledged us
  return (TW_STATUS == TW_MT_DATA_ACK) ? 0 : 1;
 }
 // Read one byte from the i2c slave. If ack=1 the slave is acknowledged,
 // if ack=0 the acknowledge bit is not set.
 // returns: byte read from i2c device
 uint8_t i2c_master_read(int ack) {
  TWCR = (1<<TWINT) | (1<<TWEN) | (ack<<TWEA);
  i2c_delay();
  return TWDR;
 }
 void i2c_reset_state(void) {
  TWCR = 0;
 }
 void i2c_slave_init(uint8_t address) {
  TWAR = address << 0; // slave i2c address
  // TWEN  - twi enable
  // TWEA  - enable address acknowledgement
  // TWINT - twi interrupt flag
  // TWIE  - enable the twi interrupt
  TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN);
 }
 ISR(TWI_vect);
 ISR(TWI_vect) {
  uint8_t ack = 1;
  switch(TW_STATUS) {
    case TW_SR_SLA_ACK:
      // this device has been addressed as a slave receiver
      slave_has_register_set = false;
      break;
    case TW_SR_DATA_ACK:
      // this device has received data as a slave receiver
      // The first byte that we receive in this transaction sets the location
      // of the read/write location of the slaves memory that it exposes over
      // i2c.  After that, bytes will be written at slave_buffer_pos, incrementing
      // slave_buffer_pos after each write.
      if(!slave_has_register_set) {
        slave_buffer_pos = TWDR;
        // don't acknowledge the master if this memory loctaion is out of bounds
        if ( slave_buffer_pos >= SLAVE_BUFFER_SIZE ) {
          ack = 0;
          slave_buffer_pos = 0;
        }
        slave_has_register_set = true;
      } else {
        i2c_slave_buffer[slave_buffer_pos] = TWDR;
        BUFFER_POS_INC();
      }
      break;
    case TW_ST_SLA_ACK:
    case TW_ST_DATA_ACK:
      // master has addressed this device as a slave transmitter and is
      // requesting data.
      TWDR = i2c_slave_buffer[slave_buffer_pos];
      BUFFER_POS_INC();
      break;
    case TW_BUS_ERROR: // something went wrong, reset twi state
      TWCR = 0;
    default:
      break;
  }
  // Reset everything, so we are ready for the next TWI interrupt
  TWCR |= (1<<TWIE) | (1<<TWINT) | (ack<<TWEA) | (1<<TWEN);
 }
 #endif
@@ -1,49 +0,0 @@
 #ifndef I2C_H
 #define I2C_H
 #include <stdint.h>
 #ifndef F_CPU
 #define F_CPU 16000000UL
 #endif
 #define I2C_READ 1
 #define I2C_WRITE 0
 #define I2C_ACK 1
 #define I2C_NACK 0
 #define SLAVE_BUFFER_SIZE 0x10
 // i2c SCL clock frequency
 #define SCL_CLOCK  400000L
 extern volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];
 void i2c_master_init(void);
 uint8_t i2c_master_start(uint8_t address);
 void i2c_master_stop(void);
 uint8_t i2c_master_write(uint8_t data);
 uint8_t i2c_master_read(int);
 void i2c_reset_state(void);
 void i2c_slave_init(uint8_t address);
 static inline unsigned char i2c_start_read(unsigned char addr) {
  return i2c_master_start((addr << 1) | I2C_READ);
 }
 static inline unsigned char i2c_start_write(unsigned char addr) {
  return i2c_master_start((addr << 1) | I2C_WRITE);
 }
 // from SSD1306 scrips
 extern unsigned char i2c_rep_start(unsigned char addr);
 extern void i2c_start_wait(unsigned char addr);
 extern unsigned char i2c_readAck(void);
 extern unsigned char i2c_readNak(void);
 extern unsigned char i2c_read(unsigned char ack);
 #define i2c_read(ack)  (ack) ? i2c_readAck() : i2c_readNak();
 #endif
@@ -1,459 +0,0 @@
 /*
 Copyright 2012 Jun Wako <[email protected]>
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 2 of the License, or
 (at your option) any later version.
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 /*
 * scan matrix
 */
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/io.h>
 #include "wait.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 #include "matrix.h"
 #include "split_util.h"
 #include "pro_micro.h"
 #include "config.h"
 #include "timer.h"
 #ifdef USE_I2C
 #  include "i2c.h"
 #else // USE_SERIAL
 #  include "serial.h"
 #endif
 #ifndef DEBOUNCE
 #   define DEBOUNCE 5
 #endif
 #if (DEBOUNCE > 0)
    static uint16_t debouncing_time;
    static bool debouncing = false;
 #endif
 #if (MATRIX_COLS <= 8)
 #    define print_matrix_header()  print("\nr/c 01234567\n")
 #    define print_matrix_row(row)  print_bin_reverse8(matrix_get_row(row))
 #    define matrix_bitpop(i)       bitpop(matrix[i])
 #    define ROW_SHIFTER ((uint8_t)1)
 #else
 #    error "Currently only supports 8 COLS"
 #endif
 static matrix_row_t matrix_debouncing[MATRIX_ROWS];
 #define ERROR_DISCONNECT_COUNT 5
 #define ROWS_PER_HAND (MATRIX_ROWS/2)
 static uint8_t error_count = 0;
 static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
 static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
 /* matrix state(1:on, 0:off) */
 static matrix_row_t matrix[MATRIX_ROWS];
 static matrix_row_t matrix_debouncing[MATRIX_ROWS];
 #if (DIODE_DIRECTION == COL2ROW)
    static void init_cols(void);
    static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row);
    static void unselect_rows(void);
    static void select_row(uint8_t row);
    static void unselect_row(uint8_t row);
 #elif (DIODE_DIRECTION == ROW2COL)
    static void init_rows(void);
    static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col);
    static void unselect_cols(void);
    static void unselect_col(uint8_t col);
    static void select_col(uint8_t col);
 #endif
 __attribute__ ((weak))
 void matrix_init_kb(void) {
    matrix_init_user();
 }
 __attribute__ ((weak))
 void matrix_scan_kb(void) {
    matrix_scan_user();
 }
 __attribute__ ((weak))
 void matrix_init_user(void) {
 }
 __attribute__ ((weak))
 void matrix_scan_user(void) {
 }
 inline
 uint8_t matrix_rows(void)
 {
    return MATRIX_ROWS;
 }
 inline
 uint8_t matrix_cols(void)
 {
    return MATRIX_COLS;
 }
 void matrix_init(void)
 {
    debug_enable = true;
    debug_matrix = true;
    debug_mouse = true;
    // initialize row and col
 #if (DIODE_DIRECTION == COL2ROW)
    unselect_rows();
    init_cols();
 #elif (DIODE_DIRECTION == ROW2COL)
    unselect_cols();
    init_rows();
 #endif
    TX_RX_LED_INIT;
    // initialize matrix state: all keys off
    for (uint8_t i=0; i < MATRIX_ROWS; i++) {
        matrix[i] = 0;
        matrix_debouncing[i] = 0;
    }
    matrix_init_quantum();
 }
 uint8_t _matrix_scan(void)
 {
    int offset = isLeftHand ? 0 : (ROWS_PER_HAND);
 #if (DIODE_DIRECTION == COL2ROW)
    // Set row, read cols
    for (uint8_t current_row = 0; current_row < ROWS_PER_HAND; current_row++) {
 #       if (DEBOUNCE > 0)
            bool matrix_changed = read_cols_on_row(matrix_debouncing+offset, current_row);
            if (matrix_changed) {
                debouncing = true;
                debouncing_time = timer_read();
            }
 #       else
            read_cols_on_row(matrix+offset, current_row);
 #       endif
    }
 #elif (DIODE_DIRECTION == ROW2COL)
    // Set col, read rows
    for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
 #       if (DEBOUNCE > 0)
            bool matrix_changed = read_rows_on_col(matrix_debouncing+offset, current_col);
            if (matrix_changed) {
                debouncing = true;
                debouncing_time = timer_read();
            }
 #       else
             read_rows_on_col(matrix+offset, current_col);
 #       endif
    }
 #endif
 #   if (DEBOUNCE > 0)
        if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCE)) {
            for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
                matrix[i+offset] = matrix_debouncing[i+offset];
            }
            debouncing = false;
        }
 #   endif
    return 1;
 }
 #ifdef USE_I2C
 // Get rows from other half over i2c
 int i2c_transaction(void) {
    int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
    int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
    if (err) goto i2c_error;
    // start of matrix stored at 0x00
    err = i2c_master_write(0x00);
    if (err) goto i2c_error;
    // Start read
    err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ);
    if (err) goto i2c_error;
    if (!err) {
        int i;
        for (i = 0; i < ROWS_PER_HAND-1; ++i) {
            matrix[slaveOffset+i] = i2c_master_read(I2C_ACK);
        }
        matrix[slaveOffset+i] = i2c_master_read(I2C_NACK);
        i2c_master_stop();
    } else {
 i2c_error: // the cable is disconnceted, or something else went wrong
        i2c_reset_state();
        return err;
    }
    return 0;
 }
 #else // USE_SERIAL
 int serial_transaction(void) {
    int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
    if (serial_update_buffers()) {
        return 1;
    }
    for (int i = 0; i < ROWS_PER_HAND; ++i) {
        matrix[slaveOffset+i] = serial_slave_buffer[i];
    }
    return 0;
 }
 #endif
 uint8_t matrix_scan(void)
 {
    uint8_t ret = _matrix_scan();
 #ifdef USE_I2C
    if( i2c_transaction() ) {
 #else // USE_SERIAL
    if( serial_transaction() ) {
 #endif
        // turn on the indicator led when halves are disconnected
        TXLED1;
        error_count++;
        if (error_count > ERROR_DISCONNECT_COUNT) {
            // reset other half if disconnected
            int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
            for (int i = 0; i < ROWS_PER_HAND; ++i) {
                matrix[slaveOffset+i] = 0;
            }
        }
    } else {
        // turn off the indicator led on no error
        TXLED0;
        error_count = 0;
    }
    matrix_scan_quantum();
    return ret;
 }
 void matrix_slave_scan(void) {
    _matrix_scan();
    int offset = (isLeftHand) ? 0 : ROWS_PER_HAND;
 #ifdef USE_I2C
    for (int i = 0; i < ROWS_PER_HAND; ++i) {
        i2c_slave_buffer[i] = matrix[offset+i];
    }
 #else // USE_SERIAL
    for (int i = 0; i < ROWS_PER_HAND; ++i) {
        serial_slave_buffer[i] = matrix[offset+i];
    }
 #endif
 }
 bool matrix_is_modified(void)
 {
    if (debouncing) return false;
    return true;
 }
 inline
 bool matrix_is_on(uint8_t row, uint8_t col)
 {
    return (matrix[row] & ((matrix_row_t)1<<col));
 }
 inline
 matrix_row_t matrix_get_row(uint8_t row)
 {
    return matrix[row];
 }
 void matrix_print(void)
 {
    print("\nr/c 0123456789ABCDEF\n");
    for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
        phex(row); print(": ");
        pbin_reverse16(matrix_get_row(row));
        print("\n");
    }
 }
 uint8_t matrix_key_count(void)
 {
    uint8_t count = 0;
    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
        count += bitpop16(matrix[i]);
    }
    return count;
 }
 #if (DIODE_DIRECTION == COL2ROW)
 static void init_cols(void)
 {
    for(uint8_t x = 0; x < MATRIX_COLS; x++) {
        uint8_t pin = col_pins[x];
        _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
        _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
    }
 }
 static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
 {
    // Store last value of row prior to reading
    matrix_row_t last_row_value = current_matrix[current_row];
    // Clear data in matrix row
    current_matrix[current_row] = 0;
    // Select row and wait for row selecton to stabilize
    select_row(current_row);
    wait_us(30);
    // For each col...
    for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
        // Select the col pin to read (active low)
        uint8_t pin = col_pins[col_index];
        uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF));
        // Populate the matrix row with the state of the col pin
        current_matrix[current_row] |=  pin_state ? 0 : (ROW_SHIFTER << col_index);
    }
    // Unselect row
    unselect_row(current_row);
    return (last_row_value != current_matrix[current_row]);
 }
 static void select_row(uint8_t row)
 {
    uint8_t pin = row_pins[row];
    _SFR_IO8((pin >> 4) + 1) |=  _BV(pin & 0xF); // OUT
    _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
 }
 static void unselect_row(uint8_t row)
 {
    uint8_t pin = row_pins[row];
    _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
    _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
 }
 static void unselect_rows(void)
 {
    for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
        uint8_t pin = row_pins[x];
        _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
        _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
    }
 }
 #elif (DIODE_DIRECTION == ROW2COL)
 static void init_rows(void)
 {
    for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
        uint8_t pin = row_pins[x];
        _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
        _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
    }
 }
 static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
 {
    bool matrix_changed = false;
    // Select col and wait for col selecton to stabilize
    select_col(current_col);
    wait_us(30);
    // For each row...
    for(uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++)
    {
        // Store last value of row prior to reading
        matrix_row_t last_row_value = current_matrix[row_index];
        // Check row pin state
        if ((_SFR_IO8(row_pins[row_index] >> 4) & _BV(row_pins[row_index] & 0xF)) == 0)
        {
            // Pin LO, set col bit
            current_matrix[row_index] |= (ROW_SHIFTER << current_col);
        }
        else
        {
            // Pin HI, clear col bit
            current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
        }
        // Determine if the matrix changed state
        if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
        {
            matrix_changed = true;
        }
    }
    // Unselect col
    unselect_col(current_col);
    return matrix_changed;
 }
 static void select_col(uint8_t col)
 {
    uint8_t pin = col_pins[col];
    _SFR_IO8((pin >> 4) + 1) |=  _BV(pin & 0xF); // OUT
    _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
 }
 static void unselect_col(uint8_t col)
 {
    uint8_t pin = col_pins[col];
    _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
    _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
 }
 static void unselect_cols(void)
 {
    for(uint8_t x = 0; x < MATRIX_COLS; x++) {
        uint8_t pin = col_pins[x];
        _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
        _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
    }
 }
 #endif
@@ -5,12 +5,12 @@
 __The Answer to the Ultimate Question of Life, the Universe, and at least Keyboards.__  
 A split 7x4 ortholinear keyboard. [Hardware project repo](https://github.com/Biacco42/Ergo42)
-Keyboard Maintainer: [Biacco42](https://github.com/Biacco42) [@Biacco42](https://twitter.com/Biacco42)  
+* Keyboard Maintainer: [Biacco42](https://github.com/Biacco42) [@Biacco42](https://twitter.com/Biacco42)
-Hardware Supported: Ergo42 PCB, Pro Micro ATmega32u4  
+* Hardware Supported: Ergo42 PCB, Pro Micro ATmega32u4
-Hardware Availability: [Ergo42 PCB and case](https://github.com/Biacco42/Ergo42)
+* Hardware Availability: [Ergo42 PCB and case](https://github.com/Biacco42/Ergo42)
 Make example for this keyboard (after setting up your build environment):
-    make ergo42/rev1:default:avrdude
+    make ergo42/rev1:default:flash
-See [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) then the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information.
+See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).
@@ -17,8 +17,7 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-#ifndef REV1_CONFIG_H
+#pragma once
 #define REV1_CONFIG_H
 #include "config_common.h"
@@ -40,8 +39,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define MATRIX_COL_PINS { F5, F6, F7, B1, B3, B2, B6 }
 // #define MATRIX_COL_PINS { B6, B2, B3, B1, F7, F6 } //uncomment this line and comment line above if you need to reverse left-to-right key order
-/* define tapping term */
+/* COL2ROW, ROW2COL*/
-#define TAPPING_TERM 100
+#define DIODE_DIRECTION COL2ROW
 #define SOFT_SERIAL_PIN D0
 /* define if matrix has ghost */
 //#define MATRIX_HAS_GHOST
@@ -59,7 +60,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* ws2812 RGB LED */
 #define RGB_DI_PIN D3
 #define RGBLED_NUM 12    // Number of LEDs
 /*
@@ -79,5 +79,3 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //#define NO_ACTION_ONESHOT
 //#define NO_ACTION_MACRO
 //#define NO_ACTION_FUNCTION
 #endif
@@ -1,22 +1 @@
 #include "ergo42.h"
 #ifdef SSD1306OLED
 void led_set_kb(uint8_t usb_led) {
    // put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
    led_set_user(usb_led);
 }
 #endif
 void matrix_init_kb(void) {
    // // green led on
    // DDRD |= (1<<5);
    // PORTD &= ~(1<<5);
    // // orange led on
    // DDRB |= (1<<0);
    // PORTB &= ~(1<<0);
 	matrix_init_user();
 };
@@ -1,18 +1,9 @@
-#ifndef REV1_H
+#pragma once
 #define REV1_H
 #include "ergo42.h"
 #include "quantum.h"
 #ifdef USE_I2C
 #include <stddef.h>
 #ifdef __AVR__
 	#include <avr/io.h>
 	#include <avr/interrupt.h>
 #endif
 #endif
 #ifndef FLIP_HALF
 // Standard Keymap
 // (TRRS jack on the left half is to the right, TRRS jack on the right half is to the left)
@@ -54,5 +45,3 @@
 #endif
 #define LAYOUT LAYOUT_ortho_4x14
 #endif
@@ -12,32 +12,26 @@ MCU = atmega32u4
 BOOTLOADER = caterina
 # Build Options
-#   change to "no" to disable the options, or define them in the Makefile in
+#   change yes to no to disable
 #   the appropriate keymap folder that will get included automatically
 #
 BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration
 MOUSEKEY_ENABLE = yes       # Mouse keys
 EXTRAKEY_ENABLE = yes       # Audio control and System control
 CONSOLE_ENABLE = no         # Console for debug
 COMMAND_ENABLE = yes        # Commands for debug and configuration
 NKRO_ENABLE = no            # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
 BACKLIGHT_ENABLE = no      # Enable keyboard backlight functionality
 MIDI_ENABLE = no            # MIDI controls
 AUDIO_ENABLE = no           # Audio output on port C6
 UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 RGBLIGHT_ENABLE = no       # Enable WS2812 RGB underlight. 
 SUBPROJECT_rev1 = yes
 USE_I2C = yes
 # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
-SLEEP_LED_ENABLE = no    # Breathing sleep LED during USB suspend
+SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend
 # if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
 NKRO_ENABLE = no            # USB Nkey Rollover
 BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality
 RGBLIGHT_ENABLE = no        # Enable keyboard RGB underglow
 MIDI_ENABLE = no            # MIDI support
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
 HD44780_ENABLE = no         # Enable support for HD44780 based LCDs
-CUSTOM_MATRIX = yes
+SPLIT_KEYBOARD = yes
 SRC += matrix.c \
 	   i2c.c \
 	   split_util.c \
 	   serial.c \
 	   ssd1306.c
 LAYOUTS = ortho_4x14
@@ -1,228 +0,0 @@
 /*
 * WARNING: be careful changing this code, it is very timing dependent
 */
 #ifndef F_CPU
 #define F_CPU 16000000
 #endif
 #include <avr/io.h>
 #include <avr/interrupt.h>
 #include <util/delay.h>
 #include <stdbool.h>
 #include "serial.h"
 #ifndef USE_I2C
 // Serial pulse period in microseconds. Its probably a bad idea to lower this
 // value.
 #define SERIAL_DELAY 24
 uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0};
 uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0};
 #define SLAVE_DATA_CORRUPT (1<<0)
 volatile uint8_t status = 0;
 inline static
 void serial_delay(void) {
  _delay_us(SERIAL_DELAY);
 }
 inline static
 void serial_output(void) {
  SERIAL_PIN_DDR |= SERIAL_PIN_MASK;
 }
 // make the serial pin an input with pull-up resistor
 inline static
 void serial_input(void) {
  SERIAL_PIN_DDR  &= ~SERIAL_PIN_MASK;
  SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
 }
 inline static
 uint8_t serial_read_pin(void) {
  return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK);
 }
 inline static
 void serial_low(void) {
  SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;
 }
 inline static
 void serial_high(void) {
  SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
 }
 void serial_master_init(void) {
  serial_output();
  serial_high();
 }
 void serial_slave_init(void) {
  serial_input();
  // Enable INT0
  EIMSK |= _BV(INT0);
  // Trigger on falling edge of INT0
  EICRA &= ~(_BV(ISC00) | _BV(ISC01));
 }
 // Used by the master to synchronize timing with the slave.
 static
 void sync_recv(void) {
  serial_input();
  // This shouldn't hang if the slave disconnects because the
  // serial line will float to high if the slave does disconnect.
  while (!serial_read_pin());
  serial_delay();
 }
 // Used by the slave to send a synchronization signal to the master.
 static
 void sync_send(void) {
  serial_output();
  serial_low();
  serial_delay();
  serial_high();
 }
 // Reads a byte from the serial line
 static
 uint8_t serial_read_byte(void) {
  uint8_t byte = 0;
  serial_input();
  for ( uint8_t i = 0; i < 8; ++i) {
    byte = (byte << 1) | serial_read_pin();
    serial_delay();
    _delay_us(1);
  }
  return byte;
 }
 // Sends a byte with MSB ordering
 static
 void serial_write_byte(uint8_t data) {
  uint8_t b = 8;
  serial_output();
  while( b-- ) {
    if(data & (1 << b)) {
      serial_high();
    } else {
      serial_low();
    }
    serial_delay();
  }
 }
 // interrupt handle to be used by the slave device
 ISR(SERIAL_PIN_INTERRUPT) {
  sync_send();
  uint8_t checksum = 0;
  for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
    serial_write_byte(serial_slave_buffer[i]);
    sync_send();
    checksum += serial_slave_buffer[i];
  }
  serial_write_byte(checksum);
  sync_send();
  // wait for the sync to finish sending
  serial_delay();
  // read the middle of pulses
  _delay_us(SERIAL_DELAY/2);
  uint8_t checksum_computed = 0;
  for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
    serial_master_buffer[i] = serial_read_byte();
    sync_send();
    checksum_computed += serial_master_buffer[i];
  }
  uint8_t checksum_received = serial_read_byte();
  sync_send();
  serial_input(); // end transaction
  if ( checksum_computed != checksum_received ) {
    status |= SLAVE_DATA_CORRUPT;
  } else {
    status &= ~SLAVE_DATA_CORRUPT;
  }
 }
 inline
 bool serial_slave_DATA_CORRUPT(void) {
  return status & SLAVE_DATA_CORRUPT;
 }
 // Copies the serial_slave_buffer to the master and sends the
 // serial_master_buffer to the slave.
 //
 // Returns:
 // 0 => no error
 // 1 => slave did not respond
 int serial_update_buffers(void) {
  // this code is very time dependent, so we need to disable interrupts
  cli();
  // signal to the slave that we want to start a transaction
  serial_output();
  serial_low();
  _delay_us(1);
  // wait for the slaves response
  serial_input();
  serial_high();
  _delay_us(SERIAL_DELAY);
  // check if the slave is present
  if (serial_read_pin()) {
    // slave failed to pull the line low, assume not present
    sei();
    return 1;
  }
  // if the slave is present syncronize with it
  sync_recv();
  uint8_t checksum_computed = 0;
  // receive data from the slave
  for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
    serial_slave_buffer[i] = serial_read_byte();
    sync_recv();
    checksum_computed += serial_slave_buffer[i];
  }
  uint8_t checksum_received = serial_read_byte();
  sync_recv();
  if (checksum_computed != checksum_received) {
    sei();
    return 1;
  }
  uint8_t checksum = 0;
  // send data to the slave
  for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
    serial_write_byte(serial_master_buffer[i]);
    sync_recv();
    checksum += serial_master_buffer[i];
  }
  serial_write_byte(checksum);
  sync_recv();
  // always, release the line when not in use
  serial_output();
  serial_high();
  sei();
  return 0;
 }
 #endif
@@ -1,26 +0,0 @@
 #ifndef MY_SERIAL_H
 #define MY_SERIAL_H
 #include "config.h"
 #include <stdbool.h>
 /* TODO:  some defines for interrupt setup */
 #define SERIAL_PIN_DDR DDRD
 #define SERIAL_PIN_PORT PORTD
 #define SERIAL_PIN_INPUT PIND
 #define SERIAL_PIN_MASK _BV(PD0)
 #define SERIAL_PIN_INTERRUPT INT0_vect
 #define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2
 #define SERIAL_MASTER_BUFFER_LENGTH 1
 // Buffers for master - slave communication
 extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH];
 extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH];
 void serial_master_init(void);
 void serial_slave_init(void);
 int serial_update_buffers(void);
 bool serial_slave_data_corrupt(void);
 #endif
@@ -1,86 +0,0 @@
 #include <avr/io.h>
 #include <avr/wdt.h>
 #include <avr/power.h>
 #include <avr/interrupt.h>
 #include <util/delay.h>
 #include <avr/eeprom.h>
 #include "split_util.h"
 #include "matrix.h"
 #include "keyboard.h"
 #include "config.h"
 #include "timer.h"
 #ifdef USE_I2C
 #  include "i2c.h"
 #else
 #  include "serial.h"
 #endif
 volatile bool isLeftHand = true;
 static void setup_handedness(void) {
  #ifdef EE_HANDS
    isLeftHand = eeprom_read_byte(EECONFIG_HANDEDNESS);
  #else
    // I2C_MASTER_RIGHT is deprecated, use MASTER_RIGHT instead, since this works for both serial and i2c
    #if defined(I2C_MASTER_RIGHT) || defined(MASTER_RIGHT)
      isLeftHand = !has_usb();
    #else
      isLeftHand = has_usb();
    #endif
  #endif
 }
 static void keyboard_master_setup(void) {
 #ifdef USE_I2C
    i2c_master_init();
 #ifdef SSD1306OLED
    matrix_master_OLED_init ();
 #endif
 #else
    serial_master_init();
 #endif
 }
 static void keyboard_slave_setup(void) {
  timer_init();
 #ifdef USE_I2C
    i2c_slave_init(SLAVE_I2C_ADDRESS);
 #else
    serial_slave_init();
 #endif
 }
 bool has_usb(void) {
   USBCON |= (1 << OTGPADE); //enables VBUS pad
   _delay_us(5);
   return (USBSTA & (1<<VBUS));  //checks state of VBUS
 }
 void split_keyboard_setup(void) {
   setup_handedness();
   if (has_usb()) {
      keyboard_master_setup();
   } else {
      keyboard_slave_setup();
   }
   sei();
 }
 void keyboard_slave_loop(void) {
   matrix_init();
   while (1) {
      matrix_slave_scan();
   }
 }
 // this code runs before the usb and keyboard is initialized
 void matrix_setup(void) {
    split_keyboard_setup();
    if (!has_usb()) {
        keyboard_slave_loop();
    }
 }
@@ -1,20 +0,0 @@
 #ifndef SPLIT_KEYBOARD_UTIL_H
 #define SPLIT_KEYBOARD_UTIL_H
 #include <stdbool.h>
 #include "eeconfig.h"
 #define SLAVE_I2C_ADDRESS           0x32
 extern volatile bool isLeftHand;
 // slave version of matix scan, defined in matrix.c
 void matrix_slave_scan(void);
 void split_keyboard_setup(void);
 bool has_usb(void);
 void keyboard_slave_loop(void);
 void matrix_master_OLED_init (void);
 #endif
@@ -0,0 +1,36 @@
 /*
 This is the c configuration file for the keymap
 Copyright 2012 Jun Wako <[email protected]>
 Copyright 2015 Jack Humbert
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 2 of the License, or
 (at your option) any later version.
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #pragma once
 /* Use I2C or Serial, not both */
 #define USE_SERIAL
 // #define USE_I2C
 /* Select hand configuration */
 #define MASTER_LEFT
 // #define MASTER_RIGHT
 // #define EE_HANDS
 #undef TAPPING_TERM
 #define TAPPING_TERM 300
@@ -0,0 +1,18 @@
 #include QMK_KEYBOARD_H
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    [0] = LAYOUT_3key_2us(
        KC_ESC,         KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,                                    KC_EQL,  KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_BSPC, 
        KC_TAB,         KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_PGUP,                                 KC_LBRC, KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_ENT,  
        LCA_T(KC_CAPS), KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_PGDN,                                 KC_RBRC, KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, 
        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_LCTL,        KC_LGUI, KC_LALT, MO(1),            KC_GRV,  KC_SPC,  LT(1,KC_DEL),          KC_HOME, KC_END,  KC_BSLS,          KC_LEFT, KC_RGHT, KC_DOWN, KC_UP    
    ),
    [1] = LAYOUT_3key_2us(
        KC_TRNS, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,                                    KC_F12,       KC_F7,   KC_F8,   KC_F9,               KC_F10,               KC_F11,              KC_TRNS, 
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,                                  KC_TRNS,      KC_TRNS, KC_TRNS, KC_TRNS,             KC_TRNS,              KC_PSCR,             KC_TRNS, 
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,                                  KC_TRNS,      KC_TRNS, KC_TRNS, KC_TRNS,             KC_TRNS,              KC_TRNS,             KC_TRNS, 
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,                                                         KC_TRNS, KC_TRNS, KC_TRNS,             KC_TRNS,              KC_TRNS,             KC_TRNS,                         
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,          KC_TRNS, KC_TRNS, KC_TRNS,          LSFT(KC_HOME), LSFT(KC_END), KC_TRNS,          LALT(LSFT(KC_LEFT)), LALT(LSFT(KC_RIGHT)), LALT(LSFT(KC_DOWN)), LALT(LSFT(KC_UP))     
    )
 };
@@ -0,0 +1 @@
 [["KC_ESC", "KC_1", "KC_2", "KC_3", "KC_4", "KC_5", "KC_6", "KC_EQL", "KC_7", "KC_8", "KC_9", "KC_0", "KC_MINS", "KC_BSPC", "KC_TAB", "KC_Q", "KC_W", "KC_E", "KC_R", "KC_T", "KC_PGUP", "KC_LBRC", "KC_Y", "KC_U", "KC_I", "KC_O", "KC_P", "KC_ENT", "LCA_T(KC_CAPS)", "KC_A", "KC_S", "KC_D", "KC_F", "KC_G", "KC_PGDN", "KC_RBRC", "KC_H", "KC_J", "KC_K", "KC_L", "KC_SCLN", "KC_QUOT", "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_LCTL", "KC_LGUI", "KC_LALT", "MO(1)", "KC_GRV", "KC_SPC", "LT(1,KC_DEL)", "KC_HOME", "KC_END", "KC_BSLS", "KC_LEFT", "KC_RGHT", "KC_DOWN", "KC_UP"], ["KC_TRNS", "KC_F1", "KC_F2", "KC_F3", "KC_F4", "KC_F5", "KC_F6", "KC_F12", "KC_F7", "KC_F8", "KC_F9", "KC_F10", "KC_F11", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_PSCR", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "LSFT(KC_HOME)", "LSFT(KC_END)", "KC_TRNS", "LALT(LSFT(KC_LEFT))", "LALT(LSFT(KC_RIGHT))", "LALT(LSFT(KC_DOWN))", "LALT(LSFT(KC_UP))"]]
@@ -0,0 +1,13 @@
 # Generated Keymap Layout
 This layout was generated by the QMK API. You can find the JSON data used to
 generate this keymap in the file layers.json.
 To make use of this file you will need follow the following steps:
 * Download or Clone QMK Firmware: <https://github.com/qmk/qmk_firmware/>
 * Extract QMK Firmware to a location on your hard drive
 * Copy this folder into `keyboards/ergodash/rev1/keymaps/`
 * You are now ready to compile or use your keymap with the source
 More information can be found in the QMK docs: <https://docs.qmk.fm>
@@ -0,0 +1,3 @@
 BACKLIGHT_ENABLE = no
 RGBLIGHT_ENABLE = no
 AUDIO_ENABLE = no
@@ -208,10 +208,8 @@ static matrix_row_t read_cols(uint8_t row) {
      return 0;
    } else {
      uint8_t data    = 0;
-      mcp23018_status = i2c_start(I2C_ADDR_WRITE, ERGODOX_EZ_I2C_TIMEOUT);
+      // reading GPIOB (column port) since in mcp23018's sequential mode
-      if (mcp23018_status) goto out;
+      // it is addressed directly after writing to GPIOA in select_row()
      mcp23018_status = i2c_write(GPIOB, ERGODOX_EZ_I2C_TIMEOUT);
      if (mcp23018_status) goto out;
      mcp23018_status = i2c_start(I2C_ADDR_READ, ERGODOX_EZ_I2C_TIMEOUT);
      if (mcp23018_status) goto out;
      mcp23018_status = i2c_read_nack(ERGODOX_EZ_I2C_TIMEOUT);
@@ -92,7 +92,7 @@ void led_set_user(uint8_t usb_led) {
 //function for layer indicator LED
 uint32_t layer_state_set_user(uint32_t state)
 {
-    if (biton32(state) == 2) {
+    if (biton32(state) == 1) {
    writePinHigh(C6);
 	} else {
 		writePinLow(C6);
@@ -16,6 +16,24 @@ Flashing example for this keyboard ([after setting up the bootloadHID flashing e
    make jj4x4:default:flash
-**Reset Key**: Hold down the key located at *K00*, commonly programmed as *8* while plugging in the keyboard.
+**Reset Key**:
 Hold down the key located at *K12*, commonly programmed as *8* while plugging in the keyboard USB cable.
 Key *K12* is in the above picture:
 Row 2 from the top, Column 2 from the left, see the schematic below:
 ```
  ,-----------------------.
  |     |     |     |     |
  |-----`-----`-----`-----|
  |     | K12 |     |     |
  |-----`-----`-----`-----|
  |     |     |     |     |
  |-----`-----`-----`-----|
  |     |     |     |     |
  `-----`-----`-----`-----'
 ```
 See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).
@@ -0,0 +1,63 @@
 # pipicanim's Nyquist layout
 ```
 make keebio/nyquist/rev3:pipicanim
 ```
 ## Layers
 + Lower -> Layer 2
 + Raise -> Layer 1
 + Code  -> Layer 3
 ### Base
 ```
 ┌──────┬──────┬──────┬──────┬──────┬──────┐ ┌──────┬──────┬──────┬──────┬──────┬──────┐
 │TAB   │Q     │W     │E     │R     │T     │ │Y     │U     │I     │O     │P     │BCKPC │
 ├──────┼──────┼──────┼──────┼──────┼──────┤ ├──────┼──────┼──────┼──────┼──────┼──────┤
 │ESC   │A     │S     │D     │F     │G     │ │H     │J     │K     │L     │;     │'     │
 ├──────┼──────┼──────┼──────┼──────┼──────┤ ├──────┼──────┼──────┼──────┼──────┼──────┤
 │SHIFT │Z     │X     │C     │V     │B     │ │N     │M     │,     │.     │/     │ENTER │
 ├──────┼──────┼──────┼──────┼──────┼──────┤ ├──────┼──────┼──────┼──────┼──────┼──────┤
 │CTRL  |SUPER │MO(3) │ALT   │MO(2) │SPACE │ │SPACE │MO(1) │ALT   │MO(3) │SUPER │CTRL  │
 └──────┴──────┴──────┴──────┴──────┴──────┘ └──────┴──────┴──────┴──────┴──────┴──────┘
 ```
 ### Lower, Numbers/Special Characters and Navigation
 ```
 ┌──────┬──────┬──────┬──────┬──────┬──────┐ ┌──────┬──────┬──────┬──────┬──────┬──────┐
 │`     │1     │2     │3     │4     │      │ │      │PGUP  │UP    │PGDOWN│(     │)     │
 ├──────┼──────┼──────┼──────┼──────┼──────┤ ├──────┼──────┼──────┼──────┼──────┼──────┤
 │      │5     │6     │7     │8     │      │ │HOME  │LEFT  │DOWN  │RIGHT │[     │]     │
 ├──────┼──────┼──────┼──────┼──────┼──────┤ ├──────┼──────┼──────┼──────┼──────┼──────┤
 │      │9     │0     │-     │=     │      │ │END   │      │      │      │\     │|     │
 ├──────┼──────┼──────┼──────┼──────┼──────┤ ├──────┼──────┼──────┼──────┼──────┼──────┤
 │      │      │      │      │      │      │ │      │      │      │      │      │      │
 └──────┴──────┴──────┴──────┴──────┴──────┘ └──────┴──────┴──────┴──────┴──────┴──────┘
 ```
 ### Raise, F buttons
 ```
 ┌──────┬──────┬──────┬──────┬──────┬──────┐ ┌──────┬──────┬──────┬──────┬──────┬──────┐
 │CAPS  │      │PRSRC │SCLOCK│PAUSE │      │ │      │F1    │F2    │F3    │F4    │DEL   │
 ├──────┼──────┼──────┼──────┼──────┼──────┤ ├──────┼──────┼──────┼──────┼──────┼──────┤
 │      │      │INSERT│HOME  │PGUP  │      │ │      │F5    │F6    │F7    │F8    │      │
 ├──────┼──────┼──────┼──────┼──────┼──────┤ ├──────┼──────┼──────┼──────┼──────┼──────┤
 │      │      │DEL   │END   │PGDOWN│      │ │      │F9    │F10   │F11   │F12   │      │
 ├──────┼──────┼──────┼──────┼──────┼──────┤ ├──────┼──────┼──────┼──────┼──────┼──────┤
 │      │      │      │      │      │      │ │      │      │      │      │      │      │
 └──────┴──────┴──────┴──────┴──────┴──────┘ └──────┴──────┴──────┴──────┴──────┴──────┘
 ```
 ### Code, RGB and media controls.
 ```
 ┌──────┬──────┬──────┬──────┬──────┬──────┐ ┌──────┬──────┬──────┬──────┬──────┬──────┐
 │RGBTOG│RGBM+ │RGBM- │      │      │      │ |      │      │      │      │      │RESET │
 ├──────┼──────┼──────┼──────┼──────┼──────┤ ├──────┼──────┼──────┼──────┼──────┼──────┤
 │HUE+  │SAT+  │BRGHT+│EFCT+ │      │      │ │      │PREV  │PLAY  │NEXT  │      │      │
 ├──────┼──────┼──────┼──────┼──────┼──────┤ ├──────┼──────┼──────┼──────┼──────┼──────┤
 │HUE-  │SAT-  │BRGHT-│EFCT  │      │      │ |      │MUTE  │VOL-  │VOL+  │      │      │
 ├──────┼──────┼──────┼──────┼──────┼──────┤ ├──────┼──────┼──────┼──────┼──────┼──────┤
 │      │      │      │      │      │      │ │      │      │      │      │      │      │
 └──────┴──────┴──────┴──────┴──────┴──────┘ └──────┴──────┴──────┴──────┴──────┴──────┘
 ```
@@ -1,5 +1,5 @@
 /*
-Copyright 2011 Jun Wako <wakojun@gmail.com>
+Copyright 2017 Danny Nguyen <danny@hexwire.com>
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -15,11 +15,17 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-#ifndef PJRC_H
+#pragma once
 #define PJRC_H
-#include "host_driver.h"
+// #define USE_I2C
-host_driver_t *pjrc_driver(void);
+/* Select hand configuration */
 // #define MASTER_RIGHT
 // #define EE_HANDS
-#endif
+#undef RGBLED_NUM
 #define RGBLIGHT_ANIMATIONS
 #define RGBLED_NUM 12
 #define RGBLIGHT_HUE_STEP 8
 #define RGBLIGHT_SAT_STEP 8
 #define RGBLIGHT_VAL_STEP 8
@@ -0,0 +1,29 @@
 #include QMK_KEYBOARD_H
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 	[0] = LAYOUT_ortho_4x12(
     KC_TAB,KC_Q,KC_W,KC_E,KC_R,KC_T,KC_Y,KC_U,KC_I,KC_O,KC_P,KC_BSPC,
     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_LSFT,KC_Z,KC_X,KC_C,KC_V,KC_B,KC_N,KC_M,KC_COMM,KC_DOT,KC_SLSH,KC_ENT,
     KC_LCTL,KC_LGUI,MO(3),KC_LALT,MO(2),KC_SPC,KC_SPC,MO(1),KC_LALT,MO(3),KC_RGUI,KC_RCTL
   ),
 	[1] = LAYOUT_ortho_4x12(
     KC_GRV,KC_1,KC_2,KC_3,KC_4,KC_TRNS,KC_TRNS,KC_PGUP,KC_UP,KC_PGDN,KC_LPRN,KC_RPRN,
     KC_TRNS,KC_5,KC_6,KC_7,KC_8,KC_TRNS,KC_HOME,KC_LEFT,KC_DOWN,KC_RGHT,KC_LBRC,KC_RBRC,
     KC_TRNS,KC_9,KC_0,KC_MINS,KC_EQL,KC_TRNS,KC_END,KC_TRNS,KC_TRNS,KC_TRNS,KC_BSLS,KC_PIPE,
     KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS
   ),
 	[2] = LAYOUT_ortho_4x12(
     KC_CAPS,KC_TRNS,KC_PSCR,KC_SLCK,KC_PAUS,KC_TRNS,KC_TRNS,KC_F1,KC_F2,KC_F3,KC_F4,KC_DEL,
     KC_TRNS,KC_TRNS,KC_INS,KC_HOME,KC_PGUP,KC_TRNS,KC_TRNS,KC_F5,KC_F6,KC_F7,KC_F8,KC_TRNS,
     KC_TRNS,KC_TRNS,KC_DEL,KC_END,KC_PGDN,KC_TRNS,KC_TRNS,KC_F9,KC_F10,KC_F11,KC_F12,KC_TRNS,
     KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS
   ),
 	[3] = LAYOUT_ortho_4x12(
     RGB_TOG,RGB_MOD,RGB_RMOD,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,RESET,
     RGB_HUI,RGB_SAI,RGB_VAI,RGB_SPI,KC_TRNS,KC_TRNS,KC_TRNS,KC_MPRV,KC_MPLY,KC_MNXT,KC_TRNS,KC_TRNS,
     RGB_HUD,RGB_SAD,RGB_VAD,RGB_SPD,KC_TRNS,KC_TRNS,KC_TRNS,KC_MUTE,KC_VOLD,KC_VOLU,KC_TRNS,KC_TRNS,
     KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS
   )
 };
@@ -0,0 +1 @@
 RGBLIGHT_ENABLE = yes
@@ -0,0 +1,52 @@
 /*
 This is the c configuration file for the keymap
 Copyright 2012 Jun Wako <[email protected]>
 Copyright 2015 Jack Humbert
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 2 of the License, or
 (at your option) any later version.
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #pragma once
 //#define USE_MATRIX_I2C
 /* Select hand configuration */
 #define MASTER_LEFT
 // #define MASTER_RIGHT
 // #define EE_HANDS
 #define SSD1306OLED
 #define USE_SERIAL_PD2
 #define TAPPING_FORCE_HOLD
 #define TAPPING_TERM 100
 #undef RGBLED_NUM
 #define RGBLIGHT_ANIMATIONS
 #define RGBLED_NUM 27
 #define RGBLIGHT_LIMIT_VAL 120
 #define RGBLIGHT_HUE_STEP 10
 #define RGBLIGHT_SAT_STEP 17
 #define RGBLIGHT_VAL_STEP 17
 // Underglow
 /*
 #undef RGBLED_NUM
 #define RGBLED_NUM 14    // Number of LEDs
 #define RGBLIGHT_ANIMATIONS
 #define RGBLIGHT_SLEEP
 */
@@ -0,0 +1,239 @@
 #include QMK_KEYBOARD_H
 #ifdef PROTOCOL_LUFA
  #include "lufa.h"
  #include "split_util.h"
 #endif
 #ifdef SSD1306OLED
  #include "ssd1306.h"
 #endif
 #ifdef RGBLIGHT_ENABLE
 //Following line allows macro to read current RGB settings
 extern rgblight_config_t rgblight_config;
 #endif
 extern uint8_t is_master;
 enum layer_names {
    _QWERTY,
    _LOWER,
    _RAISE,
    _ADJUST
 };
 enum custom_keycodes {
  QWERTY = SAFE_RANGE,
  LOWER,
  RAISE,
  ADJUST,
 };
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* QWERTY
 * ,-----------------------------------------.                    ,-----------------------------------------.
 * | ESC  |   1  |   2  |   3  |   4  |   5  |                    |   6  |   7  |   8  |   9  |   0  |  =   |
 * |------+------+------+------+------+------|                    |------+------+------+------+------+------|
 * | Tab  |   Q  |   W  |   E  |   R  |   T  |                    |   Y  |   U  |   I  |   O  |   P  |  -   |
 * |------+------+------+------+------+------|                    |------+------+------+------+------+------|
 * |LCTRL |   A  |   S  |   D  |   F  |   G  |-------.    ,-------|   H  |   J  |   K  |   L  |   ;  |  '   |
 * |------+------+------+------+------+------|   [   |    |    ]  |------+------+------+------+------+------|
 * |LShift|   Z  |   X  |   C  |   V  |   B  |-------|    |-------|   N  |   M  |   ,  |   .  |   /  |  \   |
 * `-----------------------------------------/       /     \      \-----------------------------------------'
 *                   | LAlt | LGUI |LOWER | /BackSP /       \Enter \  |Space |RAISE | RGUI |
 *                   |      |      |      |/       /         \      \ |      |      |      |
 *                   `----------------------------'           '------''--------------------'
 */
 [_QWERTY] = LAYOUT(
  KC_ESC,   KC_1,   KC_2,    KC_3,    KC_4,    KC_5,                     KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_EQL,
  KC_TAB,   KC_Q,   KC_W,    KC_E,    KC_R,    KC_T,                     KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_MINS,
  KC_LCTRL, KC_A,   KC_S,    KC_D,    KC_F,    KC_G,                     KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT,
  KC_LSFT,  KC_Z,   KC_X,    KC_C,    KC_V,    KC_B, KC_LBRC,  KC_RBRC,  KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_BSLS,
                             KC_LALT, KC_LGUI,LOWER, KC_BSPC,   KC_ENT,  KC_SPC,  RAISE,  KC_RGUI
 ),
 /* LOWER
 * ,-----------------------------------------.                    ,-----------------------------------------.
 * |  ~   |      |      |      |      |      |                    |      |      |      |      |      |      |
 * |------+------+------+------+------+------|                    |------+------+------+------+------+------|
 * |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |                    |  F7  |  F8  |  F9  | F10  | F11  | F12  |
 * |------+------+------+------+------+------|                    |------+------+------+------+------+------|
 * |      |      |      |      |      |      |-------.    ,-------| Left | Down |  Up  |Right | PGUP |      |
 * |------+------+------+------+------+------|   [   |    |    ]  |------+------+------+------+------+------|
 * |      |      |      |      |      |      |-------|    |-------| Home | End  |Alt+← |Alt+→ | PGDN |      |
 * `-----------------------------------------/       /     \      \-----------------------------------------'
 *                   | LAlt | LGUI |LOWER | /BackSP /       \Enter \  |Space |RAISE | RGUI |
 *                   |      |      |      |/       /         \      \ |      |      |      |
 *                   `----------------------------'           '------''--------------------'
 */
 [_LOWER] = LAYOUT(
  KC_TILD, _______, _______, _______, _______, _______,                    _______, _______, _______,_______, _______, _______,
  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_LEFT, KC_DOWN, KC_UP,  KC_RGHT, KC_PGUP, _______,
  _______, _______, _______, _______, _______, _______, _______, _______, KC_HOME, KC_END,  LALT(KC_LEFT), LALT(KC_RGHT), KC_PGDN, _______,
                             _______, _______, _______, _______, _______,  _______, _______, _______
 ),
 /* RAISE
 * ,-----------------------------------------.                    ,-----------------------------------------.
 * |  `   |      |      |      |      |      |                    |      |      |      |      |      |      |
 * |------+------+------+------+------+------|                    |------+------+------+------+------+------|
 * |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |                    |      |      |      |      |      |      |
 * |------+------+------+------+------+------|                    |------+------+------+------+------+------|
 * |  F7  |  F8  |  F9  | F10  | F11  | F12  |-------.    ,-------| Left | Down |  Up  |Right | PGUP |      |
 * |------+------+------+------+------+------|   [   |    |    ]  |------+------+------+------+------+------|
 * |      |      |      |      |      |      |-------|    |-------| Home | End  |Alt+← |Alt+→ | PGDN |      |
 * `-----------------------------------------/       /     \      \-----------------------------------------'
 *                   | LAlt | LGUI |LOWER | /  Del  /       \Enter \  |Space |RAISE | RGUI |
 *                   |      |      |      |/       /         \      \ |      |      |      |
 *                   `----------------------------'           '------''--------------------'
 */
 [_RAISE] = LAYOUT(
  KC_GRV,  _______, _______, _______, _______, _______,                     _______, _______, _______, _______, _______, _______,
  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_LEFT, KC_DOWN, KC_UP,  KC_RGHT,  KC_PGUP, _______,
  _______, _______, _______, _______, _______, _______,  _______, _______,  KC_HOME, KC_END,  LALT(KC_LEFT), LALT(KC_RGHT), KC_PGDN, _______,
                             _______, _______, _______,  KC_DEL,  _______,  _______, _______, _______
 ),
 /* ADJUST
 * ,-----------------------------------------.                    ,-----------------------------------------.
 * |      |      |      |      |      |      |                    |      |      |      |      |      |      |
 * |------+------+------+------+------+------|                    |------+------+------+------+------+------|
 * |      |      |      |      |      |      |                    |      |      |      |      |      |      |
 * |------+------+------+------+------+------|                    |------+------+------+------+------+------|
 * |      |      |      |      |      |      |-------.    ,-------|      |      |RGB ON| HUE+ | SAT+ | VAL+ |
 * |------+------+------+------+------+------|       |    |       |------+------+------+------+------+------|
 * |      |      |      |      |      |      |-------|    |-------|      |      | MODE | HUE- | SAT- | VAL- |
 * `-----------------------------------------/       /     \      \-----------------------------------------'
 *                   | LAlt | LGUI |LOWER | /BackSP /       \Enter \  |Space |RAISE | RGUI |
 *                   |      |      |      |/       /         \      \ |      |      |      |
 *                   `----------------------------'           '------''--------------------'
 */
  [_ADJUST] = LAYOUT(
  XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,                   XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
  XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,                   XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
  XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,                   XXXXXXX, XXXXXXX, RGB_TOG, RGB_HUI, RGB_SAI, RGB_VAI,
  XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_MOD, RGB_HUD, RGB_SAD, RGB_VAD,
                             _______, _______, _______, _______, _______,  _______, _______, _______
  )
 };
 int RGB_current_mode;
 // Setting ADJUST layer RGB back to default
 void update_tri_layer_RGB(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
  if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
    layer_on(layer3);
  } else {
    layer_off(layer3);
  }
 }
 void matrix_init_user(void) {
    #ifdef RGBLIGHT_ENABLE
      RGB_current_mode = rgblight_config.mode;
    #endif
    //SSD1306 OLED init, make sure to add #define SSD1306OLED in config.h
    #ifdef SSD1306OLED
        iota_gfx_init(!has_usb());   // turns on the display
    #endif
 }
 //SSD1306 OLED update loop, make sure to add #define SSD1306OLED in config.h
 #ifdef SSD1306OLED
 // When add source files to SRC in rules.mk, you can use functions.
 const char *read_layer_state(void);
 const char *read_logo(void);
 void set_keylog(uint16_t keycode, keyrecord_t *record);
 const char *read_keylog(void);
 const char *read_keylogs(void);
 // const char *read_mode_icon(bool swap);
 // const char *read_host_led_state(void);
 // void set_timelog(void);
 // const char *read_timelog(void);
 void matrix_scan_user(void) {
   iota_gfx_task();
 }
 void matrix_render_user(struct CharacterMatrix *matrix) {
  if (is_master) {
    // If you want to change the display of OLED, you need to change here
    matrix_write_ln(matrix, read_layer_state());
    matrix_write_ln(matrix, read_keylog());
    matrix_write_ln(matrix, read_keylogs());
    //matrix_write_ln(matrix, read_mode_icon(keymap_config.swap_lalt_lgui));
    //matrix_write_ln(matrix, read_host_led_state());
    //matrix_write_ln(matrix, read_timelog());
  } else {
    matrix_write(matrix, read_logo());
  }
 }
 void matrix_update(struct CharacterMatrix *dest, const struct CharacterMatrix *source) {
  if (memcmp(dest->display, source->display, sizeof(dest->display))) {
    memcpy(dest->display, source->display, sizeof(dest->display));
    dest->dirty = true;
  }
 }
 void iota_gfx_task_user(void) {
  struct CharacterMatrix matrix;
  matrix_clear(&matrix);
  matrix_render_user(&matrix);
  matrix_update(&display, &matrix);
 }
 #endif//SSD1306OLED
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
  if (record->event.pressed) {
 #ifdef SSD1306OLED
    set_keylog(keycode, record);
 #endif
    // set_timelog();
  }
  switch (keycode) {
    case QWERTY:
      if (record->event.pressed) {
        set_single_persistent_default_layer(_QWERTY);
      }
      return false;
      break;
    case LOWER:
      if (record->event.pressed) {
        layer_on(_LOWER);
        update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
      } else {
        layer_off(_LOWER);
        update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
      }
      return false;
      break;
    case RAISE:
      if (record->event.pressed) {
        layer_on(_RAISE);
        update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
      } else {
        layer_off(_RAISE);
        update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
      }
      return false;
      break;
    case ADJUST:
        if (record->event.pressed) {
          layer_on(_ADJUST);
        } else {
          layer_off(_ADJUST);
        }
        return false;
        break;
  }
  return true;
 }
@@ -0,0 +1,11 @@
 RGBLIGHT_ENABLE = yes       # Enable WS2812 RGB underlight.
 # If you want to change the display of OLED, you need to change here
 SRC +=  ./lib/glcdfont.c \
        ./lib/rgb_state_reader.c \
        ./lib/layer_state_reader.c \
        ./lib/logo_reader.c \
        ./lib/keylogger.c \
        # ./lib/mode_icon_reader.c \
        # ./lib/host_led_state_reader.c \
        # ./lib/timelogger.c \
@@ -1,459 +0,0 @@
 /*
 Copyright 2012 Jun Wako <[email protected]>
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 2 of the License, or
 (at your option) any later version.
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 /*
 * scan matrix
 */
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/io.h>
 #include "wait.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 #include "matrix.h"
 #include "split_util.h"
 #include "pro_micro.h"
 #include "config.h"
 #include "timer.h"
 #ifdef USE_I2C
 #  include "i2c.h"
 #else // USE_SERIAL
 #  include "serial.h"
 #endif
 #ifndef DEBOUNCE
 #   define DEBOUNCE 5
 #endif
 #if (DEBOUNCE > 0)
    static uint16_t debouncing_time;
    static bool debouncing = false;
 #endif
 #if (MATRIX_COLS <= 8)
 #    define print_matrix_header()  print("\nr/c 01234567\n")
 #    define print_matrix_row(row)  print_bin_reverse8(matrix_get_row(row))
 #    define matrix_bitpop(i)       bitpop(matrix[i])
 #    define ROW_SHIFTER ((uint8_t)1)
 #else
 #    error "Currently only supports 8 COLS"
 #endif
 static matrix_row_t matrix_debouncing[MATRIX_ROWS];
 #define ERROR_DISCONNECT_COUNT 5
 #define ROWS_PER_HAND (MATRIX_ROWS/2)
 static uint8_t error_count = 0;
 static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
 static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
 /* matrix state(1:on, 0:off) */
 static matrix_row_t matrix[MATRIX_ROWS];
 static matrix_row_t matrix_debouncing[MATRIX_ROWS];
 #if (DIODE_DIRECTION == COL2ROW)
    static void init_cols(void);
    static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row);
    static void unselect_rows(void);
    static void select_row(uint8_t row);
    static void unselect_row(uint8_t row);
 #elif (DIODE_DIRECTION == ROW2COL)
    static void init_rows(void);
    static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col);
    static void unselect_cols(void);
    static void unselect_col(uint8_t col);
    static void select_col(uint8_t col);
 #endif
 __attribute__ ((weak))
 void matrix_init_kb(void) {
    matrix_init_user();
 }
 __attribute__ ((weak))
 void matrix_scan_kb(void) {
    matrix_scan_user();
 }
 __attribute__ ((weak))
 void matrix_init_user(void) {
 }
 __attribute__ ((weak))
 void matrix_scan_user(void) {
 }
 inline
 uint8_t matrix_rows(void)
 {
    return MATRIX_ROWS;
 }
 inline
 uint8_t matrix_cols(void)
 {
    return MATRIX_COLS;
 }
 void matrix_init(void)
 {
    debug_enable = true;
    debug_matrix = true;
    debug_mouse = true;
    // initialize row and col
 #if (DIODE_DIRECTION == COL2ROW)
    unselect_rows();
    init_cols();
 #elif (DIODE_DIRECTION == ROW2COL)
    unselect_cols();
    init_rows();
 #endif
    TX_RX_LED_INIT;
    // initialize matrix state: all keys off
    for (uint8_t i=0; i < MATRIX_ROWS; i++) {
        matrix[i] = 0;
        matrix_debouncing[i] = 0;
    }
    matrix_init_quantum();
 }
 uint8_t _matrix_scan(void)
 {
    int offset = isLeftHand ? 0 : (ROWS_PER_HAND);
 #if (DIODE_DIRECTION == COL2ROW)
    // Set row, read cols
    for (uint8_t current_row = 0; current_row < ROWS_PER_HAND; current_row++) {
 #       if (DEBOUNCE > 0)
            bool matrix_changed = read_cols_on_row(matrix_debouncing+offset, current_row);
            if (matrix_changed) {
                debouncing = true;
                debouncing_time = timer_read();
            }
 #       else
            read_cols_on_row(matrix+offset, current_row);
 #       endif
    }
 #elif (DIODE_DIRECTION == ROW2COL)
    // Set col, read rows
    for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
 #       if (DEBOUNCE > 0)
            bool matrix_changed = read_rows_on_col(matrix_debouncing+offset, current_col);
            if (matrix_changed) {
                debouncing = true;
                debouncing_time = timer_read();
            }
 #       else
             read_rows_on_col(matrix+offset, current_col);
 #       endif
    }
 #endif
 #   if (DEBOUNCE > 0)
        if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCE)) {
            for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
                matrix[i+offset] = matrix_debouncing[i+offset];
            }
            debouncing = false;
        }
 #   endif
    return 1;
 }
 #ifdef USE_I2C
 // Get rows from other half over i2c
 int i2c_transaction(void) {
    int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
    int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
    if (err) goto i2c_error;
    // start of matrix stored at 0x00
    err = i2c_master_write(0x00);
    if (err) goto i2c_error;
    // Start read
    err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ);
    if (err) goto i2c_error;
    if (!err) {
        int i;
        for (i = 0; i < ROWS_PER_HAND-1; ++i) {
            matrix[slaveOffset+i] = i2c_master_read(I2C_ACK);
        }
        matrix[slaveOffset+i] = i2c_master_read(I2C_NACK);
        i2c_master_stop();
    } else {
 i2c_error: // the cable is disconnceted, or something else went wrong
        i2c_reset_state();
        return err;
    }
    return 0;
 }
 #else // USE_SERIAL
 int serial_transaction(void) {
    int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
    if (serial_update_buffers()) {
        return 1;
    }
    for (int i = 0; i < ROWS_PER_HAND; ++i) {
        matrix[slaveOffset+i] = serial_slave_buffer[i];
    }
    return 0;
 }
 #endif
 uint8_t matrix_scan(void)
 {
    uint8_t ret = _matrix_scan();
 #ifdef USE_I2C
    if( i2c_transaction() ) {
 #else // USE_SERIAL
    if( serial_transaction() ) {
 #endif
        // turn on the indicator led when halves are disconnected
        TXLED1;
        error_count++;
        if (error_count > ERROR_DISCONNECT_COUNT) {
            // reset other half if disconnected
            int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
            for (int i = 0; i < ROWS_PER_HAND; ++i) {
                matrix[slaveOffset+i] = 0;
            }
        }
    } else {
        // turn off the indicator led on no error
        TXLED0;
        error_count = 0;
    }
    matrix_scan_quantum();
    return ret;
 }
 void matrix_slave_scan(void) {
    _matrix_scan();
    int offset = (isLeftHand) ? 0 : ROWS_PER_HAND;
 #ifdef USE_I2C
    for (int i = 0; i < ROWS_PER_HAND; ++i) {
        i2c_slave_buffer[i] = matrix[offset+i];
    }
 #else // USE_SERIAL
    for (int i = 0; i < ROWS_PER_HAND; ++i) {
        serial_slave_buffer[i] = matrix[offset+i];
    }
 #endif
 }
 bool matrix_is_modified(void)
 {
    if (debouncing) return false;
    return true;
 }
 inline
 bool matrix_is_on(uint8_t row, uint8_t col)
 {
    return (matrix[row] & ((matrix_row_t)1<<col));
 }
 inline
 matrix_row_t matrix_get_row(uint8_t row)
 {
    return matrix[row];
 }
 void matrix_print(void)
 {
    print("\nr/c 0123456789ABCDEF\n");
    for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
        phex(row); print(": ");
        pbin_reverse16(matrix_get_row(row));
        print("\n");
    }
 }
 uint8_t matrix_key_count(void)
 {
    uint8_t count = 0;
    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
        count += bitpop16(matrix[i]);
    }
    return count;
 }
 #if (DIODE_DIRECTION == COL2ROW)
 static void init_cols(void)
 {
    for(uint8_t x = 0; x < MATRIX_COLS; x++) {
        uint8_t pin = col_pins[x];
        _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
        _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
    }
 }
 static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
 {
    // Store last value of row prior to reading
    matrix_row_t last_row_value = current_matrix[current_row];
    // Clear data in matrix row
    current_matrix[current_row] = 0;
    // Select row and wait for row selecton to stabilize
    select_row(current_row);
    wait_us(30);
    // For each col...
    for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
        // Select the col pin to read (active low)
        uint8_t pin = col_pins[col_index];
        uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF));
        // Populate the matrix row with the state of the col pin
        current_matrix[current_row] |=  pin_state ? 0 : (ROW_SHIFTER << col_index);
    }
    // Unselect row
    unselect_row(current_row);
    return (last_row_value != current_matrix[current_row]);
 }
 static void select_row(uint8_t row)
 {
    uint8_t pin = row_pins[row];
    _SFR_IO8((pin >> 4) + 1) |=  _BV(pin & 0xF); // OUT
    _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
 }
 static void unselect_row(uint8_t row)
 {
    uint8_t pin = row_pins[row];
    _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
    _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
 }
 static void unselect_rows(void)
 {
    for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
        uint8_t pin = row_pins[x];
        _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
        _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
    }
 }
 #elif (DIODE_DIRECTION == ROW2COL)
 static void init_rows(void)
 {
    for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
        uint8_t pin = row_pins[x];
        _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
        _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
    }
 }
 static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
 {
    bool matrix_changed = false;
    // Select col and wait for col selecton to stabilize
    select_col(current_col);
    wait_us(30);
    // For each row...
    for(uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++)
    {
        // Store last value of row prior to reading
        matrix_row_t last_row_value = current_matrix[row_index];
        // Check row pin state
        if ((_SFR_IO8(row_pins[row_index] >> 4) & _BV(row_pins[row_index] & 0xF)) == 0)
        {
            // Pin LO, set col bit
            current_matrix[row_index] |= (ROW_SHIFTER << current_col);
        }
        else
        {
            // Pin HI, clear col bit
            current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
        }
        // Determine if the matrix changed state
        if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
        {
            matrix_changed = true;
        }
    }
    // Unselect col
    unselect_col(current_col);
    return matrix_changed;
 }
 static void select_col(uint8_t col)
 {
    uint8_t pin = col_pins[col];
    _SFR_IO8((pin >> 4) + 1) |=  _BV(pin & 0xF); // OUT
    _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
 }
 static void unselect_col(uint8_t col)
 {
    uint8_t pin = col_pins[col];
    _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
    _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
 }
 static void unselect_cols(void)
 {
    for(uint8_t x = 0; x < MATRIX_COLS; x++) {
        uint8_t pin = col_pins[x];
        _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
        _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
    }
 }
 #endif
@@ -95,9 +95,8 @@ uint8_t matrix_cols(void)
 void matrix_init(void)
 {
-    debug_enable = true;
+    split_keyboard_setup();
-    debug_matrix = true;
+
    debug_mouse = true;
    // initialize row and col
    unselect_rows();
    init_cols();
@@ -7,6 +7,7 @@
 #include "split_util.h"
 #include "matrix.h"
 #include "keyboard.h"
 #include "wait.h"
 #ifdef USE_MATRIX_I2C
 #  include "i2c.h"
@@ -14,19 +15,59 @@
 #  include "split_scomm.h"
 #endif
 #ifndef SPLIT_USB_TIMEOUT
 #    define SPLIT_USB_TIMEOUT 2500
 #endif
 volatile bool isLeftHand = true;
-static void setup_handedness(void) {
+bool waitForUsb(void) {
-  #ifdef EE_HANDS
+    for (uint8_t i = 0; i < (SPLIT_USB_TIMEOUT / 100); i++) {
-    isLeftHand = eeprom_read_byte(EECONFIG_HANDEDNESS);
+        // This will return true of a USB connection has been established
-  #else
+        if (UDADDR & _BV(ADDEN)) {
-    // I2C_MASTER_RIGHT is deprecated, use MASTER_RIGHT instead, since this works for both serial and i2c
+            return true;
-    #if defined(I2C_MASTER_RIGHT) || defined(MASTER_RIGHT)
+        }
-      isLeftHand = !has_usb();
+        wait_ms(100);
-    #else
+    }
-      isLeftHand = has_usb();
+
-    #endif
+    // Avoid NO_USB_STARTUP_CHECK - Disable USB as the previous checks seem to enable it somehow
-  #endif
+    (USBCON &= ~(_BV(USBE) | _BV(OTGPADE)));
    return false;
 }
 __attribute__((weak)) bool is_keyboard_left(void) {
 #if defined(SPLIT_HAND_PIN)
    // Test pin SPLIT_HAND_PIN for High/Low, if low it's right hand
    setPinInput(SPLIT_HAND_PIN);
    return readPin(SPLIT_HAND_PIN);
 #elif defined(EE_HANDS)
    return eeconfig_read_handedness();
 #elif defined(MASTER_RIGHT)
    return !has_usb();
 #endif
    return has_usb();
 }
 __attribute__((weak)) bool has_usb(void) {
    static enum { UNKNOWN, MASTER, SLAVE } usbstate = UNKNOWN;
    // only check once, as this is called often
    if (usbstate == UNKNOWN) {
 #if defined(SPLIT_USB_DETECT)
        usbstate = waitForUsb() ? MASTER : SLAVE;
 #elif defined(__AVR__)
        USBCON |= (1 << OTGPADE);  // enables VBUS pad
        wait_us(5);
        usbstate = (USBSTA & (1 << VBUS)) ? MASTER : SLAVE;  // checks state of VBUS
 #else
        usbstate = MASTER;
 #endif
    }
    return (usbstate == MASTER);
 }
 static void keyboard_master_setup(void) {
@@ -47,14 +88,8 @@ static void keyboard_slave_setup(void) {
 #endif
 }
 bool has_usb(void) {
   USBCON |= (1 << OTGPADE); //enables VBUS pad
   _delay_us(5);
   return (USBSTA & (1<<VBUS));  //checks state of VBUS
 }
 void split_keyboard_setup(void) {
-   setup_handedness();
+   isLeftHand = is_keyboard_left();
   if (has_usb()) {
      keyboard_master_setup();
@@ -63,8 +98,3 @@ void split_keyboard_setup(void) {
   }
   sei();
 }
 // this code runs before the usb and keyboard is initialized
 void matrix_setup(void) {
    split_keyboard_setup();
 }
@@ -1,83 +0,0 @@
 #include <avr/io.h>
 #include <avr/wdt.h>
 #include <avr/power.h>
 #include <avr/interrupt.h>
 #include <util/delay.h>
 #include <avr/eeprom.h>
 #include "split_util.h"
 #include "matrix.h"
 #include "keyboard.h"
 #include "config.h"
 #include "timer.h"
 #ifdef USE_I2C
 #  include "i2c.h"
 #else
 #  include "serial.h"
 #endif
 volatile bool isLeftHand = true;
 static void setup_handedness(void) {
  #ifdef EE_HANDS
    isLeftHand = eeprom_read_byte(EECONFIG_HANDEDNESS);
  #else
    // I2C_MASTER_RIGHT is deprecated, use MASTER_RIGHT instead, since this works for both serial and i2c
    #if defined(I2C_MASTER_RIGHT) || defined(MASTER_RIGHT)
      isLeftHand = !has_usb();
    #else
      isLeftHand = has_usb();
    #endif
  #endif
 }
 static void keyboard_master_setup(void) {
 #ifdef USE_I2C
    i2c_master_init();
 #else
    serial_master_init();
 #endif
 }
 static void keyboard_slave_setup(void) {
  timer_init();
 #ifdef USE_I2C
    i2c_slave_init(SLAVE_I2C_ADDRESS);
 #else
    serial_slave_init();
 #endif
 }
 bool has_usb(void) {
   USBCON |= (1 << OTGPADE); //enables VBUS pad
   _delay_us(5);
   return (USBSTA & (1<<VBUS));  //checks state of VBUS
 }
 void split_keyboard_setup(void) {
   setup_handedness();
   if (has_usb()) {
      keyboard_master_setup();
   } else {
      keyboard_slave_setup();
   }
   sei();
 }
 void keyboard_slave_loop(void) {
   matrix_init();
   while (1) {
      matrix_slave_scan();
   }
 }
 // this code runs before the usb and keyboard is initialized
 void matrix_setup(void) {
    split_keyboard_setup();
    if (!has_usb()) {
        keyboard_slave_loop();
    }
 }
@@ -1,20 +0,0 @@
 #ifndef SPLIT_KEYBOARD_UTIL_H
 #define SPLIT_KEYBOARD_UTIL_H
 #include <stdbool.h>
 #include "eeconfig.h"
 #define SLAVE_I2C_ADDRESS           0x32
 extern volatile bool isLeftHand;
 // slave version of matix scan, defined in matrix.c
 void matrix_slave_scan(void);
 void split_keyboard_setup(void);
 bool has_usb(void);
 void keyboard_slave_loop(void);
 void matrix_master_OLED_init (void);
 #endif
@@ -0,0 +1,3 @@
 #pragma once
 #define RSPC_KEYS KC_RSFT, KC_RALT, KC_7
@@ -33,7 +33,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  KC_ESC,  DE_1,    DE_2,    DE_3,    DE_4,    DE_5,    DE_6,    DE_7,    DE_8,    DE_9,    DE_0,    DE_QST,
  KC_GRV,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_BSPC,
  KC_TAB,  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    DE_PLUS, KC_ENT,
-  KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_UP,   KC_RSFT,
+  KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_UP,   KC_RSPC,
  KC_LCTL, KC_LGUI, KC_LALT, KC_LALT, KC_SC,       KC_SPC,       KC_ALGR, KC_FN,   KC_LEFT, KC_DOWN, KC_RGHT
 ),
@@ -18,7 +18,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #pragma once
 #include "config_common.h"
 #include <serial_config.h>
 /* USB Device descriptor parameter */
 #define VENDOR_ID       0xFEED
@@ -28,11 +27,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define PRODUCT         Mint60
 #define DESCRIPTION     A row staggered split keyboard
 #define TAPPING_FORCE_HOLD
 #define TAPPING_TERM 100
 #define USE_SERIAL
 /* key matrix size */
 #define MATRIX_ROWS 10
 #define MATRIX_COLS 8
@@ -54,6 +48,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* COL2ROW, ROW2COL*/
 #define DIODE_DIRECTION COL2ROW
 /*
 * Split Keyboard specific options, make sure you have 'SPLIT_KEYBOARD = yes' in your rules.mk, and define SOFT_SERIAL_PIN.
 */
 #define SOFT_SERIAL_PIN D2
 // #define BACKLIGHT_PIN B7
 // #define BACKLIGHT_BREATHING
 // #define BACKLIGHT_LEVELS 3
@@ -1,162 +0,0 @@
 #include <util/twi.h>
 #include <avr/io.h>
 #include <stdlib.h>
 #include <avr/interrupt.h>
 #include <util/twi.h>
 #include <stdbool.h>
 #include "i2c.h"
 #ifdef USE_I2C
 // Limits the amount of we wait for any one i2c transaction.
 // Since were running SCL line 100kHz (=> 10μs/bit), and each transactions is
 // 9 bits, a single transaction will take around 90μs to complete.
 //
 // (F_CPU/SCL_CLOCK)  =>  # of μC cycles to transfer a bit
 // poll loop takes at least 8 clock cycles to execute
 #define I2C_LOOP_TIMEOUT (9+1)*(F_CPU/SCL_CLOCK)/8
 #define BUFFER_POS_INC() (slave_buffer_pos = (slave_buffer_pos+1)%SLAVE_BUFFER_SIZE)
 volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];
 static volatile uint8_t slave_buffer_pos;
 static volatile bool slave_has_register_set = false;
 // Wait for an i2c operation to finish
 inline static
 void i2c_delay(void) {
  uint16_t lim = 0;
  while(!(TWCR & (1<<TWINT)) && lim < I2C_LOOP_TIMEOUT)
    lim++;
  // easier way, but will wait slightly longer
  // _delay_us(100);
 }
 // Setup twi to run at 100kHz or 400kHz (see ./i2c.h SCL_CLOCK)
 void i2c_master_init(void) {
  // no prescaler
  TWSR = 0;
  // Set TWI clock frequency to SCL_CLOCK. Need TWBR>10.
  // Check datasheets for more info.
  TWBR = ((F_CPU/SCL_CLOCK)-16)/2;
 }
 // Start a transaction with the given i2c slave address. The direction of the
 // transfer is set with I2C_READ and I2C_WRITE.
 // returns: 0 => success
 //          1 => error
 uint8_t i2c_master_start(uint8_t address) {
  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA);
  i2c_delay();
  // check that we started successfully
  if ( (TW_STATUS != TW_START) && (TW_STATUS != TW_REP_START))
    return 1;
  TWDR = address;
  TWCR = (1<<TWINT) | (1<<TWEN);
  i2c_delay();
  if ( (TW_STATUS != TW_MT_SLA_ACK) && (TW_STATUS != TW_MR_SLA_ACK) )
    return 1; // slave did not acknowledge
  else
    return 0; // success
 }
 // Finish the i2c transaction.
 void i2c_master_stop(void) {
  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
  uint16_t lim = 0;
  while(!(TWCR & (1<<TWSTO)) && lim < I2C_LOOP_TIMEOUT)
    lim++;
 }
 // Write one byte to the i2c slave.
 // returns 0 => slave ACK
 //         1 => slave NACK
 uint8_t i2c_master_write(uint8_t data) {
  TWDR = data;
  TWCR = (1<<TWINT) | (1<<TWEN);
  i2c_delay();
  // check if the slave acknowledged us
  return (TW_STATUS == TW_MT_DATA_ACK) ? 0 : 1;
 }
 // Read one byte from the i2c slave. If ack=1 the slave is acknowledged,
 // if ack=0 the acknowledge bit is not set.
 // returns: byte read from i2c device
 uint8_t i2c_master_read(int ack) {
  TWCR = (1<<TWINT) | (1<<TWEN) | (ack<<TWEA);
  i2c_delay();
  return TWDR;
 }
 void i2c_reset_state(void) {
  TWCR = 0;
 }
 void i2c_slave_init(uint8_t address) {
  TWAR = address << 0; // slave i2c address
  // TWEN  - twi enable
  // TWEA  - enable address acknowledgement
  // TWINT - twi interrupt flag
  // TWIE  - enable the twi interrupt
  TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN);
 }
 ISR(TWI_vect);
 ISR(TWI_vect) {
  uint8_t ack = 1;
  switch(TW_STATUS) {
    case TW_SR_SLA_ACK:
      // this device has been addressed as a slave receiver
      slave_has_register_set = false;
      break;
    case TW_SR_DATA_ACK:
      // this device has received data as a slave receiver
      // The first byte that we receive in this transaction sets the location
      // of the read/write location of the slaves memory that it exposes over
      // i2c.  After that, bytes will be written at slave_buffer_pos, incrementing
      // slave_buffer_pos after each write.
      if(!slave_has_register_set) {
        slave_buffer_pos = TWDR;
        // don't acknowledge the master if this memory loctaion is out of bounds
        if ( slave_buffer_pos >= SLAVE_BUFFER_SIZE ) {
          ack = 0;
          slave_buffer_pos = 0;
        }
        slave_has_register_set = true;
      } else {
        i2c_slave_buffer[slave_buffer_pos] = TWDR;
        BUFFER_POS_INC();
      }
      break;
    case TW_ST_SLA_ACK:
    case TW_ST_DATA_ACK:
      // master has addressed this device as a slave transmitter and is
      // requesting data.
      TWDR = i2c_slave_buffer[slave_buffer_pos];
      BUFFER_POS_INC();
      break;
    case TW_BUS_ERROR: // something went wrong, reset twi state
      TWCR = 0;
    default:
      break;
  }
  // Reset everything, so we are ready for the next TWI interrupt
  TWCR |= (1<<TWIE) | (1<<TWINT) | (ack<<TWEA) | (1<<TWEN);
 }
 #endif
@@ -1,49 +0,0 @@
 #ifndef I2C_H
 #define I2C_H
 #include <stdint.h>
 #ifndef F_CPU
 #define F_CPU 16000000UL
 #endif
 #define I2C_READ 1
 #define I2C_WRITE 0
 #define I2C_ACK 1
 #define I2C_NACK 0
 #define SLAVE_BUFFER_SIZE 0x10
 // i2c SCL clock frequency 400kHz
 #define SCL_CLOCK  400000L
 extern volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];
 void i2c_master_init(void);
 uint8_t i2c_master_start(uint8_t address);
 void i2c_master_stop(void);
 uint8_t i2c_master_write(uint8_t data);
 uint8_t i2c_master_read(int);
 void i2c_reset_state(void);
 void i2c_slave_init(uint8_t address);
 static inline unsigned char i2c_start_read(unsigned char addr) {
  return i2c_master_start((addr << 1) | I2C_READ);
 }
 static inline unsigned char i2c_start_write(unsigned char addr) {
  return i2c_master_start((addr << 1) | I2C_WRITE);
 }
 // from SSD1306 scrips
 extern unsigned char i2c_rep_start(unsigned char addr);
 extern void i2c_start_wait(unsigned char addr);
 extern unsigned char i2c_readAck(void);
 extern unsigned char i2c_readNak(void);
 extern unsigned char i2c_read(unsigned char ack);
 #define i2c_read(ack)  (ack) ? i2c_readAck() : i2c_readNak();
 #endif
@@ -14,22 +14,11 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include QMK_KEYBOARD_H
 #ifdef PROTOCOL_LUFA
 #include "lufa.h"
 #include "split_util.h"
 #endif
 #ifdef RGBLIGHT_ENABLE
 //Following line allows macro to read current RGB settings
 extern rgblight_config_t rgblight_config;
 #endif
 enum custom_keycodes {
  RGBRST = SAFE_RANGE
 };
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  [0] = LAYOUT( \
    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,  \
@@ -47,10 +36,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  )
 };
 // define variables for reactive RGB
 bool TOG_STATUS = false;
 int RGB_current_mode;
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
  switch (keycode) {
    case RGBRST:
@@ -58,22 +43,9 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
        if (record->event.pressed) {
          eeconfig_update_rgblight_default();
          rgblight_enable();
          RGB_current_mode = rgblight_config.mode;
        }
      #endif
      break;
  }
  return true;
 }
 void matrix_init_user(void) {
 }
 void matrix_scan_user(void) {
 }
 void led_set_user(uint8_t usb_led) {
 }
@@ -1,343 +0,0 @@
 /*
 Copyright 2012 Jun Wako <[email protected]>
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 2 of the License, or
 (at your option) any later version.
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 /*
 * scan matrix
 */
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/io.h>
 #include <avr/wdt.h>
 #include <avr/interrupt.h>
 #include <util/delay.h>
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 #include "matrix.h"
 #include "split_util.h"
 #include "pro_micro.h"
 #ifdef USE_I2C
 #  include "i2c.h"
 #else // USE_SERIAL
 #  include "serial.h"
 #endif
 #ifndef DEBOUNCE
 #  define DEBOUNCE	5
 #endif
 #define ERROR_DISCONNECT_COUNT 5
 static uint8_t debouncing = DEBOUNCE;
 static const int ROWS_PER_HAND = MATRIX_ROWS/2;
 static uint8_t error_count = 0;
 uint8_t is_master = 0 ;
 static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
 static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
 /* matrix state(1:on, 0:off) */
 static matrix_row_t matrix[MATRIX_ROWS];
 static matrix_row_t matrix_debouncing[MATRIX_ROWS];
 static matrix_row_t read_cols(void);
 static void init_cols(void);
 static void unselect_rows(void);
 static void select_row(uint8_t row);
 static uint8_t matrix_master_scan(void);
 __attribute__ ((weak))
 void matrix_init_kb(void) {
    matrix_init_user();
 }
 __attribute__ ((weak))
 void matrix_scan_kb(void) {
    matrix_scan_user();
 }
 __attribute__ ((weak))
 void matrix_init_user(void) {
 }
 __attribute__ ((weak))
 void matrix_scan_user(void) {
 }
 inline
 uint8_t matrix_rows(void)
 {
    return MATRIX_ROWS;
 }
 inline
 uint8_t matrix_cols(void)
 {
    return MATRIX_COLS;
 }
 void matrix_init(void)
 {
    debug_enable = true;
    debug_matrix = true;
    debug_mouse = true;
    // initialize row and col
    unselect_rows();
    init_cols();
    TX_RX_LED_INIT;
    // initialize matrix state: all keys off
    for (uint8_t i=0; i < MATRIX_ROWS; i++) {
        matrix[i] = 0;
        matrix_debouncing[i] = 0;
    }
    is_master = has_usb();
    matrix_init_quantum();
 }
 uint8_t _matrix_scan(void)
 {
    // Right hand is stored after the left in the matirx so, we need to offset it
    int offset = isLeftHand ? 0 : (ROWS_PER_HAND);
    for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
        select_row(i);
        _delay_us(30);  // without this wait read unstable value.
        matrix_row_t cols = read_cols();
        if (matrix_debouncing[i+offset] != cols) {
            matrix_debouncing[i+offset] = cols;
            debouncing = DEBOUNCE;
        }
        unselect_rows();
    }
    if (debouncing) {
        if (--debouncing) {
            _delay_ms(1);
        } else {
            for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
                matrix[i+offset] = matrix_debouncing[i+offset];
            }
        }
    }
    return 1;
 }
 #ifdef USE_I2C
 // Get rows from other half over i2c
 int i2c_transaction(void) {
    int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
    int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
    if (err) goto i2c_error;
    // start of matrix stored at 0x00
    err = i2c_master_write(0x00);
    if (err) goto i2c_error;
    // Start read
    err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ);
    if (err) goto i2c_error;
    if (!err) {
        int i;
        for (i = 0; i < ROWS_PER_HAND-1; ++i) {
            matrix[slaveOffset+i] = i2c_master_read(I2C_ACK);
        }
        matrix[slaveOffset+i] = i2c_master_read(I2C_NACK);
        i2c_master_stop();
    } else {
 i2c_error: // the cable is disconnceted, or something else went wrong
        i2c_reset_state();
        return err;
    }
    return 0;
 }
 #else // USE_SERIAL
 int serial_transaction(void) {
    int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
    int ret=serial_update_buffers();
    if (ret ) {
        if(ret==2)RXLED1;
        return 1;
    }
 RXLED0;
    for (int i = 0; i < ROWS_PER_HAND; ++i) {
        matrix[slaveOffset+i] = serial_slave_buffer[i];
    }
    return 0;
 }
 #endif
 uint8_t matrix_scan(void)
 {
    if (is_master) {
        matrix_master_scan();
    }else{
        matrix_slave_scan();
          int offset = (isLeftHand) ? ROWS_PER_HAND : 0;
          for (int i = 0; i < ROWS_PER_HAND; ++i) {
              matrix[offset+i] = serial_master_buffer[i];
          }
        matrix_scan_quantum();
    }
    return 1;
 }
 uint8_t matrix_master_scan(void) {
    int ret = _matrix_scan();
 #ifndef KEYBOARD_helix_rev1
    int offset = (isLeftHand) ? 0 : ROWS_PER_HAND;
 #ifdef USE_I2C
 //    for (int i = 0; i < ROWS_PER_HAND; ++i) {
        /* i2c_slave_buffer[i] = matrix[offset+i]; */
 //        i2c_slave_buffer[i] = matrix[offset+i];
 //    }
 #else // USE_SERIAL
    for (int i = 0; i < ROWS_PER_HAND; ++i) {
        serial_master_buffer[i] = matrix[offset+i];
    }
 #endif
 #endif
 #ifdef USE_I2C
    if( i2c_transaction() ) {
 #else // USE_SERIAL
    if( serial_transaction() ) {
 #endif
        // turn on the indicator led when halves are disconnected
        TXLED1;
        error_count++;
        if (error_count > ERROR_DISCONNECT_COUNT) {
            // reset other half if disconnected
            int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
            for (int i = 0; i < ROWS_PER_HAND; ++i) {
                matrix[slaveOffset+i] = 0;
            }
        }
    } else {
        // turn off the indicator led on no error
        TXLED0;
        error_count = 0;
    }
    matrix_scan_quantum();
    return ret;
 }
 void matrix_slave_scan(void) {
    _matrix_scan();
    int offset = (isLeftHand) ? 0 : ROWS_PER_HAND;
 #ifdef USE_I2C
    for (int i = 0; i < ROWS_PER_HAND; ++i) {
        /* i2c_slave_buffer[i] = matrix[offset+i]; */
        i2c_slave_buffer[i] = matrix[offset+i];
    }
 #else // USE_SERIAL
    for (int i = 0; i < ROWS_PER_HAND; ++i) {
        serial_slave_buffer[i] = matrix[offset+i];
    }
 #endif
 }
 bool matrix_is_modified(void)
 {
    if (debouncing) return false;
    return true;
 }
 inline
 bool matrix_is_on(uint8_t row, uint8_t col)
 {
    return (matrix[row] & ((matrix_row_t)1<<col));
 }
 inline
 matrix_row_t matrix_get_row(uint8_t row)
 {
    return matrix[row];
 }
 void matrix_print(void)
 {
    print("\nr/c 0123456789ABCDEF\n");
    for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
        phex(row); print(": ");
        pbin_reverse16(matrix_get_row(row));
        print("\n");
    }
 }
 uint8_t matrix_key_count(void)
 {
    uint8_t count = 0;
    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
        count += bitpop16(matrix[i]);
    }
    return count;
 }
 static void  init_cols(void)
 {
    for(int x = 0; x < MATRIX_COLS; x++) {
        _SFR_IO8((col_pins[x] >> 4) + 1) &=  ~_BV(col_pins[x] & 0xF);
        _SFR_IO8((col_pins[x] >> 4) + 2) |= _BV(col_pins[x] & 0xF);
    }
 }
 static matrix_row_t read_cols(void)
 {
    matrix_row_t result = 0;
    for(int x = 0; x < MATRIX_COLS; x++) {
        result |= (_SFR_IO8(col_pins[x] >> 4) & _BV(col_pins[x] & 0xF)) ? 0 : (1 << x);
    }
    return result;
 }
 static void unselect_rows(void)
 {
    for(int x = 0; x < ROWS_PER_HAND; x++) {
        _SFR_IO8((row_pins[x] >> 4) + 1) &=  ~_BV(row_pins[x] & 0xF);
        _SFR_IO8((row_pins[x] >> 4) + 2) |= _BV(row_pins[x] & 0xF);
    }
 }
 static void select_row(uint8_t row)
 {
    _SFR_IO8((row_pins[row] >> 4) + 1) |=  _BV(row_pins[row] & 0xF);
    _SFR_IO8((row_pins[row] >> 4) + 2) &= ~_BV(row_pins[row] & 0xF);
 }
@@ -14,30 +14,3 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "mint60.h"
 void matrix_init_kb(void) {
 	// put your keyboard start-up code here
 	// runs once when the firmware starts up
 	matrix_init_user();
 }
 void matrix_scan_kb(void) {
 	// put your looping keyboard code here
 	// runs every cycle (a lot)
 	matrix_scan_user();
 }
 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
 	// put your per-action keyboard code here
 	// runs for every action, just before processing by the firmware
 	return process_record_user(keycode, record);
 }
 void led_set_kb(uint8_t usb_led) {
 	// put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
 	led_set_user(usb_led);
 }
@@ -13,25 +13,10 @@
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-#ifndef MINT60_H
+#pragma once
 #define MINT60_H
 #include "quantum.h"
 #ifdef RGBLIGHT_ENABLE
 //rgb led driver
 #include "ws2812.h"
 #endif
 #ifdef USE_I2C
 #include <stddef.h>
 #ifdef __AVR__
  #include <avr/io.h>
  #include <avr/interrupt.h>
 #endif
 #endif
 // This a shortcut to help you visually see your layout.
 // The following is an example using the Planck MIT layout
 // The first section contains all of the arguments
@@ -55,5 +40,3 @@
  { R30, R31, R32, R33, R34, R35, R36, R37 }, \
  { R40, R41, KC_NO, R43, KC_NO, R45, R46, R47 }, \
 }
 #endif
@@ -14,16 +14,17 @@ BOOTLOADER = caterina
 # Build Options
 #   change yes to no to disable
 #
-BOOTMAGIC_ENABLE = no      # Virtual DIP switch configuration
+BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration
-MOUSEKEY_ENABLE = no       # Mouse keys
+MOUSEKEY_ENABLE = no        # Mouse keys
-EXTRAKEY_ENABLE = no       # Audio control and System control
+EXTRAKEY_ENABLE = no        # Audio control and System control
-CONSOLE_ENABLE = no        # Console for debug
+CONSOLE_ENABLE = no         # Console for debug
-COMMAND_ENABLE = no        # Commands for debug and configuration
+COMMAND_ENABLE = no         # Commands for debug and configuration
 # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
 SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend
 # if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
 NKRO_ENABLE = no            # USB Nkey Rollover
 BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality on B7 by default
 RGBLIGHT_ENABLE = yes       # Enable WS2812 RGB underlight. 
 MIDI_ENABLE = no            # MIDI support
 UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
@@ -31,10 +32,4 @@ AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
 HD44780_ENABLE = no 		# Enable support for HD44780 based LCDs
-CUSTOM_MATRIX = yes
+SPLIT_KEYBOARD = yes
 SRC += i2c.c \
       serial.c \
       matrix.c \
       split_util.c
 USE_I2C = yes
 RGBLIGHT_ENABLE = yes       # Enable WS2812 RGB underlight. 
@@ -1,295 +0,0 @@
 /*
 * WARNING: be careful changing this code, it is very timing dependent
 */
 #ifndef F_CPU
 #define F_CPU 16000000
 #endif
 #include <avr/io.h>
 #include <avr/interrupt.h>
 #include <util/delay.h>
 #include <stdbool.h>
 #include "serial.h"
 #ifdef USE_SERIAL
 #define _delay_sub_us(x)    __builtin_avr_delay_cycles(x)
 // Serial pulse period in microseconds.
 #define SELECT_SERIAL_SPEED 1
 #if SELECT_SERIAL_SPEED == 0
  // Very High speed
  #define SERIAL_DELAY 4             // micro sec
  #define READ_WRITE_START_ADJUST 30 // cycles
  #define READ_WRITE_WIDTH_ADJUST 10 // cycles
 #elif SELECT_SERIAL_SPEED == 1
  // High speed
  #define SERIAL_DELAY 6             // micro sec
  #define READ_WRITE_START_ADJUST 23 // cycles
  #define READ_WRITE_WIDTH_ADJUST 10 // cycles
 #elif SELECT_SERIAL_SPEED == 2
  // Middle speed
  #define SERIAL_DELAY 12            // micro sec
  #define READ_WRITE_START_ADJUST 25 // cycles
  #define READ_WRITE_WIDTH_ADJUST 10 // cycles
 #elif SELECT_SERIAL_SPEED == 3
  // Low speed
  #define SERIAL_DELAY 24            // micro sec
  #define READ_WRITE_START_ADJUST 25 // cycles
  #define READ_WRITE_WIDTH_ADJUST 10 // cycles
 #elif SELECT_SERIAL_SPEED == 4
  // Very Low speed
  #define SERIAL_DELAY 50            // micro sec
  #define READ_WRITE_START_ADJUST 25 // cycles
  #define READ_WRITE_WIDTH_ADJUST 10 // cycles
 #else
 #error Illegal Serial Speed
 #endif
 #define SERIAL_DELAY_HALF1 (SERIAL_DELAY/2)
 #define SERIAL_DELAY_HALF2 (SERIAL_DELAY - SERIAL_DELAY/2)
 #define SLAVE_INT_WIDTH 1
 #define SLAVE_INT_RESPONSE_TIME SERIAL_DELAY
 uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0};
 uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0};
 #define SLAVE_DATA_CORRUPT (1<<0)
 volatile uint8_t status = 0;
 inline static
 void serial_delay(void) {
  _delay_us(SERIAL_DELAY);
 }
 inline static
 void serial_delay_half1(void) {
  _delay_us(SERIAL_DELAY_HALF1);
 }
 inline static
 void serial_delay_half2(void) {
  _delay_us(SERIAL_DELAY_HALF2);
 }
 inline static
 void serial_output(void) {
  SERIAL_PIN_DDR |= SERIAL_PIN_MASK;
 }
 // make the serial pin an input with pull-up resistor
 inline static
 void serial_input_with_pullup(void) {
  SERIAL_PIN_DDR  &= ~SERIAL_PIN_MASK;
  SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
 }
 inline static
 uint8_t serial_read_pin(void) {
  return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK);
 }
 inline static
 void serial_low(void) {
  SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;
 }
 inline static
 void serial_high(void) {
  SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
 }
 void serial_master_init(void) {
  serial_output();
  serial_high();
 }
 void serial_slave_init(void) {
  serial_input_with_pullup();
 #if SERIAL_PIN_MASK == _BV(PD0)
  // Enable INT0
  EIMSK |= _BV(INT0);
  // Trigger on falling edge of INT0
  EICRA &= ~(_BV(ISC00) | _BV(ISC01));
 #elif SERIAL_PIN_MASK == _BV(PD2)
  // Enable INT2
  EIMSK |= _BV(INT2);
  // Trigger on falling edge of INT2
  EICRA &= ~(_BV(ISC20) | _BV(ISC21));
 #else
 #error unknown SERIAL_PIN_MASK value
 #endif
 }
 // Used by the sender to synchronize timing with the reciver.
 static
 void sync_recv(void) {
  for (int i = 0; i < SERIAL_DELAY*5 && serial_read_pin(); i++ ) {
  }
  // This shouldn't hang if the slave disconnects because the
  // serial line will float to high if the slave does disconnect.
  while (!serial_read_pin());
 }
 // Used by the reciver to send a synchronization signal to the sender.
 static
 void sync_send(void) {
  serial_low();
  serial_delay();
  serial_high();
 }
 // Reads a byte from the serial line
 static
 uint8_t serial_read_byte(void) {
  uint8_t byte = 0;
  _delay_sub_us(READ_WRITE_START_ADJUST);
  for ( uint8_t i = 0; i < 8; ++i) {
    serial_delay_half1();   // read the middle of pulses
    byte = (byte << 1) | serial_read_pin();
    _delay_sub_us(READ_WRITE_WIDTH_ADJUST);
    serial_delay_half2();
  }
  return byte;
 }
 // Sends a byte with MSB ordering
 static
 void serial_write_byte(uint8_t data) {
  uint8_t b = 1<<7;
  while( b ) {
    if(data & b) {
      serial_high();
    } else {
      serial_low();
    }
    b >>= 1;
    serial_delay();
  }
  serial_low(); // sync_send() / senc_recv() need raise edge
 }
 // interrupt handle to be used by the slave device
 ISR(SERIAL_PIN_INTERRUPT) {
  serial_output();
  // slave send phase
  uint8_t checksum = 0;
  for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
    sync_send();
    serial_write_byte(serial_slave_buffer[i]);
    checksum += serial_slave_buffer[i];
  }
  sync_send();
  serial_write_byte(checksum);
  // slave switch to input
  sync_send(); //0
  serial_delay_half1(); //1
  serial_low();         //2
  serial_input_with_pullup(); //2
  serial_delay_half1(); //3
  // slave recive phase
  uint8_t checksum_computed = 0;
  for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
    sync_recv();
    serial_master_buffer[i] = serial_read_byte();
    checksum_computed += serial_master_buffer[i];
  }
  sync_recv();
  uint8_t checksum_received = serial_read_byte();
  if ( checksum_computed != checksum_received ) {
    status |= SLAVE_DATA_CORRUPT;
  } else {
    status &= ~SLAVE_DATA_CORRUPT;
  }
  sync_recv(); //weit master output to high
 }
 inline
 bool serial_slave_DATA_CORRUPT(void) {
  return status & SLAVE_DATA_CORRUPT;
 }
 // Copies the serial_slave_buffer to the master and sends the
 // serial_master_buffer to the slave.
 //
 // Returns:
 // 0 => no error
 // 1 => slave did not respond
 // 2 => checksum error
 int serial_update_buffers(void) {
  // this code is very time dependent, so we need to disable interrupts
  cli();
  // signal to the slave that we want to start a transaction
  serial_output();
  serial_low();
  _delay_us(SLAVE_INT_WIDTH);
  // wait for the slaves response
  serial_input_with_pullup();
  _delay_us(SLAVE_INT_RESPONSE_TIME);
  // check if the slave is present
  if (serial_read_pin()) {
    // slave failed to pull the line low, assume not present
    serial_output();
    serial_high();
    sei();
    return 1;
  }
  // master recive phase
  // if the slave is present syncronize with it
  uint8_t checksum_computed = 0;
  // receive data from the slave
  for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
    sync_recv();
    serial_slave_buffer[i] = serial_read_byte();
    checksum_computed += serial_slave_buffer[i];
  }
  sync_recv();
  uint8_t checksum_received = serial_read_byte();
  if (checksum_computed != checksum_received) {
    serial_output();
    serial_high();
    sei();
    return 2;
  }
  // master switch to output
  sync_recv(); //0
  serial_delay();  //1
  serial_low();    //3
  serial_output(); // 3
  serial_delay_half1(); //4
  // master send phase
  uint8_t checksum = 0;
  for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
    sync_send();
    serial_write_byte(serial_master_buffer[i]);
    checksum += serial_master_buffer[i];
  }
  sync_send();
  serial_write_byte(checksum);
  // always, release the line when not in use
  sync_send();
  sei();
  return 0;
 }
 #endif
@@ -1,27 +0,0 @@
 #ifndef SOFT_SERIAL_H
 #define SOFT_SERIAL_H
 #include <stdbool.h>
 // ////////////////////////////////////////////
 // Need Soft Serial defines in serial_config.h
 // ////////////////////////////////////////////
 // ex.
 //  #define SERIAL_PIN_DDR DDRD
 //  #define SERIAL_PIN_PORT PORTD
 //  #define SERIAL_PIN_INPUT PIND
 //  #define SERIAL_PIN_MASK _BV(PD?)   ?=0,2
 //  #define SERIAL_PIN_INTERRUPT INT?_vect  ?=0,2
 //  #define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2
 //  #define SERIAL_MASTER_BUFFER_LENGTH MATRIX_ROWS/2
 // Buffers for master - slave communication
 extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH];
 extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH];
 void serial_master_init(void);
 void serial_slave_init(void);
 int serial_update_buffers(void);
 bool serial_slave_data_corrupt(void);
 #endif /* SOFT_SERIAL_H */
@@ -1,16 +0,0 @@
 #ifndef SOFT_SERIAL_CONFIG_H
 #define SOFT_SERIAL_CONFIG_H
 /* Soft Serial defines */
 #define SERIAL_PIN_DDR DDRD
 #define SERIAL_PIN_PORT PORTD
 #define SERIAL_PIN_INPUT PIND
 #define SERIAL_PIN_MASK _BV(PD2)
 #define SERIAL_PIN_INTERRUPT INT2_vect
 #define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2
 #define SERIAL_MASTER_BUFFER_LENGTH MATRIX_ROWS/2
 //// #error rev2 serial config
 #endif /* SOFT_SERIAL_CONFIG_H */
@@ -1,70 +0,0 @@
 #include <avr/io.h>
 #include <avr/wdt.h>
 #include <avr/power.h>
 #include <avr/interrupt.h>
 #include <util/delay.h>
 #include <avr/eeprom.h>
 #include "split_util.h"
 #include "matrix.h"
 #include "keyboard.h"
 #ifdef USE_I2C
 #  include "i2c.h"
 #else
 #  include "serial.h"
 #endif
 volatile bool isLeftHand = true;
 static void setup_handedness(void) {
  #ifdef EE_HANDS
    isLeftHand = eeprom_read_byte(EECONFIG_HANDEDNESS);
  #else
    // I2C_MASTER_RIGHT is deprecated, use MASTER_RIGHT instead, since this works for both serial and i2c
    #if defined(I2C_MASTER_RIGHT) || defined(MASTER_RIGHT)
      isLeftHand = !has_usb();
    #else
      isLeftHand = has_usb();
    #endif
  #endif
 }
 static void keyboard_master_setup(void) {
 #ifdef USE_I2C
    i2c_master_init();
 #else
    serial_master_init();
 #endif
 }
 static void keyboard_slave_setup(void) {
 #ifdef USE_I2C
    i2c_slave_init(SLAVE_I2C_ADDRESS);
 #else
    serial_slave_init();
 #endif
 }
 bool has_usb(void) {
   USBCON |= (1 << OTGPADE); //enables VBUS pad
   _delay_us(5);
   return (USBSTA & (1<<VBUS));  //checks state of VBUS
 }
 void split_keyboard_setup(void) {
   setup_handedness();
   if (has_usb()) {
      keyboard_master_setup();
   } else {
      keyboard_slave_setup();
   }
   sei();
 }
 // this code runs before the usb and keyboard is initialized
 void matrix_setup(void) {
    split_keyboard_setup();
 }
@@ -1,19 +0,0 @@
 #ifndef SPLIT_KEYBOARD_UTIL_H
 #define SPLIT_KEYBOARD_UTIL_H
 #include <stdbool.h>
 #include "eeconfig.h"
 #define SLAVE_I2C_ADDRESS           0x32
 extern volatile bool isLeftHand;
 // slave version of matix scan, defined in matrix.c
 void matrix_slave_scan(void);
 void split_keyboard_setup(void);
 bool has_usb(void);
 void matrix_master_OLED_init (void);
 #endif
@@ -1,40 +0,0 @@
 #pragma once
 #ifdef AUDIO_ENABLE
    #define STARTUP_SONG SONG(PREONIC_SOUND)
    // #define STARTUP_SONG SONG(NO_SOUND)
    #define DEFAULT_LAYER_SONGS { SONG(QWERTY_SOUND), \
                                  SONG(COLEMAK_SOUND), \
                                  SONG(DVORAK_SOUND) \
                                }
 #endif
 #define MUSIC_MASK (keycode != KC_NO)
 /*
 * MIDI options
 */
 /* Prevent use of disabled MIDI features in the keymap */
 //#define MIDI_ENABLE_STRICT 1
 /* enable basic MIDI features:
   - MIDI notes can be sent when in Music mode is on
 */
 #define MIDI_BASIC
 /* enable advanced MIDI features:
   - MIDI notes can be added to the keymap
   - Octave shift and transpose
   - Virtual sustain, portamento, and modulation wheel
   - etc.
 */
 //#define MIDI_ADVANCED
 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 2
 #define LEADER_TIMEOUT 400
 #define LEADER_PER_KEY_TIMING
@@ -1,192 +0,0 @@
 /* Copyright 2015-2017 Jack Humbert 2019-2020 Alfred Maler
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include QMK_KEYBOARD_H
 #include "muse.h"
 enum preonic_layers {
  _QWERTY,
  _SETTINGS,
  _SYMBOLS,
  _NAVIGATION,
  _NUMPAD,
 };
 enum preonic_keycodes {
  QWERTY = SAFE_RANGE,
  SYMBOLS,
  NAVIGATION,
  NUMPAD,
  SETTINGS
 };
 #define NUMSPACE LT(_NUMPAD, KC_SPC)
 #define NAVLAYER MO(_NAVIGATION)
 #define SYMLAYER MO(_SYMBOLS)
 #define CTRLSHFT C(KC_LSFT)
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* Qwerty
 * ,-----------------------------------------------------------------------------------.
 * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Bksp |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | TAB  |   Q  |   W  |   E  |   R  |   T  |   Y  |   U  |   I  |   O  |   P  | DEL  |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | NAV  |   A  |   S  |   D  |   F  |   G  |   H  |   J  |   K  |   L  |   ;  |  "   |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | SHFT |   Z  |   X  |   C  |   V  |   B  |   N  |   M  |   ,  |   .  |   /  | SHFT |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | CTRL | C/S  | LGUI | LALT | SYMB |  SPACE/NUM  | SYMB | RALT | SETT | MUTG | LEAD |
 * `-----------------------------------------------------------------------------------'
 */
 [_QWERTY] = LAYOUT_preonic_grid(
  KC_GRV,      KC_1,     KC_2,    KC_3,    KC_4,     KC_5,     KC_6,     KC_7,     KC_8,    KC_9,     KC_0,    KC_BSPC, 
  KC_TAB,      KC_Q,     KC_W,    KC_E,    KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,    KC_O,     KC_P,    KC_DEL,  
  NAVLAYER,    KC_A,     KC_S,    KC_D,    KC_F,     KC_G,     KC_H,     KC_J,     KC_K,    KC_L,     KC_SCLN, KC_QUOT, 
  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_LCTL,     CTRLSHFT, KC_LGUI, KC_LALT, SYMLAYER, NUMSPACE, NUMSPACE, SYMLAYER, KC_RALT, SETTINGS, MU_TOG,  KC_LEAD
 ),
 /* SYMBOLS
 * ,-----------------------------------------------------------------------------------.
 * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Bksp |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | TAB  |   #  |   $  |   {  |   }  |      |      |   ^  |   *  |   |  |   ~  | DEL  |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | ESC  |   <  |   >  |   (  |   )  |      |      |   -  |   +  |   &  |   \  |   `  |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | SHFT |   !  |   @  |   [  |   ]  |      |      |   _  |   =  |   %  |   /  | SHFT |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | TRNS | TRNS | TRNS | TRNS | TRNS |    TRNS     | TRNS | TRNS | TRNS | TRNS | TRNS |
 * `-----------------------------------------------------------------------------------'
 */
 [_SYMBOLS] = LAYOUT_preonic_grid(
  KC_GRV,  KC_1,       KC_2,       KC_3,       KC_4,       KC_5,     KC_6,     KC_7,       KC_8,     KC_9,     KC_0,    KC_BSPC,
  KC_TAB,  KC_HASH,    KC_DOLLAR,  KC_LCBR,    KC_RCBR,    KC_NO,    KC_NO,    KC_CIRC,    KC_ASTR,  KC_PIPE,  KC_TILD, KC_DEL, 
  KC_NO,   KC_LABK,    KC_RABK,    KC_LPRN,    KC_RPRN,    KC_NO,    KC_NO,    KC_MINS,    KC_PLUS,  KC_AMPR,  KC_BSLS, KC_GRV, 
  KC_LSFT, KC_EXCLAIM, KC_AT,      KC_LBRC,    KC_RBRC,    KC_NO,    KC_NO,    KC_UNDS,    KC_EQL,   KC_PERC,  KC_SLSH, KC_RSFT,
  KC_TRNS, KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,  KC_TRNS,  KC_TRNS,    KC_TRNS,  KC_TRNS,  KC_TRNS, KC_TRNS 
 ),
 /* NAVIGATION
 * ,-----------------------------------------------------------------------------------.
 * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Bksp |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | TRNS |      |      | SPC  |  F5  |      | INS  | HOME | END  | TAB  |      | DEL  |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | NAV  | SHFT | CTRl | ALT  | GUI  |      | LEFT | DOWN | UP   | RGHT |      | ENTR |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | SHFT | UNDO | CUT  | COPY | PSTE |      | SPC  | PGDO | PGUP |      |      | SHFT |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | TRNS | TRNS | TRNS | TRNS | TRNS |     ESC     | TRNS | TRNS | TRNS | TRNS | TRNS |
 * `-----------------------------------------------------------------------------------'
 */
 [_NAVIGATION] = LAYOUT_preonic_grid(
  KC_GRV,  KC_1,    KC_2,     KC_3,    KC_4,     KC_5,    KC_6,    KC_7,    KC_8,    KC_9,      KC_0,    KC_BSPC, 
  KC_TRNS, KC_NO,   KC_NO,    KC_SPC,  KC_F5,    KC_NO,   KC_INS,  KC_HOME, KC_END,  KC_TAB,    KC_NO,   KC_DEL,  
  KC_TRNS, KC_LSFT, KC_LCTRL, KC_LALT, KC_LGUI,  KC_NO,   KC_LEFT, KC_DOWN, KC_UP,   KC_RIGHT,  KC_NO,   KC_ENT, 
  KC_TRNS, C(KC_Z), C(KC_X),  C(KC_C), C(KC_V),  KC_NO,   KC_SPC,  KC_PGDN, KC_PGUP, KC_NO,     KC_NO,   KC_TRNS,
  KC_TRNS, KC_TRNS, KC_TRNS,  KC_TRNS, KC_TRNS,  KC_ESC,  KC_ESC,  KC_TRNS, KC_TRNS, KC_TRNS,   KC_TRNS, KC_TRNS 
 ),
 /* NUMPAD
 * ,-----------------------------------------------------------------------------------.
 * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Bksp |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | TRNS |  F9  |  F10 |  F11 |  F12 |      |      |   7  |   8  |   9  |   -  | DEL  |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | ESC  |  F5  |  F6  |  F7  |  F8  | SPC  | SPC  |   4  |   5  |   6  |   +  | ENTR |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | TRNS |  F1  |  F2  |  F3  |  F4  | ALT  | CAPS |   1  |   2  |   3  |   /  | TRNS |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | TRNS | TRNS | TRNS | TRNS | TRNS |    TRNS     |   0  |   ,  |   .  |   *  | TRNS |
 * `-----------------------------------------------------------------------------------'
 */
 [_NUMPAD] = LAYOUT_preonic_grid( 
  KC_GRV,  KC_1,    KC_2,     KC_3,    KC_4,    KC_5,    KC_6,     KC_7,    KC_8,    KC_9,     KC_0,     KC_BSPC,
  KC_TAB,  KC_F9,   KC_F10,   KC_F11,  KC_F12,  KC_NO,   KC_NO,    KC_7,    KC_8,    KC_9,     KC_MINS,  KC_DEL, 
  KC_ESC,  KC_F5,   KC_F6,    KC_F7,   KC_F8,   KC_SPC,  KC_SPC,   KC_4,    KC_5,    KC_6,     KC_PLUS,  KC_ENT, 
  KC_LSFT, KC_F1,   KC_F2,    KC_F3,   KC_F4,   KC_LALT, KC_CAPS,  KC_1,    KC_2,    KC_3,     KC_SLSH,  KC_TRNS,
  KC_TRNS, KC_TRNS, KC_TRNS,  KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,  KC_0, KC_COMM,    KC_DOT,   KC_ASTR,  KC_TRNS 
 ),
 /* SETTINGS
 * ,-----------------------------------------------------------------------------------.
 * |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * |      |      |      |      |      |      |      |      |      |      |      |  Del |
 * |------+------+------+------+------+-------------+------+------+------+------+------|
 * |      |      |      |Aud on|AudOff|AGnorm|AGswap|Qwerty|      |      |      |      |
 * |------+------+------+------+------+------|------+------+------+------+------+------|
 * | ASTG |Voice-|Voice+|Mus on|MusOff|MidiOn|MidOff|      |      |      |      |      |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * |      |      |      |      |      |             |      |      |      |      |      |
 * `-----------------------------------------------------------------------------------'
 */
 [_SETTINGS] = LAYOUT_preonic_grid( 
  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  
  _______, _______,   DEBUG,   _______, _______, _______, _______, TERM_ON, TERM_OFF,_______, _______, KC_DEL,
  _______, _______, MU_MOD,  AU_ON,   AU_OFF,  AG_NORM, AG_SWAP, QWERTY,  _______, _______,  _______, _______,
  KC_ASTG, MUV_DE,  MUV_IN,  MU_ON,   MU_OFF,  MI_ON,   MI_OFF,  _______, _______, _______, _______, _______, 
  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______  
 )
 };
 bool muse_mode = false;
 uint8_t last_muse_note = 0;
 uint16_t muse_counter = 0;
 uint8_t muse_offset = 70;
 uint16_t muse_tempo = 50;
 LEADER_EXTERNS();
 void matrix_scan_user(void) {
 #ifdef AUDIO_ENABLE
    if (muse_mode) {
        if (muse_counter == 0) {
            uint8_t muse_note = muse_offset + SCALE[muse_clock_pulse()];
            if (muse_note != last_muse_note) {
                stop_note(compute_freq_for_midi_note(last_muse_note));
                play_note(compute_freq_for_midi_note(muse_note), 0xF);
                last_muse_note = muse_note;
            }
        }
        muse_counter = (muse_counter + 1) % muse_tempo;
    } else {
        if (muse_counter) {
            stop_all_notes();
            muse_counter = 0;
        }
    }
 #endif
  LEADER_DICTIONARY() {
    leading = false;
    SEQ_FIVE_KEYS(KC_R, KC_E, KC_S, KC_E, KC_T) {
      reset_keyboard();
    }
    leader_end(); 
  }
 }
 bool music_mask_user(uint16_t keycode) {
  switch (keycode) {
    default:
      return true;
  }
 }
@@ -1,80 +0,0 @@
 # alfrdmalr's preonic layout
 ## Overview 
 The alphanumeric characters and symbols are spread between three main 'typing' layers: QWERTY, NUMPAD, and SYMBOLS. The NUMPAD layer also holds the first twelve function keys.
 A fourth layer, NAVIGATION, contains useful modifiers, shortcuts, and navigation functions like the arrow keys and page up/down. This layer also provides access to the ENTER and ESC keys. 
 Finally, a SETTINGS layer can be used to adjust certain keyboard-related options. Right now, this is pretty similar to the default settings layer (the planck's ADJUST layer). Primary differences are the inclusion of an autoshift toggle and the removal of the reset button. The bootloader functionality has been moved to a leader key sequence: LEAD - R - E - S - E - T. 
 ```
 /* Qwerty
 * ,-----------------------------------------------------------------------------------.
 * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Bksp |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | Tab  |   Q  |   W  |   E  |   R  |   T  |   Y  |   U  |   I  |   O  |   P  | Del  |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | NAV  |   A  |   S  |   D  |   F  |   G  |   H  |   J  |   K  |   L  |   ;  |  "   |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | SHFT |   Z  |   X  |   C  |   V  |   B  |   N  |   M  |   ,  |   .  |   /  | SHFT |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | CTRL | C/S  | LGUI | LALT | SYMB |  SPACE/NUM  | SYMB | RALT | SETT |mu tog| LEAD |
 * `-----------------------------------------------------------------------------------'
 */
 /* SYMBOLS
 * ,-----------------------------------------------------------------------------------.
 * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Bksp |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | Tab  |   #  |   $  |   {  |   }  |      |      |   ^  |   *  |   |  |   ~  | Del  |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | Esc  |   <  |   >  |   (  |   )  |      |      |   -  |   +  |   &  |   `  | ENTR |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | SHFT |   !  |   @  |   [  |   ]  |      |      |   _  |   =  |   %  |   /  | SHFT |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | TRNS | TRNS | TRNS | TRNS | TRNS |    TRNS     | TRNS | TRNS | TRNS | TRNS | TRNS |
 * `-----------------------------------------------------------------------------------'
 */
 /* NUMPAD
 * ,-----------------------------------------------------------------------------------.
 * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Bksp |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | TRNS |  F9  |  F10 |  F11 |  F12 |      |      |   7  |   8  |   9  |   -  | DEL  |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | ESC  |  F5  |  F6  |  F7  |  F8  | SPC  | SPC  |   4  |   5  |   6  |   +  | ENTR |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | TRNS |  F1  |  F2  |  F3  |  F4  | ALT  | CAPS |   1  |   2  |   3  |   /  | TRNS |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | TRNS | TRNS | TRNS | TRNS | TRNS |    TRNS     |   0  |   ,  |   .  |   *  | TRNS |
 * `-----------------------------------------------------------------------------------'
 */
 /* NAVIGATION
 * ,-----------------------------------------------------------------------------------.
 * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Bksp |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | TRNS |      |      | SPC  |  F5  |      | INS  | HOME | END  | TAB  |      | Del  |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | NAV  | SHIFT| CTRl | ALT  | GUI  |      | LEFT | DOWN | UP   | RIGHT|      | ENTR |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | SHFT | UNDO | CUT  | COPY | PASTE|      | SPC  | PGDO | PGUP |      |      | SHFT |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * | TRNS | TRNS | TRNS | TRNS | TRNS |     ESC     | TRNS | TRNS | TRNS | TRNS | TRNS |
 * `-----------------------------------------------------------------------------------'
 */
 /* SETTINGS
 * ,-----------------------------------------------------------------------------------.
 * |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * |      |      |      |      |      |      |      |      |      |      |      |  Del |
 * |------+------+------+------+------+-------------+------+------+------+------+------|
 * |      |      |      |Aud on|AudOff|AGnorm|AGswap|Qwerty|      |      |      |      |
 * |------+------+------+------+------+------|------+------+------+------+------+------|
 * | ASTG |Voice-|Voice+|Mus on|MusOff|MidiOn|MidOff|      |      |      |      |      |
 * |------+------+------+------+------+------+------+------+------+------+------+------|
 * |      |      |      |      |      |             |      |      |      |      |      |
 * `-----------------------------------------------------------------------------------'
 */
 ```
 ASTG = autoshift toggle
@@ -1,3 +0,0 @@
 SRC += muse.c
 AUTO_SHIFT_ENABLE = yes
 LEADER_ENABLE = yes
@@ -0,0 +1,48 @@
 /*
 Copyright 2020 Holten Campbell
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 2 of the License, or
 (at your option) any later version.
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #pragma once
 #include "config_common.h"
 /* USB Device descriptor parameter */
 #define VENDOR_ID       0xFEED
 #define PRODUCT_ID      0x4024
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    PrimeKB
 #define PRODUCT         Prime_L_V2
 #define DESCRIPTION     Custom layout keyboard
 /* key matrix size */
 #define MATRIX_ROWS 5
 #define MATRIX_COLS 16
 /* Keyboard Matrix Assignments */
 #define MATRIX_ROW_PINS { E6, B2, B1, B0, B6 }
 #define MATRIX_COL_PINS { C6, C7, F7, F6, F5, F4, F1, F0, D4, D0, D1, D2, D3, D5, B7, B3 }
 #define UNUSED_PINS
 /* COL2ROW, ROW2COL*/
 #define DIODE_DIRECTION COL2ROW
 /* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
 #define DEBOUNCE 5
 /* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
 #define LOCKING_SUPPORT_ENABLE
 /* Locking resynchronize hack */
 #define LOCKING_RESYNC_ENABLE
@@ -0,0 +1,16 @@
 {
  "keyboard_name": "Prime_L V2",
  "url": "https://www.primekb.com",
  "maintainer": "HoltenC",
  "width": 16,
  "height": 5,
  "layouts": {
      "LAYOUT": {
          "layout": [{"x":0, "y":0}, {"x":1, "y":0}, {"x":2, "y":0}, {"x":3, "y":0}, {"x":4, "y":0}, {"x":5, "y":0}, {"x":6, "y":0}, {"x":7, "y":0}, {"x":8, "y":0}, {"x":9, "y":0}, {"x":10, "y":0}, {"x":11, "y":0}, {"x":12, "y":0}, {"x":13, "y":0}, {"x":14, "y":0}, {"x":15, "y":0}, 
                    {"x":0, "y":1}, {"x":1, "y":1}, {"x":2, "y":1}, {"x":3, "y":1}, {"x":4, "y":1}, {"x":5, "y":1}, {"x":6, "y":1}, {"x":7, "y":1}, {"x":8, "y":1}, {"x":9, "y":1}, {"x":10, "y":1}, {"x":11, "y":1}, {"x":12, "y":1}, {"x":13, "y":1}, {"x":14, "y":1}, {"x":15, "y":1}, 
                    {"x":0, "y":2}, {"x":1, "y":2}, {"x":2, "y":2}, {"x":3, "y":2, "w":1.25}, {"x":4.25, "y":2}, {"x":5.25, "y":2}, {"x":6.25, "y":2}, {"x":7.25, "y":2}, {"x":8.25, "y":2}, {"x":9.25, "y":2}, {"x":10.25, "y":2}, {"x":11.25, "y":2}, {"x":12.25, "y":2}, {"x":13.25, "y":2}, {"x":14.25, "y":2, "w":1.75}, 
                    {"x":0, "y":3}, {"x":1, "y":3}, {"x":2, "y":3}, {"x":3, "y":3, "w":1.75}, {"x":4.75, "y":3}, {"x":5.75, "y":3}, {"x":6.75, "y":3}, {"x":7.75, "y":3}, {"x":8.75, "y":3}, {"x":9.75, "y":3}, {"x":10.75, "y":3}, {"x":11.75, "y":3}, {"x":12.75, "y":3}, {"x":13.75, "y":3}, {"x":14.75, "y":3, "w":1.25}, 
                    {"x":0, "y":4}, {"x":1, "y":4}, {"x":2, "y":4}, {"x":3, "y":4, "w":1.25}, {"x":4.25, "y":4, "w":1.25}, {"x":5.5, "y":4}, {"x":6.5, "y":4, "w":1.25}, {"x":7.75, "y":4, "w":1.75}, {"x":9.5, "y":4, "w":1.75}, {"x":11.25, "y":4, "w":1.25}, {"x":12.5, "y":4}, {"x":13.5, "y":4, "w":1.25}, {"x":14.75, "y":4, "w":1.25}]
      }
  }
 }
@@ -0,0 +1,34 @@
 /* Copyright 2020 Holten Campbell
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include QMK_KEYBOARD_H
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    [0] = LAYOUT(
 		KC_ESC, KC_HOME, KC_END, KC_PSCR, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_PGUP, KC_BSPC, 
 		KC_P7, KC_P8, KC_P9, KC_NLCK, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_PGDN, KC_BSLS, 
 		KC_P4, KC_P5, KC_P6, KC_TAB, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_QUOT, KC_ENT, 
 		KC_P1, KC_P2, KC_P3, 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_ENT, KC_PDOT, KC_P0, KC_LCTL, KC_LALT, KC_LBRC, KC_RBRC, MO(1), KC_SPC, KC_MINS, KC_EQL, KC_RGUI, KC_RCTL
    ),
 	[1] = LAYOUT(
 		RESET, KC_TRNS, KC_TRNS, KC_TRNS, 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_GRV, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_UP, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, 
 		KC_TRNS, KC_TRNS, KC_TRNS, KC_CAPS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_LEFT, KC_DOWN, KC_RGHT, KC_SCLN, KC_TRNS, 
 		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, 
 		BL_TOGG, BL_STEP, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_DEL, KC_VOLD, KC_VOLU, KC_MUTE, KC_TRNS
    )
 };
@@ -0,0 +1 @@
 # The default keymap for prime_l_v2
@@ -1,4 +1,5 @@
-/*
+/* Copyright 2020 Holten Campbell
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
@@ -12,5 +13,4 @@
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-
+#include "prime_l_v2.h"
 #pragma once
@@ -0,0 +1,33 @@
 /* Copyright 2020 Holten Campbell
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #pragma once
 #include "quantum.h"
 #define LAYOUT( \
 	K000, K001, K002, K003, K004, K005, K006, K007, K008, K009, K010, K011, K012, K013, K014, K015, \
 	K100, K101, K102, K103, K104, K105, K106, K107, K108, K109, K110, K111, K112, K113, K114, K115, \
 	K200, K201, K202, K203, K204, K205, K206, K207, K208, K209, K210, K211, K212, K213,    K215    , \
 	K300, K301, K302, K303,       K305, K306, K307, K308, K309, K310, K311, K312, K313, K314, K315, \
 	K400, K401, K402, K403,       K405, K406, K407, K408,       K410,       K412, K413, K414, K415  \
 ) { \
 	{ K000,  K001,  K002,  K003,  K004,  K005,  K006,  K007,  K008,  K009,  K010,  K011,  K012,  K013,  K014,  K015 }, \
 	{ K100,  K101,  K102,  K103,  K104,  K105,  K106,  K107,  K108,  K109,  K110,  K111,  K112,  K113,  K114,  K115 }, \
 	{ K200,  K201,  K202,  K203,  K204,  K205,  K206,  K207,  K208,  K209,  K210,  K211,  K212,  K213,  KC_NO, K215 }, \
 	{ K300,  K301,  K302,  K303,  K305,  K306,  K307,  K308,  K309,  K310,  K311,  K312,  K313,  KC_NO, K314,  K315 }, \
 	{ K400,  K401,  K402,  K403,  K405,  K406,  K407,  K408,  KC_NO, K410,  KC_NO, K412,  K413,  KC_NO, K414,  K415 }  \
 }
@@ -0,0 +1,15 @@
 # Prime_L_V2
 ![Prime_L_V2](https://i.imgur.com/P3P6GUu.jpg)
 A compact layout with the footprint of your typical 65% board, featuring a left mini-numpad.
 * Keyboard Maintainer: [HoltenC](https://github.com/HoltenC)
 * Hardware Supported: Prime_L_V2 PCBs, ATMega32u4
 * Hardware Availability: [Store Link](https://www.primekb.com)
 Make example for this keyboard (after setting up your build environment):
    make primekb/prime_l_v2:default
 See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).
@@ -0,0 +1,33 @@
 # MCU name
 MCU = atmega32u4
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
 #   ATmega32A    bootloadHID
 #   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 # Build Options
 #   change yes to no to disable
 #
 BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration
 MOUSEKEY_ENABLE = yes       # Mouse keys
 EXTRAKEY_ENABLE = yes       # Audio control and System control
 CONSOLE_ENABLE = no         # Console for debug
 COMMAND_ENABLE = no         # Commands for debug and configuration
 # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
 SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend
 # if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
 NKRO_ENABLE = yes           # USB Nkey Rollover
 BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality
 RGBLIGHT_ENABLE = no        # Enable keyboard RGB underglow
 MIDI_ENABLE = no            # MIDI support
 UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
 HD44780_ENABLE = no 		# Enable support for HD44780 based LCDs
@@ -0,0 +1,50 @@
 #pragma once
 #include "config_common.h"
 /* USB Device descriptor parameter */
 #define VENDOR_ID       0xFEED
 #define PRODUCT_ID      0x62AC
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    Walletburner
 #define PRODUCT         Neuron
 #define DESCRIPTION     Keyboard
 /* key matrix size */
 #define MATRIX_ROWS 4
 #define MATRIX_COLS 12
 /* key matrix pins */
 #define MATRIX_ROW_PINS { D0, D1, D3, F5 }
 #define MATRIX_COL_PINS { F0, F7, F6, F4, F1, E6, D6, D2, B4, D7, B6, D5 }
 #define UNUSED_PINS
 /* COL2ROW or ROW2COL */
 #define DIODE_DIRECTION COL2ROW
 /* number of backlight levels */
 #define BACKLIGHT_PIN B5
 #ifdef BACKLIGHT_PIN
 #define BACKLIGHT_LEVELS 3
 #endif
 /* Set 0 if debouncing isn't needed */
 #define DEBOUNCE 5
 /* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
 #define LOCKING_SUPPORT_ENABLE
 /* Locking resynchronize hack */
 #define LOCKING_RESYNC_ENABLE
 #define RGB_DI_PIN B1
 #ifdef RGB_DI_PIN
 #define RGBLIGHT_ANIMATIONS
 #define RGBLED_NUM 1
 #define RGBLIGHT_HUE_STEP 8
 #define RGBLIGHT_SAT_STEP 8
 #define RGBLIGHT_VAL_STEP 8
 #endif
@@ -0,0 +1,12 @@
 {
    "keyboard_name": "Neuron", 
    "url": "https://qmk.fm/keyboards/", 
    "maintainer": "worldspawn00", 
    "width": 12, 
    "height": 4, 
    "layouts": {
        "LAYOUT": {
            "layout": [{"label":"Esc", "x":0, "y":0}, {"label":"Q", "x":1, "y":0}, {"label":"W", "x":2, "y":0}, {"label":"E", "x":3, "y":0}, {"label":"R", "x":4, "y":0}, {"label":"T", "x":5, "y":0}, {"label":"Y", "x":6, "y":0}, {"label":"U", "x":7, "y":0}, {"label":"I", "x":8, "y":0}, {"label":"O\u2191", "x":9, "y":0}, {"label":"P", "x":10, "y":0}, {"label":"Back<br>Space", "x":11, "y":0}, {"label":"Ctrl", "x":0, "y":1, "w":1.25}, {"label":"A", "x":1.25, "y":1}, {"label":"S", "x":2.25, "y":1}, {"label":"D", "x":3.25, "y":1}, {"label":"F", "x":4.25, "y":1}, {"label":"G", "x":5.25, "y":1}, {"label":"H", "x":6.25, "y":1}, {"label":"J", "x":7.25, "y":1}, {"label":"K\u2190", "x":8.25, "y":1}, {"label":"L\u2192", "x":9.25, "y":1}, {"label":"Enter", "x":10.25, "y":1, "w":1.75}, {"label":"Shift", "x":0, "y":2, "w":1.75}, {"label":"Z", "x":1.75, "y":2}, {"label":"X", "x":2.75, "y":2}, {"label":"C", "x":3.75, "y":2}, {"label":"V", "x":4.75, "y":2}, {"label":"B", "x":5.75, "y":2}, {"label":"N", "x":6.75, "y":2}, {"label":"M", "x":7.75, "y":2}, {"label":"<\u2193,", "x":8.75, "y":2}, {"label":">.", "x":9.75, "y":2}, {"label":"Fn", "x":10.75, "y":2, "w":1.25}, {"label":"Super", "x":1, "y":3}, {"label":"Meta", "x":2, "y":3, "w":1.5}, {"x":3.5, "y":3, "w":2.25}, {"x":5.75, "y":3, "w":2.75}, {"label":"Meta", "x":8.5, "y":3, "w":1.5}, {"label":"Alt Gr", "x":10, "y":3}]
        }
    }
 }
@@ -0,0 +1,18 @@
 #include QMK_KEYBOARD_H
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 	[0] = LAYOUT(
 		KC_ESC, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC, 
 		KC_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_ENT, 
 		KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, MO(1), 
 		KC_LGUI, KC_RALT, KC_SPC, KC_SPC, KC_SPC, KC_RALT, KC_RGUI),
 	[1] = LAYOUT(
 		RESET, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, 
 		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, 
 		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, 
 		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS)
 };
@@ -0,0 +1 @@
 #include "neuron.h"
@@ -0,0 +1,16 @@
 #pragma once
 #include "quantum.h"
 #define LAYOUT( \
 	K000, K001, K002, K003, K004, K005, K006, K007, K008, K009, K010, K011, \
 	K100, K101, K102, K103, K104, K105, K106, K107, K108, K109,       K111, \
 	K200,       K202, K203, K204, K205, K206, K207, K208, K209, K210, K211, \
 	      K301, K302, K303,             K306,       K308,       K310, K311  \
 ) { \
 	{ K000,  K001,  K002,  K003,  K004,  K005,  K006,  K007,  K008,  K009,  K010,  K011 }, \
 	{ K100,  K101,  K102,  K103,  K104,  K105,  K106,  K107,  K108,  K109,  KC_NO, K111 }, \
 	{ K200,  KC_NO, K202,  K203,  K204,  K205,  K206,  K207,  K208,  K209,  K210,  K211 }, \
 	{ KC_NO, K301,  K302,  K303,  KC_NO, KC_NO, K306,  KC_NO, K308, KC_NO, K310,  K311 }  \
 }
@@ -0,0 +1,15 @@
 # Neuron
 ![Neuron](https://i.imgur.com/HeeUwVj.png)  
 The Neuron is a 12 column staggered 40% keyboard.  
 * Keyboard Maintainer: [worldspawn00](https://github.com/worldspawn00/)  
 * Hardware Supported: The Neuron PCB and kit.  
 * Hardware Availability: [PCB & Kit](https://geekhack.org/index.php?topic=102681.0)  
 Make example for this keyboard (after setting up your build environment):
    make walletburner/neuron:default
 See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).
@@ -0,0 +1,26 @@
 # MCU name
 MCU = atmega32u4
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
 #   ATmega32A    bootloadHID
 #   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 # Build Options
 #   comment out to disable the options.
 #
 BOOTMAGIC_ENABLE = yes # Virtual DIP switch configuration
 MOUSEKEY_ENABLE = yes  # Mouse keys
 EXTRAKEY_ENABLE = yes  # Audio control and System control
 CONSOLE_ENABLE = no    # Console for debug
 COMMAND_ENABLE = no    # Commands for debug and configuration
 SLEEP_LED_ENABLE = no  # Breathing sleep LED during USB suspend
 NKRO_ENABLE = yes      # USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
 BACKLIGHT_ENABLE = no  # Enable keyboard backlight functionality
 AUDIO_ENABLE = no
 RGBLIGHT_ENABLE = yes
@@ -0,0 +1,58 @@
 #pragma once
 #include "config_common.h"
 /* USB Device descriptor parameter */
 #define VENDOR_ID       0xFEED
 #define PRODUCT_ID      0x04EF
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    Worldspawn00
 #define PRODUCT         Gothic50
 #define DESCRIPTION     Expanded Ergo Keyboard
 /* key matrix size */
 #define MATRIX_ROWS 5
 #define MATRIX_COLS 15
 /* key matrix pins */
 #define MATRIX_ROW_PINS { B5, B4, D7, D6 }
 #define MATRIX_COL_PINS { E6, F0, F1, C7, C6, B6, D4, D5, D3, D2, D1, D0, B7, B0 }
 #define UNUSED_PINS
 /* COL2ROW, ROW2COL*/
 #define DIODE_DIRECTION COL2ROW
 #define RGB_DI_PIN F7
 #ifdef RGB_DI_PIN
 #define RGBLIGHT_ANIMATIONS
 #define RGBLED_NUM 10
 #define RGBLIGHT_HUE_STEP 8
 #define RGBLIGHT_SAT_STEP 8
 #define RGBLIGHT_VAL_STEP 8
 #endif
 /* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
 #define DEBOUNCE 5
 /* define if matrix has ghost (lacks anti-ghosting diodes) */
 //#define MATRIX_HAS_GHOST
 /* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
 #define LOCKING_SUPPORT_ENABLE
 /* Locking resynchronize hack */
 #define LOCKING_RESYNC_ENABLE
 /* If defined, GRAVE_ESC will always act as ESC when CTRL is held.
 * This is userful for the Windows task manager shortcut (ctrl+shift+esc).
 */
 #define GRAVE_ESC_CTRL_OVERRIDE
@@ -0,0 +1 @@
 #include "gothic50.h"
@@ -0,0 +1,24 @@
 #pragma once
 #include "quantum.h"
 /* This a shortcut to help you visually see your layout.
 *
 * The first section contains all of the arguments representing the physical
 * layout of the board and position of the keys.
 *
 * The second converts the arguments into a two-dimensional array which
 * represents the switch matrix.
 */
 #define LAYOUT( \
    k00, k01, k02, k03, k04, k05,           k06, k07, k08, k09, k0A, k0B, k0C,         k0D, \
    k10, k11, k12, k13, k14, k15,           k16, k17, k18, k19, k1A,    k1B,           k1D, \
    k20, k21, k22, k23, k24, k25,           k26, k27, k28, k29, k2A, k2B,     k2C,     k2D, \
    k30, k31,      k32, k34, k35,           k37, k39, k3A,               k3B, k3C, k3D \
 ) \
 { \
    { k00,   k01,   k02,   k03,   k04,   k05,   k06,   k07,   k08,   k09,   k0A,   k0B,   k0C, k0D }, \
    { k10,   k11,   k12,   k13,   k14,   k15,   k16,   k17,   k18,   k19,   k1A,   k1B, KC_NO, k1D }, \
    { k20,   k21,   k22,   k23,   k24,   k25,   k26,   k27,   k28,   k29,   k2A,   k2B,   k2C, k2D }, \
    { k30,   k31,   k32,   KC_NO, k34,   k35,   KC_NO, k37,   KC_NO, k39,   k3A,   k3B,   k3C, k3D } \
 }
@@ -0,0 +1,12 @@
 {
    "keyboard_name": "Gothic50", 
    "url": "https://qmk.fm/keyboards", 
    "maintainer": "worldspawn00", 
      "width": 16.5, 
    "height": 4.25, 
    "layouts": {
        "LAYOUT": {
            "layout": [{"label":"Tab", "x":0, "y":0}, {"label":"Q", "x":1, "y":0}, {"label":"W", "x":2, "y":0}, {"label":"E", "x":3, "y":0}, {"label":"R", "x":4, "y":0}, {"label":"T", "x":5, "y":0}, {"label":"Y", "x":8.25, "y":0}, {"label":"U", "x":9.25, "y":0}, {"label":"I", "x":10.25, "y":0}, {"label":"O", "x":11.25, "y":0}, {"label":"P", "x":12.25, "y":0}, {"label":"{", "x":13.25, "y":0}, {"label":"}", "x":14.25, "y":0}, {"x":15.5, "y":0}, {"label":"Caps Lock", "x":0, "y":1, "w":1.25}, {"label":"A", "x":1.25, "y":1}, {"label":"S", "x":2.25, "y":1}, {"label":"D", "x":3.25, "y":1}, {"label":"F", "x":4.25, "y":1}, {"label":"G", "x":5.25, "y":1}, {"label":"H", "x":8.5, "y":1}, {"label":"J", "x":9.5, "y":1}, {"label":"K", "x":10.5, "y":1}, {"label":"L", "x":11.5, "y":1}, {"label":":", "x":12.5, "y":1}, {"label":"Enter", "x":13.5, "y":1, "w":1.75}, {"x":15.5, "y":1}, {"label":"Shift", "x":0, "y":2, "w":1.75}, {"label":"Z", "x":1.75, "y":2}, {"label":"X", "x":2.75, "y":2}, {"label":"C", "x":3.75, "y":2}, {"label":"V", "x":4.75, "y":2}, {"label":"B", "x":5.75, "y":2}, {"x":8, "y":2}, {"label":"N", "x":9, "y":2}, {"label":"M", "x":10, "y":2}, {"label":"<", "x":11, "y":2}, {"label":">", "x":12, "y":2}, {"label":"?", "x":13, "y":2}, {"x":15.5, "y":2}, {"x":14.25, "y":2.25}, {"label":"Ctrl", "x":0, "y":3, "w":1.25}, {"label":"Win", "x":1.25, "y":3, "w":1.25}, {"label":"Alt", "x":3.25, "y":3, "w":1.25}, {"x":4.5, "y":3}, {"x":5.5, "y":3, "w":1.25}, {"x":8, "y":3, "w":1.75}, {"label":"Alt", "x":9.75, "y":3}, {"label":"Win", "x":10.75, "y":3, "w":1.25}, {"x":13.25, "y":3.25}, {"x":14.25, "y":3.25}, {"x":15.25, "y":3.25}]
        }
    }
 }
@@ -0,0 +1,57 @@
 #include QMK_KEYBOARD_H
 // Tap Dance Declarations
 enum {
    TD_SCAPS = 0
 };
 #define SCAPS_LG TD(TD_SCAPS)
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  [0] = LAYOUT(
    KC_GESC,        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_PSCR, \
    LCTL_T(KC_TAB), KC_A,    KC_S,    KC_D,    KC_F,    KC_G,            KC_H,    KC_J,    KC_K,    KC_L,    KC_QUOT, KC_ENT,                  KC_INS, \
    SCAPS_LG,       KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,            MO(2),   KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH,      KC_UP,       KC_DEL, \
    KC_APP,         KC_LGUI,          KC_LALT, MO(1),   LT(1,KC_SPC),    KC_BSPC, KC_RALT, KC_RCTL,                        KC_LEFT, KC_DOWN, KC_RGHT \
  ),
  [1] = LAYOUT(
    KC_TILD,    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_PAUS, \
    _______, RGB_MOD, RGB_HUI, RGB_SAI, RGB_VAI, _______,       _______, _______, _______, _______, KC_SCLN, KC_BSLS,                       KC_MUTE, \
    _______, RGB_TOG, RGB_HUD, RGB_SAD, RGB_VAD, _______,       _______, _______, _______, _______, _______, _______,          KC_PGUP,       KC_MPLY, \
    _______, _______,          _______, _______, _______,       _______, _______, _______,                            KC_HOME, KC_PGDN, KC_END \
  ),
  [2] = LAYOUT(
    _______,   KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,        KC_F6,   KC_F7,   KC_F8,   KC_F9,  KC_F10,  KC_F11,   KC_F12,         RESET, \
    _______, _______, _______, _______, _______, _______,      _______, _______, _______, _______, _______, _______,                   _______, \
    _______, _______, _______, _______, _______, _______,      _______, _______, _______, _______, _______, _______,           KC_VOLU,   _______,\
    _______, _______,          _______, _______, _______,      _______, _______, _______,                             KC_MPRV, KC_VOLD, KC_MNXT \
  )
 };
 void matrix_init_user(void) {
  // set CapsLock LED to output and low
  setPinOutput(F6);
  writePinLow(F6);
  // set NumLock LED to output and low
  setPinOutput(F5);
  writePinLow(F5);
  // set ScrollLock LED to output and low
  setPinOutput(F4);
  writePinLow(F4);
 }
 layer_state_t layer_state_set_user(layer_state_t state)
 {
    writePin(F4, (state & 0x1));
    writePin(F5, (state & 0x2));
    writePin(F6, (state & 0x4));
    return state;
 }
 // Tap Dance Definitions
 qk_tap_dance_action_t tap_dance_actions[] = {
    // double tap for caps
    [TD_SCAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS)
 };
@@ -0,0 +1 @@
 TAP_DANCE_ENABLE = yes
@@ -0,0 +1,15 @@
 # Gothic50
 ![Gothic50](https://i.imgur.com/T2V63c8.png)
 An Alice style 40% board with arrowkeys, based on the Fate Arisu layout.
 * Keyboard Maintainer: [Worldspawn00](https://github.com/Worldspawn00)  
 * Hardware Supported: Gothic50 PCB
 * Hardware Availability: https://geekhack.org/index.php?topic=102180.0
 Make example for this keyboard (after setting up your build environment):
    make wsk/gothic50:default
 See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs)
@@ -0,0 +1,32 @@
 # MCU name
 MCU = atmega32u4
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
 #   atmega32a    bootloadHID
 BOOTLOADER = atmel-dfu
 # Build Options
 #   change yes to no to disable
 #
 BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration
 MOUSEKEY_ENABLE = no        # Mouse keys
 EXTRAKEY_ENABLE = yes       # Audio control and System control
 CONSOLE_ENABLE = yes        # Console for debug
 COMMAND_ENABLE = yes        # Commands for debug and configuration
 # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
 SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend
 # if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
 NKRO_ENABLE = no            # USB Nkey Rollover
 BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality on B7 by default
 RGBLIGHT_ENABLE = yes       # Enable keyboard RGB underglow
 MIDI_ENABLE = no            # MIDI support
 UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
 HD44780_ENABLE = no         # Enable support for HD44780 based LCDs
@@ -0,0 +1,46 @@
 #pragma once
 #include "config_common.h"
 /* USB Device descriptor parameter */
 #define VENDOR_ID       0xFEED
 #define PRODUCT_ID      0x63CC
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    Worldspawn00
 #define PRODUCT         Gothic70
 #define DESCRIPTION     Expanded Ergo Keyboard
 /* key matrix size */
 #define MATRIX_ROWS 5
 #define MATRIX_COLS 15
 /* key matrix pins */
 #define MATRIX_ROW_PINS { D0, D1, D2, D3, D5 }
 #define MATRIX_COL_PINS { F0, F1, E6, C7, C6, B6, D4, B1, B0, B7, B5, B4, D7, D6, B3 }
 #define UNUSED_PINS
 /* COL2ROW, ROW2COL*/
 #define DIODE_DIRECTION COL2ROW
 #define RGB_DI_PIN F4
 #ifdef RGB_DI_PIN
 #define RGBLIGHT_ANIMATIONS
 #define RGBLED_NUM 7
 #define RGBLIGHT_HUE_STEP 8
 #define RGBLIGHT_SAT_STEP 8
 #define RGBLIGHT_VAL_STEP 8
 #endif
 /* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
 #define DEBOUNCE 5
 /* define if matrix has ghost (lacks anti-ghosting diodes) */
 //#define MATRIX_HAS_GHOST
 /* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
 #define LOCKING_SUPPORT_ENABLE
 /* Locking resynchronize hack */
 #define LOCKING_RESYNC_ENABLE
Author	SHA1	Message	Date
fauxpark	6052aa499e	Use FIRMWARE_FORMAT for "Checking file size" message (#8121 )	2020-02-10 04:19:08 +11:00
nopunin10did	2fe288d01d	[Keymap] Adding ergodash/rev1:nopunin10did (#8098 ) * Adding ergodash/rev1:nopunin10did * Update keyboards/ergodash/rev1/keymaps/nopunin10did/keymap.c * Update keyboards/ergodash/rev1/keymaps/nopunin10did/keymap.c * Update keyboards/ergodash/rev1/keymaps/nopunin10did/readme.md	2020-02-08 19:54:10 -08:00
Erovia	b6e23f974b	Update the flash cli command to use the user config (#8125 )	2020-02-08 23:58:28 +01:00
fauxpark	174a15d07d	Remove PJRC USB stack	2020-02-08 11:07:43 -08:00
James Young	5ab0eeb513	[Keyboard] Boardwalk Refactor (#8122 ) * refactor keymaps Create one keymap for each layout macro. * remove config.h for default keymap There's nothing in it. * update readme - use the new list format - use a smaller version of the keyboard photo (does the readme really need a 14MP image on it?)	2020-02-08 10:25:50 -08:00
Joel Challis	75e7018f72	CI: Add workflow for CLI testing (#7357 ) Create GitHub Actions cli test workflow and remove travis runs of 'qmk pytest'	2020-02-08 13:43:55 +01:00
holtenc	8fe29f2784	Add Prime_L V2 and Prime_EXL Plus (#8111 ) * correct indicator light states. function of indicator lights was inverted. these changes correct that. * flesh out keymaps pre production * Enable extrakey in rules * Prime_BLE initial commit * Initial commit for Prime_L V2 * Update info.json correct key spacing. * update copyright * Update readme.md * Inital commit * updates before PR into QMK master * Drop Prime_EXL Plus from PR. Make requested changes to Prime_L V2 * Rename keyboards/primekb/Prime_l_v2/config.h to keyboards/primekb/prime_l_v2/config.h * Rename keyboards/primekb/prime_l_v2/config.h to keyboards/primekb/Prime_l_v2/config.h * remove directory Prime_l_v2 * re-submit with proper folder name.	2020-02-08 15:03:44 +11:00
worldspawn00 ridingqwerty Drashna Jaelre	dd6f92541d	[Keyboard] adding keyboard: neuron (#7980 ) * neuron * Update keyboards/walletburner/neuron/neuron.h Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/walletburner/neuron/neuron.h Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/walletburner/neuron/config.h Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/walletburner/neuron/config.h Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/walletburner/neuron/config.h Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/walletburner/neuron/rules.mk Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/walletburner/neuron/rules.mk Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/walletburner/neuron/rules.mk Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/walletburner/neuron/rules.mk Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/walletburner/neuron/rules.mk Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/walletburner/neuron/readme.md Co-Authored-By: Drashna Jaelre <[email protected]> * Update keyboards/walletburner/neuron/readme.md Co-Authored-By: Drashna Jaelre <[email protected]> * Update keyboards/walletburner/neuron/readme.md Co-Authored-By: Drashna Jaelre <[email protected]> * Committed review suggestions * Corrected bootloader to use atmel-dfu * One last tweak to correct MANUFACTURER Co-authored-by: ridingqwerty <[email protected]> Co-authored-by: Drashna Jaelre <[email protected]>	2020-02-07 19:42:29 -08:00
worldspawn00andridingqwerty	610cf729af	[Keyboard] adding keyboard: pain27 (#7977 ) * pain27 * Applied review suggestions * Correct DEBOUNCE verbiage, remove .ini files * Readme tweaks Co-authored-by: ridingqwerty <[email protected]>	2020-02-07 19:42:03 -08:00
worldspawn00andridingqwerty	96a4388c43	[Keyboard] adding keyboard: sl40 (#7978 ) * sl40 * Amended with collaborator suggestions Co-authored-by: ridingqwerty <[email protected]>	2020-02-07 19:39:44 -08:00
worldspawn00andridingqwerty	a86a8a236a	[Keyboard] adding keyboard: houndstooth (#7981 ) * houndstooth * Amended with collaborator suggestions * LAYOUT fixup, left crud in keymap * Fix missing comma in keymap.c * Correct RGBLIGHT_ENABLE to no Co-authored-by: ridingqwerty <[email protected]>	2020-02-07 19:38:20 -08:00
worldspawn00andridingqwerty	f44a89ca77	[Keyboard] adding keyboard: kodachi50 (#7976 ) * kodachi50 * Amendeded with collaborator suggestions * Add a missing key to layer 2 top row Co-authored-by: ridingqwerty <[email protected]>	2020-02-07 19:37:46 -08:00
worldspawn00 Drashna Jaelre ridingqwerty Mikkel Jeppesen	a1a88b8ac7	[Keyboard] adding keyboard: gothic70 (#7982 ) * gothic70 * Update keyboards/wsk/gothic70/readme.md Co-Authored-By: Drashna Jaelre <[email protected]> * Update keyboards/wsk/gothic70/readme.md Co-Authored-By: Drashna Jaelre <[email protected]> * Update keyboards/wsk/gothic70/readme.md Co-Authored-By: Drashna Jaelre <[email protected]> * Update keyboards/wsk/gothic70/keymaps/default/keymap.c Co-Authored-By: Drashna Jaelre <[email protected]> * Update keyboards/wsk/gothic70/rules.mk Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/wsk/gothic70/rules.mk Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/wsk/gothic70/rules.mk Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/wsk/gothic70/rules.mk Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/wsk/gothic70/rules.mk Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/wsk/gothic70/rules.mk Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/wsk/gothic70/config.h Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/wsk/gothic70/keymaps/default/keymap.c Co-Authored-By: Mikkel Jeppesen <[email protected]> * Update keyboards/wsk/gothic70/keymaps/default/keymap.c Co-Authored-By: Mikkel Jeppesen <[email protected]> * Update keyboards/wsk/gothic70/keymaps/default/keymap.c Co-Authored-By: Mikkel Jeppesen <[email protected]> * Update keyboards/wsk/gothic70/keymaps/default/keymap.c Co-Authored-By: Mikkel Jeppesen <[email protected]> * Update keyboards/wsk/gothic70/keymaps/default/keymap.c Co-Authored-By: Mikkel Jeppesen <[email protected]> * Update keyboards/wsk/gothic70/keymaps/default/keymap.c Co-Authored-By: Mikkel Jeppesen <[email protected]> * Update keyboards/wsk/gothic70/config.h Co-Authored-By: Mikkel Jeppesen <[email protected]> * Update keyboards/wsk/gothic70/keymaps/default/keymap.c Co-Authored-By: Mikkel Jeppesen <[email protected]> * Update keyboards/wsk/gothic70/keymaps/default/keymap.c Co-Authored-By: Mikkel Jeppesen <[email protected]> * Update keyboards/wsk/gothic70/keymaps/default/keymap.c Co-Authored-By: Mikkel Jeppesen <[email protected]> * Committed review suggestions * Small indicator LED layer function tweak * Fixing layout for configurator Co-authored-by: Drashna Jaelre <[email protected]> Co-authored-by: ridingqwerty <[email protected]> Co-authored-by: Mikkel Jeppesen <[email protected]>	2020-02-07 19:34:37 -08:00
worldspawn00 ridingqwerty Drashna Jaelre	df029f9660	[Keyboard] adding keyboard: gothic50 (#7983 ) * gothic50 * Update keyboards/wsk/gothic50/config.h Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/wsk/gothic50/config.h Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/wsk/gothic50/config.h Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/wsk/gothic50/config.h Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/wsk/gothic50/rules.mk Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/wsk/gothic50/rules.mk Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/wsk/gothic50/rules.mk Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/wsk/gothic50/rules.mk Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/wsk/gothic50/rules.mk Co-Authored-By: ridingqwerty <[email protected]> * Update keyboards/wsk/gothic50/keymaps/default/keymap.c Co-Authored-By: Drashna Jaelre <[email protected]> * Update keyboards/wsk/gothic50/readme.md Co-Authored-By: Drashna Jaelre <[email protected]> * Update keyboards/wsk/gothic50/readme.md Co-Authored-By: Drashna Jaelre <[email protected]> * Update keyboards/wsk/gothic50/readme.md Co-Authored-By: Drashna Jaelre <[email protected]> * Update keyboards/wsk/gothic50/rules.mk Co-Authored-By: ridingqwerty <[email protected]> * Updated with collaborator suggestions * Fixing layout for configurator Co-authored-by: ridingqwerty <[email protected]> Co-authored-by: Drashna Jaelre <[email protected]>	2020-02-07 19:32:14 -08:00
James Young	b62829031d	[Keyboard] YMDK NP21: matrix and keymap refactor (#8112 ) * YMDK NP21: matrix and keymap refactor - refactored layout macros - LAYOUT_ortho_6x4 orients the keyboard with the USB port to the back instead of to the right - LAYOUT uses the previous sideways orientation (included for backwards compatibility) - removed redundant includes from ymdk_np21.h - added a readme for the default keymap * add Configurator layout support	2020-02-07 19:15:35 -08:00
Mehmet Denizhan Erdem	43c0a9293e	[Keymap] Added keymap for keebio/nyquist (#8108 ) * my custom keymap for nyquist rev3 * Formatted keymap and added readme	2020-02-07 19:07:04 -08:00
Joel Challis	4962b743d2	[Keyboard] Port SPLIT_USB_DETECT to lily58 (#8107 ) * remove unused files * Port SPLIT_USB_DETECT to lily58	2020-02-07 19:03:51 -08:00
Max Rumpf	ea2fcb5b08	[Keymap] Phoebe/Maxr1998 keymap: enable space cadet with curly braces (#8096 ) * Phoebe/Maxr1998 keymap: enable space cadet with curly braces * Revert space cadet for left shift, open curly brace on right shift	2020-02-07 18:54:41 -08:00
Yasuhiro SHIMIZU	fd2ac4b4d5	[Keymap] add lily58 yshrsmz keymap (#8095 ) * add lily58 yshrsmz keymap * apply requested changes * remove more backslashes * remove more backslashes * update rules.mk	2020-02-07 18:53:53 -08:00
esinlayo	7182e9a8ad	[Keyboard] Remove i2c write command when reading columns on Ergodox EZ (#8092 ) * Remove i2c write command when reading cols on Ergodox EZ * Comment on mcp23018 address state during read_cols	2020-02-07 18:52:02 -08:00
fauxpark	3b1f29a5d6	[Keyboard] Misc tidyups for Chidori (#8091 )	2020-02-07 18:50:42 -08:00
Alfred Maler	707c04b4ab	[Keymap] Add users/alfrdmalr and switch to layouts (#8030 ) * WIP do not merge * first pass at custom preonic layout * add auto shift and reset via leader key * Update readme * update copyright notice * formatting changes * fix: use MO instead of process_record_user * added backslash and moved grave position * remove extraneous 'j' characer in NUMPAD template * update template formatting * remove process_record_user * swap "!" with "@" * fix readme formatting * update readme layout image * restore settings layer * add windows minimize sequence * fix: switch to correct seq function for three-key sequence * fix: missing semicolon * refactor: move keymap to userspace and generic 5x12 layout * add numlock to numpad layer * add readme * update readme formatting * remove unused wrappers from layout keymap * update readme title to reflect new location * remove alfrdmalr directory from preonic/keymaps * clean up user config	2020-02-07 18:42:04 -08:00
James Young	be05de6a3d	XD84: Configurator bugfix for ISO layout (#8117 ) * switch to debug linting * move ISO Enter to its proper location	2020-02-07 18:16:44 -08:00
James Young	889eb51fb5	ZJ68: complete Configurator layout support (#8116 ) Only LAYOUT_all had its layout data present; the data for LAYOUT_65_ansi and LAYOUT_65_ansi_split_bs was missing.	2020-02-07 18:09:55 -08:00
Cody Benderandskullydazed	e77188458f	Add QMK Compile Context Sensitivity (#6884 ) * Add context sensitive compile, without config check * Initial full working state. Plan to refactor * Refactor loop for simplicity, add comments * Update docs/cli.md with qmk compile examples * Simplify path for keyboard derivation * Update path to use path.join instead of concat * Refactor keyboard path, the skully way * Add in keymap folder support * Add /layouts compile support * Update docs/cli.md with empty compile in layouts * Add comments to compile.py * Update docs for clarity, and fix compile error typo * Fix config option compile * Fix layout compile and failure mode * Add rules.mk check * Fix variable names for global config * Add in_layout priority * Remove default fallback in favor of throw, update docs * Add keymap folder context * Fix formatting * Add os import * Convert to create_make_command * Fix Travis lint errors * Remove blank line with whitespace * Add blank lines for readability * Remove unnecessary config logic * Update Docs to add flash Co-Authored-By: skullydazed <[email protected]> * Shift config precedence to MILC Co-authored-by: skullydazed <[email protected]>	2020-02-07 21:48:37 +01:00
Joel Challis	774cbbf879	Refactor ergo42 to use split_common (#7925 ) * Initial refactor of ergo42 to split common * Prevent fallthrough for DIODE_DIRECTION	2020-02-07 13:59:18 +00:00
Joel Challis	c93093569e	Refactor mint60 to use split_common (#8084 )	2020-02-07 13:58:55 +00:00
Marius Rugan	fb6f581157	jj4x4: README update (#7854 ) * Updates README jj4x4 * Update keyboards/jj4x4/README.md * Update keyboards/jj4x4/README.md * Update keyboards/jj4x4/README.md * Update keyboards/jj4x4/README.md * Update keyboards/jj4x4/README.md	2020-02-07 02:13:53 -08:00
worldspawn00	e43d143ab0	[Keyboard] adding keyboard: tkl30 (#7979 ) * tkl30 * Amended with collaborator suggestions * s/DEBOUNCING_DELAY/DEBOUNCE/ * Used noroadsleft's PID suggestion * Committed noroadsleft's keymap formatting and rules.mk suggestions * LAYOUT formatting and readme suggestions	2020-02-06 21:28:08 -08:00
fauxpark	a73c38112d	Move Grave Escape, Lock and Leader keycodes into their own sect… (#8093 )	2020-02-07 15:54:14 +11:00
ridingqwerty	e3444084fb	Committing fix to info.json for wsk/jerkin (#8110 )	2020-02-06 21:58:16 -05:00
zvecr	75d4ff7d51	Prevent fallthrough for DIODE_DIRECTION	2020-01-17 18:55:24 +00:00
zvecr	952e805edb	Initial refactor of ergo42 to split common	2020-01-17 18:50:58 +00:00
		`@@ -0,0 +1 @@`
							`# The default_2u_arrow keymap for Boardwalk`
		`@@ -0,0 +1 @@`
							`# The default_625u_arrow keymap for Boardwalk`
		`@@ -0,0 +1 @@`
							`# The default_ortho_7u keymap for Boardwalk`
		`@@ -0,0 +1 @@`
							`# The default_ortho_hhkb keymap for Boardwalk`
		`@@ -0,0 +1 @@`
							[["KC_ESC", "KC_1", "KC_2", "KC_3", "KC_4", "KC_5", "KC_6", "KC_EQL", "KC_7", "KC_8", "KC_9", "KC_0", "KC_MINS", "KC_BSPC", "KC_TAB", "KC_Q", "KC_W", "KC_E", "KC_R", "KC_T", "KC_PGUP", "KC_LBRC", "KC_Y", "KC_U", "KC_I", "KC_O", "KC_P", "KC_ENT", "LCA_T(KC_CAPS)", "KC_A", "KC_S", "KC_D", "KC_F", "KC_G", "KC_PGDN", "KC_RBRC", "KC_H", "KC_J", "KC_K", "KC_L", "KC_SCLN", "KC_QUOT", "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_LCTL", "KC_LGUI", "KC_LALT", "MO(1)", "KC_GRV", "KC_SPC", "LT(1,KC_DEL)", "KC_HOME", "KC_END", "KC_BSLS", "KC_LEFT", "KC_RGHT", "KC_DOWN", "KC_UP"], ["KC_TRNS", "KC_F1", "KC_F2", "KC_F3", "KC_F4", "KC_F5", "KC_F6", "KC_F12", "KC_F7", "KC_F8", "KC_F9", "KC_F10", "KC_F11", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_PSCR", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "KC_TRNS", "LSFT(KC_HOME)", "LSFT(KC_END)", "KC_TRNS", "LALT(LSFT(KC_LEFT))", "LALT(LSFT(KC_RIGHT))", "LALT(LSFT(KC_DOWN))", "LALT(LSFT(KC_UP))"]]
		`@@ -0,0 +1,3 @@`
							`#pragma once`

							`#define RSPC_KEYS KC_RSFT, KC_RALT, KC_7`