Unicode fix for new wincompose version (#5082)

* unicode fix for new wincompose version

* move wincompose case to linux

* Change unicode input end to enter

Makefile

@@ -536,9 +536,9 @@ endef
 	cmp $(ROOT_DIR)/Makefile $(ROOT_DIR)/Makefile >/dev/null 2>&1; if [ $$? -gt 0 ]; then printf "$(MSG_NO_CMP)"; exit 1; fi;
 	# Check if the submodules are dirty, and display a warning if they are
 ifndef SKIP_GIT
-	if [ ! -e lib/chibios ]; then git submodule sync lib/chibios && git submodule update --init lib/chibios; fi
-	if [ ! -e lib/chibios-contrib ]; then git submodule sync lib/chibios-contrib && git submodule update --init lib/chibios-contrib; fi
-	if [ ! -e lib/ugfx ]; then git submodule sync lib/ugfx && git submodule update --init lib/ugfx; fi
+	if [ ! -e lib/chibios ]; then git submodule sync lib/chibios && git submodule update --depth 1 --init lib/chibios; fi
+	if [ ! -e lib/chibios-contrib ]; then git submodule sync lib/chibios-contrib && git submodule update --depth 1 --init lib/chibios-contrib; fi
+	if [ ! -e lib/ugfx ]; then git submodule sync lib/ugfx && git submodule update --depth 1 --init lib/ugfx; fi
 	git submodule status --recursive 2>/dev/null | \
 	while IFS= read -r x; do \
 		case "$$x" in \

common_features.mk

@@ -298,34 +298,26 @@ ifneq ($(strip $(CUSTOM_MATRIX)), yes)
 endif
 
 DEBOUNCE_DIR:= $(QUANTUM_DIR)/debounce
-# Debounce Modules. If implemented in matrix.c, don't use these.
+# Debounce Modules. Set DEBOUNCE_TYPE=custom if including one manually.
 DEBOUNCE_TYPE?= sym_g
-VALID_DEBOUNCE_TYPES := sym_g eager_pk custom
-ifeq ($(filter $(DEBOUNCE_TYPE),$(VALID_DEBOUNCE_TYPES)),)
-    $(error DEBOUNCE_TYPE="$(DEBOUNCE_TYPE)" is not a valid debounce algorithm)
+ifneq ($(strip $(DEBOUNCE_TYPE)), custom)
+    QUANTUM_SRC += $(DEBOUNCE_DIR)/$(strip $(DEBOUNCE_TYPE)).c
 endif
-ifeq ($(strip $(DEBOUNCE_TYPE)), sym_g)
-    QUANTUM_SRC += $(DEBOUNCE_DIR)/debounce_sym_g.c
-else ifeq ($(strip $(DEBOUNCE_TYPE)), eager_pk)
-    QUANTUM_SRC += $(DEBOUNCE_DIR)/debounce_eager_pk.c
-endif
-
-
 
 ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
     OPT_DEFS += -DSPLIT_KEYBOARD
 
     # Include files used by all split keyboards
-    QUANTUM_SRC += $(QUANTUM_DIR)/split_common/split_flags.c \
-                   $(QUANTUM_DIR)/split_common/split_util.c
+    QUANTUM_SRC += $(QUANTUM_DIR)/split_common/split_util.c
 
     # Determine which (if any) transport files are required
     ifneq ($(strip $(SPLIT_TRANSPORT)), custom)
         QUANTUM_SRC += $(QUANTUM_DIR)/split_common/transport.c
         # Functions added via QUANTUM_LIB_SRC are only included in the final binary if they're called.
-        # Unused functions are pruned away, which is why we can add both drivers here without bloat.
-        QUANTUM_LIB_SRC += $(QUANTUM_DIR)/split_common/i2c.c \
-                           $(QUANTUM_DIR)/split_common/serial.c
+        # Unused functions are pruned away, which is why we can add multiple drivers here without bloat.
+        QUANTUM_LIB_SRC += $(QUANTUM_DIR)/split_common/serial.c \
+                           i2c_master.c \
+                           i2c_slave.c
     endif
     COMMON_VPATH += $(QUANTUM_PATH)/split_common
 endif

docs/_summary.md

@@ -60,6 +60,7 @@
   * [Key Lock](feature_key_lock.md)
   * [Layouts](feature_layouts.md)
   * [Leader Key](feature_leader_key.md)
+  * [LED Matrix](feature_led_matrix.md)
   * [Macros](feature_macros.md)
   * [Mouse Keys](feature_mouse_keys.md)
   * [One Shot Keys](feature_advanced_keycodes.md#one-shot-keys)
@@ -91,7 +92,8 @@
   * [Understanding QMK](understanding_qmk.md)
 
 * Other Topics
-  * [Using Eclipse with QMK](eclipse.md)
+  * [Using Eclipse with QMK](other_eclipse.md)
+  * [Using VSCode with QMK](other_vscode.md)
   * [Support](support.md)
 
 * QMK Internals (In Progress)

docs/config_options.md

@@ -208,9 +208,13 @@ There are a few different ways to set handedness for split keyboards (listed in
 
 1. Set `SPLIT_HAND_PIN`: Reads a pin to determine handedness. If pin is high, it's the left side, if low, the half is determined to be the right side
 2. Set `EE_HANDS` and flash `eeprom-lefthand.eep`/`eeprom-righthand.eep` to each half
+   * For boards with DFU bootloader you can use `:dfu-split-left`/`:dfu-split-right` to flash these EEPROM files
+   * For boards with Caterina bootloader (like stock Pro Micros), use `:avrdude-split-left`/`:avrdude-split-right`
 3. Set `MASTER_RIGHT`: Half that is plugged into the USB port is determined to be the master and right half (inverse of the default)
 4. Default: The side that is plugged into the USB port is the master half and is assumed to be the left half. The slave side is the right half
 
+#### Defines for handedness
+
 * `#define SPLIT_HAND_PIN B7`
   * For using high/low pin to determine handedness, low = right hand, high = left hand. Replace `B7` with the pin you are using. This is optional, and if you leave `SPLIT_HAND_PIN` undefined, then you can still use the EE_HANDS method or MASTER_LEFT / MASTER_RIGHT defines like the stock Let's Split uses.
 
@@ -307,8 +311,8 @@ Use these to enable or disable building certain features. The more you have enab
   * Enables split keyboard support (dual MCU like the let's split and bakingpy's boards) and includes all necessary files located at quantum/split_common
 * `CUSTOM_MATRIX`
   * Allows replacing the standard matrix scanning routine with a custom one.
-* `CUSTOM_DEBOUNCE`
-  * Allows replacing the standard key debouncing routine with a custom one.
+* `DEBOUNCE_TYPE`
+  * Allows replacing the standard key debouncing routine with an alternative or custom one.
 * `WAIT_FOR_USB`
   * Forces the keyboard to wait for a USB connection to be established before it starts up
 * `NO_USB_STARTUP_CHECK`

docs/contributing.md

@@ -129,6 +129,20 @@ Documentation is one of the easiest ways to get started contributing to QMK. Fin
 
 You'll find all our documentation in the `qmk_firmware/docs` directory, or if you'd rather use a web based workflow you can click "Suggest An Edit" at the top of each page on http://docs.qmk.fm/.
 
+When providing code examples in your documentation, try to observe naming conventions used elsewhere in the docs. For example, standardizing enums as `my_layers` or `my_keycodes` for consistency:
+
+```c
+enum my_layers {
+  _FIRST_LAYER,
+  _SECOND_LAYER
+};
+
+enum my_keycodes {
+  FIRST_LAYER = SAFE_RANGE,
+  SECOND_LAYER
+};
+```
+
 ## Keymaps
 
 Most first-time QMK contributors start with their personal keymaps. We try to keep keymap standards pretty casual (keymaps, after all, reflect the personality of their creators) but we do ask that you follow these guidelines to make it easier for others to discover and learn from your keymap.
@@ -137,7 +151,7 @@ Most first-time QMK contributors start with their personal keymaps. We try to ke
 * All Keymap PR's are squashed, so if you care about how your commits are squashed you should do it yourself
 * Do not lump features in with keymap PR's. Submit the feature first and then a second PR for the keymap.
 * Do not include `Makefile`s in your keymap folder (they're no longer used)
-* Update copyrights in file headers (look for `REPLACE_WITH_YOUR_NAME `)
+* Update copyrights in file headers (look for `%YOUR_NAME%`)
 
 ## Keyboards
 
@@ -150,7 +164,7 @@ We also ask that you follow these guidelines:
 * Do not lump core features in with new keyboards. Submit the feature first and then submit a separate PR for the keyboard.
 * Name `.c`/`.h` file after the immediate parent folder, eg `/keyboards/<kb1>/<kb2>/<kb2>.[ch]`
 * Do not include `Makefile`s in your keyboard folder (they're no longer used)
-* Update copyrights in file headers (look for `REPLACE_WITH_YOUR_NAME `)
+* Update copyrights in file headers (look for `%YOUR_NAME%`)
 
 ## Quantum/TMK Core
 

docs/custom_quantum_functions.md

@@ -321,7 +321,7 @@ uint32_t layer_state_set_user(uint32_t state) {
 ```
 ### `layer_state_set_*` Function Documentation
 
-* Keyboard/Revision: `void uint32_t layer_state_set_kb(uint32_t state)`
+* Keyboard/Revision: `uint32_t layer_state_set_kb(uint32_t state)`
 * Keymap: `uint32_t layer_state_set_user(uint32_t state)`
 
 The `state` is the bitmask of the active layers, as explained in the [Keymap Overview](keymap.md#keymap-layer-status)

docs/feature_advanced_keycodes.md

@@ -15,7 +15,7 @@ This will allow you to use `FN_CAPS` and `ALT_TAB` in your keymap, keeping it mo
 
 ## Caveats
 
-Currently, `LT()` and `MT()` are limited to the [Basic Keycode set](keycodes_basic.md), meaning you can't use keycodes like `LCTL()`, `KC_TILD`, or anything greater than `0xFF`. Modifiers specified as part of a Layer Tap or Mod Tap's keycode will be ignored.
+Currently, `LT()` and `MT()` are limited to the [Basic Keycode set](keycodes_basic.md), meaning you can't use keycodes like `LCTL()`, `KC_TILD`, or anything greater than `0xFF`. Modifiers specified as part of a Layer Tap or Mod Tap's keycode will be ignored. If you need to apply modifiers to your tapped keycode, [Tap Dance](https://github.com/qmk/qmk_firmware/blob/master/docs/feature_tap_dance.md#example-5-using-tap-dance-for-advanced-mod-tap-and-layer-tap-keys) can be used to accomplish this.
 
 Additionally, if at least one right-handed modifier is specified in a Mod Tap or Layer Tap, it will cause all modifiers specified to become right-handed, so it is not possible to mix and match the two.
 

docs/feature_debounce_type.md

@@ -2,45 +2,38 @@
 
 QMK supports multiple debounce algorithms through its debounce API.
 
-The underlying debounce algorithm is determined by which matrix.c file you are using.
-
 The logic for which debounce method called is below. It checks various defines that you have set in rules.mk
 
 ```
+DEBOUNCE_DIR:= $(QUANTUM_DIR)/debounce
 DEBOUNCE_TYPE?= sym_g
-VALID_DEBOUNCE_TYPES := sym_g eager_pk custom
-ifeq ($(filter $(DEBOUNCE_TYPE),$(VALID_DEBOUNCE_TYPES)),)
-    $(error DEBOUNCE_TYPE="$(DEBOUNCE_TYPE)" is not a valid debounce algorithm)
-endif
-ifeq ($(strip $(DEBOUNCE_TYPE)), sym_g)
-    QUANTUM_SRC += $(DEBOUNCE_DIR)/debounce_sym_g.c
-else ifeq ($(strip $(DEBOUNCE_TYPE)), eager_pk)
-    QUANTUM_SRC += $(DEBOUNCE_DIR)/debounce_eager_pk.c
+ifneq ($(strip $(DEBOUNCE_TYPE)), custom)
+    QUANTUM_SRC += $(DEBOUNCE_DIR)/$(strip $(DEBOUNCE_TYPE)).c
 endif
 ```
 
 # Debounce selection
 
-| DEBOUNCE_ALGO    | Description                                                 | What to do                    |
-| -------------    | ---------------------------------------------------         | ----------------------------- |
-| Not defined      | You are using the included matrix.c and debounce.c          | Nothing. Debounce_sym_g will be compiled, and used if necessary |
-| custom           | Use your own debounce.c                                     | ```SRC += debounce.c``` add your own debounce.c and implement necessary functions |
-| sym_g / eager_pk | You are using the included matrix.c and debounce.c          | Use an alternative debounce algorithm |
+| DEBOUNCE_TYPE    | Description                                          | What else is needed           |
+| -------------    | ---------------------------------------------------  | ----------------------------- |
+| Not defined      | Use the default algorithm, currently sym_g           | Nothing                       |
+| custom           | Use your own debounce.c                              | ```SRC += debounce.c``` add your own debounce.c and implement necessary functions |
+| anything_else    | Use another algorithm from quantum/debounce/*        | Nothing                       |
 
-**Regarding split keyboards**: 
+**Regarding split keyboards**:
 The debounce code is compatible with split keyboards.
 
 # Use your own debouncing code
 * Set ```DEBOUNCE_TYPE = custom ```.
 * Add ```SRC += debounce.c```
-* Add your own ```debounce.c```. Look at included ```debounce_sym_g.c```s for sample implementations.
+* Add your own ```debounce.c```. Look at current implementations in ```quantum/debounce``` for examples.
 * Debouncing occurs after every raw matrix scan.
 * Use num_rows rather than MATRIX_ROWS, so that split keyboards are supported correctly.
 
 # Changing between included debouncing methods
 You can either use your own code, by including your own debounce.c, or switch to another included one.
 Included debounce methods are:
-* debounce_eager_pk - debouncing per key. On any state change, response is immediate, followed by ```DEBOUNCE_DELAY``` millseconds of no further input for that key
-* debounce_sym_g - debouncing per keyboard. On any state change, a global timer is set. When ```DEBOUNCE_DELAY``` milliseconds of no changes has occured, all input changes are pushed.
+* eager_pk - debouncing per key. On any state change, response is immediate, followed by ```DEBOUNCE_DELAY``` millseconds of no further input for that key
+* sym_g - debouncing per keyboard. On any state change, a global timer is set. When ```DEBOUNCE_DELAY``` milliseconds of no changes has occured, all input changes are pushed.
 
 

docs/feature_tap_dance.md

@@ -314,3 +314,86 @@ qk_tap_dance_action_t tap_dance_actions[] = {
 And then simply use `TD(X_CTL)` anywhere in your keymap.
 
 If you want to implement this in your userspace, then you may want to check out how [DanielGGordon](https://github.com/qmk/qmk_firmware/tree/master/users/gordon) has implemented this in their userspace.
+
+### Example 5: Using tap dance for advanced mod-tap and layer-tap keys
+
+Tap dance can be used to emulate `MT()` and `LT()` behavior when the tapped code is not a basic keycode. This is useful to send tapped keycodes that normally require `Shift`, such as parentheses or curly braces—or other modified keycodes, such as `Control + X`.
+
+Below your layers and custom keycodes, add the following:
+
+```c
+// tapdance keycodes
+enum td_keycodes {
+  ALT_LP // Our example key: `LALT` when held, `(` when tapped. Add additional keycodes for each tapdance.
+};
+
+// define a type containing as many tapdance states as you need
+typedef enum {
+  SINGLE_TAP,
+  SINGLE_HOLD,
+  DOUBLE_SINGLE_TAP
+} td_state_t;
+
+// create a global instance of the tapdance state type
+static td_state_t td_state;
+
+// declare your tapdance functions:
+
+// function to determine the current tapdance state
+int cur_dance (qk_tap_dance_state_t *state);
+
+// `finished` and `reset` functions for each tapdance keycode
+void altlp_finished (qk_tap_dance_state_t *state, void *user_data);
+void altlp_reset (qk_tap_dance_state_t *state, void *user_data);
+```
+
+Below your `LAYOUT`, define each of the tapdance functions:
+
+```c
+// determine the tapdance state to return
+int cur_dance (qk_tap_dance_state_t *state) {
+  if (state->count == 1) {
+    if (state->interrupted || !state->pressed) { return SINGLE_TAP; }
+    else { return SINGLE_HOLD; }
+  }
+  if (state->count == 2) { return DOUBLE_SINGLE_TAP; }
+  else { return 3; } // any number higher than the maximum state value you return above
+}
+ 
+// handle the possible states for each tapdance keycode you define:
+
+void altlp_finished (qk_tap_dance_state_t *state, void *user_data) {
+  td_state = cur_dance(state);
+  switch (td_state) {
+    case SINGLE_TAP:
+      register_code16(KC_LPRN);
+      break;
+    case SINGLE_HOLD:
+      register_mods(MOD_BIT(KC_LALT)); // for a layer-tap key, use `layer_on(_MY_LAYER)` here
+      break;
+    case DOUBLE_SINGLE_TAP: // allow nesting of 2 parens `((` within tapping term
+      tap_code16(KC_LPRN);
+      register_code16(KC_LPRN);
+  }
+}
+
+void altlp_reset (qk_tap_dance_state_t *state, void *user_data) {
+  switch (td_state) {
+    case SINGLE_TAP:
+      unregister_code16(KC_LPRN);
+      break;
+    case SINGLE_HOLD:
+      unregister_mods(MOD_BIT(KC_LALT)); // for a layer-tap key, use `layer_off(_MY_LAYER)` here
+      break;
+    case DOUBLE_SINGLE_TAP:
+      unregister_code16(KC_LPRN);
+  }
+}
+
+// define `ACTION_TAP_DANCE_FN_ADVANCED()` for each tapdance keycode, passing in `finished` and `reset` functions
+qk_tap_dance_action_t tap_dance_actions[] = {
+  [ALT_LP] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, altlp_finished, altlp_reset)
+};
+```
+
+Wrap each tapdance keycode in `TD()` when including it in your keymap, e.g. `TD(ALT_LP)`.

docs/feature_unicode.md

@@ -65,6 +65,8 @@ The following input modes are available:
   To enable, go to _System Preferences > Keyboard > Input Sources_, add _Unicode Hex Input_ to the list (it's under _Other_), then activate it from the input dropdown in the Menu Bar.
   By default, this mode uses the left Option key (`KC_LALT`), but this can be changed by defining [`UNICODE_OSX_KEY`](#input-key-configuration) with another keycode.
 
+  **Note:** Using the _Unicode Hex Input_ input source may disable some Option based shortcuts, such as: Option + Left Arrow (`moveWordLeftAndModifySelection`) and Option + Right Arrow  (`moveWordRightAndModifySelection`).
+
 * **`UC_LNX`**: Linux built-in IBus Unicode input. Supports code points up to `0x10FFFF` (all possible code points).
 
   Enabled by default and works almost anywhere on IBus-enabled distros. Without IBus, this mode works under GTK apps, but rarely anywhere else.
@@ -121,7 +123,7 @@ For instance, you can add these definitions to your `config.h` file:
 
 ### Additional Customization
 
-Because Unicode is such a large and variable feature, there are a number of options that you can customize to work better on your system. 
+Because Unicode is such a large and variable feature, there are a number of options that you can customize to work better on your system.
 
 #### Start and Finish input functions
 
@@ -183,7 +185,7 @@ AutoHotkey inserts the Text right of `Send, ` when this combination is pressed.
 
 ### US International
 
-If you enable the US International layout on the system, it will use punctuation to accent the characters. 
+If you enable the US International layout on the system, it will use punctuation to accent the characters.
 
 For instance, typing "`a" will result in à.
 

docs/feature_userspace.md

@@ -201,27 +201,51 @@ bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
 
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
-  case KC_MAKE:
-    if (!record->event.pressed) {
-      SEND_STRING("make " QMK_KEYBOARD ":" QMK_KEYMAP
-#if  (defined(BOOTLOADER_DFU) || defined(BOOTLOADER_LUFA_DFU) || defined(BOOTLOADER_QMK_DFU))
-       ":dfu "
-#elif defined(BOOTLOADER_HALFKAY)
-      ":teensy "
-#elif defined(BOOTLOADER_CATERINA)
-       ":avrdude "
-#endif
-        SS_TAP(X_ENTER));
-    }
-    return false;
-    break;
+    case KC_MAKE:  // Compiles the firmware, and adds the flash command based on keyboard bootloader
+            if (!record->event.pressed) {
+            uint8_t temp_mod = get_mods();
+            uint8_t temp_osm = get_oneshot_mods();
+            clear_mods(); clear_oneshot_mods();
+            SEND_STRING("make " QMK_KEYBOARD ":" QMK_KEYMAP);
+    #ifndef FLASH_BOOTLOADER
+            if ( (temp_mod | temp_osm) & MOD_MASK_SHIFT ) 
+    #endif
+            { // 
+                #if defined(__arm__)  // only run for ARM boards
+                    SEND_STRING(":dfu-util");
+                #elif defined(BOOTLOADER_DFU) // only run for DFU boards
+                    SEND_STRING(":dfu");
+                #elif defined(BOOTLOADER_HALFKAY) // only run for teensy boards
+                    SEND_STRING(":teensy");
+                #elif defined(BOOTLOADER_CATERINA) // only run for Pro Micros
+                    SEND_STRING(":avrdude");
+                #endif // bootloader options
+            }
+            if ( (temp_mod | temp_osm) & MOD_MASK_CTRL) { 
+                SEND_STRING(" -j8 --output-sync"); 
+            }
+            SEND_STRING(SS_TAP(X_ENTER));
+            set_mods(temp_mod);
+        }
+        break;
+
   }
   return process_record_keymap(keycode, record);
 }
 ```
 
+For boards that may not have a shift button (such as on a macro pad), we need a way to always include the bootloader option.  To do that, add the following to the `rules.mk` in your userspace folder: 
+
+```make 
+ifeq ($(strip $(FLASH_BOOTLOADER)), yes)
+    OPT_DEFS += -DFLASH_BOOTLOADER
+endif
+```
+
 This will add a new `KC_MAKE` keycode that can be used in any of your keymaps.  And this keycode will output `make <keyboard>:<keymap>`, making frequent compiling easier.  And this will work with any keyboard and any keymap as it will output the current boards info, so that you don't have to type this out every time.
 
-Additionally, this should flash the newly compiled firmware automatically, using the correct utility, based on the bootloader settings (or default to just generating the HEX file). However, it should be noted that this may not work on all systems. AVRDUDE doesn't work on WSL, namely (and will dump the HEX in the ".build" folder instead).
+Also, holding `shift` will add the appropriate flashing command (`:dfu`, `:teensy`, `:avrdude`, `:dfu-util`) for a majority of keyboards.  Holding `control` will add some commands that will speed up compiling time by processing multiple files at once. 
 
+And for the boards that lack a shift key, or that you want to always attempt the flashing part, you can add `FLASH_BOOTLOADER = yes` to the `rules.mk` of that keymap.
 
+?> This should flash the newly compiled firmware automatically, using the correct utility, based on the bootloader settings (or default to just generating the HEX file). However, it should be noted that this may not work on all systems. AVRDUDE doesn't work on WSL, namely. And this doesn't support BootloadHID or mdloader. 

docs/features.md

@@ -17,6 +17,7 @@ QMK has a staggering number of features for building your keyboard. It can take
 * [Key Lock](feature_key_lock.md) - Lock a key in the "down" state.
 * [Layouts](feature_layouts.md) - Use one keymap with any keyboard that supports your layout.
 * [Leader Key](feature_leader_key.md) - Tap the leader key followed by a sequence to trigger custom behavior.
+* [LED Matrix](feature_led_matrix.md) - LED Matrix single color lights for per key lighting (Single Color, not RGB).
 * [Macros](feature_macros.md) - Send multiple key presses when pressing only one physical key.
 * [Mouse keys](feature_mouse_keys.md) - Control your mouse pointer from your keyboard.
 * [One Shot Keys](feature_advanced_keycodes.md#one-shot-keys) - Sticky Keys, lets hit a key rather than holding it.

docs/getting_started_build_tools.md

@@ -44,9 +44,7 @@ Fedora / Red Hat example:
     
 Arch / Manjaro example:
 
-    pacman -S base-devel gcc unzip wget zip avr-gcc avr-binutils avr-libc dfu-util arm-none-eabi-gcc arm-none-eabi-binutils arm-none-eabi-newlib git
-
-(the `dfu-programmer` package is availble on AUR only so you should download from there or use an AUR helper)
+    pacman -S base-devel gcc unzip wget zip avr-gcc avr-binutils avr-libc dfu-util arm-none-eabi-gcc arm-none-eabi-binutils arm-none-eabi-newlib git dfu-programmer dfu-util
 
 ## Nix
 

docs/getting_started_make_guide.md

@@ -143,9 +143,9 @@ As there is no standard split communication driver for ARM-based split keyboards
 
 Lets you replace the default matrix scanning routine with your own code. You will need to provide your own implementations of matrix_init() and matrix_scan().
 
-`CUSTOM_DEBOUNCE`
+`DEBOUNCE_TYPE`
 
-Lets you replace the default key debouncing routine with your own code. You will need to provide your own implementation of debounce().
+Lets you replace the default key debouncing routine with an alternative one. If `custom` you will need to provide your own implementation.
 
 ## Customizing Makefile Options on a Per-Keymap Basis
 

docs/hand_wire.md

@@ -196,7 +196,7 @@ If you're more of a visual learner, or want some additional tips and something m
 
 From here, you should have a working keyboard once you program a firmware. Before we attach the Teensy permanently to the keyboard, let's quickly get some firmware loaded onto the Teensy so we can test each keyswitch.
 
-To start out, download [the firmware](https://github.com/qmk/qmk_firmware/) - we'll be using my (Jack's) fork of TMK called QMK/Quantum. We'll be doing a lot from the Terminal/command prompt, so get that open, along with a decent text editor like [Sublime Text](http://www.sublimetext.com/).
+To start out, download [the firmware](https://github.com/qmk/qmk_firmware/) - we'll be using my (Jack's) fork of TMK called QMK/Quantum. We'll be doing a lot from the Terminal/command prompt, so get that open, along with a decent text editor like [Sublime Text](http://www.sublimetext.com/) (paid) or [Visual Studio Code](https://code.visualstudio.com) (free).
 
 The first thing we're going to do is create a new project using the script in the root directory of the firmware. In your terminal, run this command with `<project_name>` replaced by the name of your project - it'll need to be different from any other project in the `keyboards/` folder:
 

docs/how_keyboards_work.md

@@ -12,7 +12,7 @@ place:
 ``` text
 +------+         +-----+       +----------+      +----------+     +----+
 | User |-------->| Key |------>| Firmware |----->| USB wire |---->| OS |
-+------+         +-----+       +----------+      +----------+     |----+
++------+         +-----+       +----------+      +----------+     +----+
 ```
 
 This scheme is a very simple view of what's going on, and more details follow

docs/i2c_driver.md

@@ -12,7 +12,7 @@ The I2C Master drivers used in QMK have a set of common functions to allow porta
 |`uint8_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);`                         |Receive data over I2C. Address is the 7-bit slave address without the direction. Saves number of bytes specified by `length` in `data` array. Returns status of transaction. |
 |`uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);`       |Same as the `i2c_transmit` function but `regaddr` sets where in the slave the data will be written.                                                                          |
 |`uint8_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);`        |Same as the `i2c_receive` function but `regaddr` sets from where in the slave the data will be read.                                                                         |
-|`uint8_t i2c_stop(uint16_t timeout);`                                                                             |Stops the I2C driver.                                                                                                                                                        |
+|`uint8_t i2c_stop(void);`                                                                                         |Ends an I2C transaction.                                                                                                                                                     |
 
 ### Function Return
 

docs/other_vscode.md

@@ -0,0 +1,117 @@
+# Setting up Visual Studio Code for QMK Development
+
+[Visual Studio Code](https://code.visualstudio.com/) (VS Code) is an open-source code editor that supports many different programming languages. 
+
+Using a full-featured editor such as VS Code provides many advantages over a plain text editor, such as:
+* intelligent code completion
+* convenient navigation in the code
+* refactoring tools
+* build automation (no need for the command-line)
+* a graphical front end for GIT
+* many other tools such as debugging, code formatting, showing call hierarchies etc.
+
+The purpose of this page is to document how to set up VS Code for developing QMK Firmware.
+
+This guide covers how to configure everything needed on Windows and Ubuntu 18.04
+
+# Set up VS Code
+Before starting, you will want to make sure that you have all of the build tools set up, and QMK Firmware cloned. Head to the the [Newbs Getting Started Guide](newbs_getting_started.md) to get things set up, if you haven't already.
+
+## Windows
+
+### Prerequisites
+
+* [Git for Windows](https://git-scm.com/download/win) (This link will prompt to save/run the installer)
+  
+  1. Disable all of the options but `Git LFS (Large File Support)` and `Check daily for Git for Windows updates`. 
+  2. Set the default editor to `Use Visual Studio Code as Git's default editor`
+  3. Select the `Use Git from Git Bash only` option, since that's the option that you should use here.
+  4. For the `Choosing HTTPS transport backend`, either option should be fine.
+  5. Select the `Checkout as-is, commit Unix-style line endings` option. QMK Firmware uses Unix style commits.
+  6. For the extra options, leave the default options as is. 
+
+  This software is needed for Git support in VS Code. It may be possible to not include this, but it is much simpler to just use this. 
+
+* [Git Credential Manager for Windows](https://github.com/Microsoft/Git-Credential-Manager-for-Windows/releases) (Optional) 
+
+  This software provides better support for Git by providing secure storage for git credentials, MFA and personal access token generation. 
+  
+  This isn't strictly needed, but we would recommend it. 
+
+
+### Installing VS Code
+
+1. Head to [VS Code](https://code.visualstudio.com/) and download the installer
+2. Run the installer
+
+This part is super simple.  However, there is some configuration that we need to do to ensure things are configured correctly.
+
+### Configuring VS Code
+
+First, we need to set up IntelliSense. This isn't strictly required, but it will make your life a LOT easier. To do this, we need to create the `.vscode/c_cpp_properies.json` file in the QMK Firmware folder, You can do this all manually, but I've done most of the work already. 
+
+Grab [this file](https://gist.github.com/drashna/48e2c49ce877be592a1650f91f8473e8) and save it.  You may need to edit this file, if you didn't install MSYS2 to the default location, or are using WSL/LxSS.  
+
+Once you have saved this file, you will need to reload VS Code, if it was already running. 
+
+?> You should see an `extensions.json` and `settings.json` file in the `.vscode` folder, as well.
+
+
+Now, we will set up the MSYS2 window to show up in VSCode as the integrated terminal.  This has a number of advantages. Mostly, you can control+click on errors and jump to those files.  This makes debugging much easier.  It's also nice, in that you don't have to jump to another window. 
+
+1. Click <kbd><kbd>File</kbd> > <kbd>Preferences ></kbd> > <kbd>Settings</kbd> </kbd>
+2. Click on the <kbd>{}</kbd> button, in the top right to open the `settings.json` file. 
+3. Set the file's content to: 
+
+   ```json
+   {
+        "terminal.integrated.shell.windows": "C:\\msys64\\usr\\bin\\bash.exe",
+        "terminal.integrated.env.windows": {
+            "MSYSTEM": "MINGW64",
+            "CHERE_INVOKING": "1"
+        },
+        "terminal.integrated.shellArgs.windows": [
+            "--login"
+        ],
+        "terminal.integrated.cursorStyle": "line"
+    }
+    ```
+
+   If there are settings here already, then just add everything between the first and last curly brackets.  
+
+?> If you installed MSYS2 to a different folder, then you'll need to change the path for `terminal.integrated.shell.windows` to the correct path for your system. 
+
+4. Hit Ctrl-` (grave) to bring up the terminal.  
+
+   This should start the terminal in the workspace's folder (so the `qmk_firmware` folder), and then you can compile your keyboard. 
+
+
+## Every other Operating System
+
+1. Head to [VS Code](https://code.visualstudio.com/) and download the installer
+2. Run the installer
+3. That's it
+
+No, really, that's it.  The paths needed are already included when installing the packages, and it is much better about detecting the current workspace files and parsing them for IntelliSense. 
+
+## Plugins
+
+There are a number of extensions that you may want to install:
+
+* [Git Extension Pack](https://marketplace.visualstudio.com/items?itemName=donjayamanne.git-extension-pack) - 
+This installs a bunch of Git related tools that may make using Git with QMK Firmware easier.
+* [EditorConfig for VS Code](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) - _[Optional]_ -  Helps to keep the code to the QMK Coding Conventions.
+* [Bracket Pair Colorizer 2](https://marketplace.visualstudio.com/items?itemName=CoenraadS.bracket-pair-colorizer-2) - _[Optional]_ - This color codes the brackets in your code, to make it easier to reference nested code.
+* [Github Markdown Preview](https://marketplace.visualstudio.com/items?itemName=bierner.github-markdown-preview) - _[Optional]_ - Makes the markdown preview in VS Code more like GitHub's.
+* [VS Live Share Extension Pack](https://marketplace.visualstudio.com/items?itemName=MS-vsliveshare.vsliveshare-pack) - _[Optional]_ - This extension allows somebody else to access your workspace (or you to access somebody else's workspace) and help out.  This is great if you're having issues and need some help from somebody.
+* [VIM Keymap](https://marketplace.visualstudio.com/items?itemName=GiuseppeCesarano.vim-keymap) - _[Optional]_ - For those that prefer VIM style keybindings. There are other options for this, too. 
+* [Travis CI Status](https://marketplace.visualstudio.com/items?itemName=felixrieseberg.vsc-travis-ci-status) - _[Optional]_ - This shows the current Travis CI status, if you have it set up.
+
+Restart once you've installed any extensions
+
+# Configure VS Code for QMK
+1. Click <kbd><kbd>File</kbd> > <kbd>Open Folder</kbd></kbd>
+2. Open the QMK Firmware folder that you cloned from GitHub. 
+3. Click <kbd><kbd>File</kbd> > <kbd>Save Workspace As...</kbd></kbd>
+
+And now you're ready to code QMK Firmware in VS Code

drivers/arm/i2c_master.c

@@ -101,8 +101,7 @@ uint8_t i2c_readReg(uint8_t devaddr, uint8_t* regaddr, uint8_t* data, uint16_t l
   return i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), regaddr, 1, data, length, MS2ST(timeout));
 }
 
-// This is usually not needed. It releases the driver to allow pins to become GPIO again.
-uint8_t i2c_stop(uint16_t timeout)
+uint8_t i2c_stop(void)
 {
   i2cStop(&I2C_DRIVER);
   return 0;

drivers/arm/i2c_master.h

@@ -47,4 +47,4 @@ uint8_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t ti
 uint8_t i2c_transmit_receive(uint8_t address, uint8_t * tx_body, uint16_t tx_length, uint8_t * rx_body, uint16_t rx_length);
 uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
 uint8_t i2c_readReg(uint8_t devaddr, uint8_t* regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
-uint8_t i2c_stop(uint16_t timeout);
+uint8_t i2c_stop(void);

drivers/avr/i2c_master.c

@@ -7,43 +7,44 @@
 
 #include "i2c_master.h"
 #include "timer.h"
+#include "wait.h"
 
 #ifndef F_SCL
-#define F_SCL 400000UL // SCL frequency
+#  define F_SCL 400000UL  // SCL frequency
 #endif
 #define Prescaler 1
-#define TWBR_val ((((F_CPU / F_SCL) / Prescaler) - 16 ) / 2)
+#define TWBR_val ((((F_CPU / F_SCL) / Prescaler) - 16) / 2)
 
-void i2c_init(void)
-{
-  TWSR = 0;     /* no prescaler */
+void i2c_init(void) {
+  TWSR = 0; /* no prescaler */
   TWBR = (uint8_t)TWBR_val;
 }
 
-i2c_status_t i2c_start(uint8_t address, uint16_t timeout)
-{
+i2c_status_t i2c_start(uint8_t address, uint16_t timeout) {
   // reset TWI control register
   TWCR = 0;
   // transmit START condition
-  TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);
+  TWCR = (1 << TWINT) | (1 << TWSTA) | (1 << TWEN);
 
   uint16_t timeout_timer = timer_read();
-  while( !(TWCR & (1<<TWINT)) ) {
+  while (!(TWCR & (1 << TWINT))) {
     if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
       return I2C_STATUS_TIMEOUT;
     }
   }
 
   // check if the start condition was successfully transmitted
-  if(((TW_STATUS & 0xF8) != TW_START) && ((TW_STATUS & 0xF8) != TW_REP_START)){ return I2C_STATUS_ERROR; }
+  if (((TW_STATUS & 0xF8) != TW_START) && ((TW_STATUS & 0xF8) != TW_REP_START)) {
+    return I2C_STATUS_ERROR;
+  }
 
   // load slave address into data register
   TWDR = address;
   // start transmission of address
-  TWCR = (1<<TWINT) | (1<<TWEN);
+  TWCR = (1 << TWINT) | (1 << TWEN);
 
   timeout_timer = timer_read();
-  while( !(TWCR & (1<<TWINT)) ) {
+  while (!(TWCR & (1 << TWINT))) {
     if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
       return I2C_STATUS_TIMEOUT;
     }
@@ -51,38 +52,39 @@ i2c_status_t i2c_start(uint8_t address, uint16_t timeout)
 
   // check if the device has acknowledged the READ / WRITE mode
   uint8_t twst = TW_STATUS & 0xF8;
-  if ( (twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK) ) return I2C_STATUS_ERROR;
+  if ((twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK)) {
+    return I2C_STATUS_ERROR;
+  }
 
   return I2C_STATUS_SUCCESS;
 }
 
-i2c_status_t i2c_write(uint8_t data, uint16_t timeout)
-{
+i2c_status_t i2c_write(uint8_t data, uint16_t timeout) {
   // load data into data register
   TWDR = data;
   // start transmission of data
-  TWCR = (1<<TWINT) | (1<<TWEN);
+  TWCR = (1 << TWINT) | (1 << TWEN);
 
   uint16_t timeout_timer = timer_read();
-  while( !(TWCR & (1<<TWINT)) ) {
+  while (!(TWCR & (1 << TWINT))) {
     if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
       return I2C_STATUS_TIMEOUT;
     }
   }
 
-  if( (TW_STATUS & 0xF8) != TW_MT_DATA_ACK ){ return I2C_STATUS_ERROR; }
+  if ((TW_STATUS & 0xF8) != TW_MT_DATA_ACK) {
+    return I2C_STATUS_ERROR;
+  }
 
   return I2C_STATUS_SUCCESS;
 }
 
-int16_t i2c_read_ack(uint16_t timeout)
-{
-
+int16_t i2c_read_ack(uint16_t timeout) {
   // start TWI module and acknowledge data after reception
-  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWEA);
+  TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWEA);
 
   uint16_t timeout_timer = timer_read();
-  while( !(TWCR & (1<<TWINT)) ) {
+  while (!(TWCR & (1 << TWINT))) {
     if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
       return I2C_STATUS_TIMEOUT;
     }
@@ -92,14 +94,12 @@ int16_t i2c_read_ack(uint16_t timeout)
   return TWDR;
 }
 
-int16_t i2c_read_nack(uint16_t timeout)
-{
-
+int16_t i2c_read_nack(uint16_t timeout) {
   // start receiving without acknowledging reception
-  TWCR = (1<<TWINT) | (1<<TWEN);
+  TWCR = (1 << TWINT) | (1 << TWEN);
 
   uint16_t timeout_timer = timer_read();
-  while( !(TWCR & (1<<TWINT)) ) {
+  while (!(TWCR & (1 << TWINT))) {
     if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
       return I2C_STATUS_TIMEOUT;
     }
@@ -109,115 +109,89 @@ int16_t i2c_read_nack(uint16_t timeout)
   return TWDR;
 }
 
-i2c_status_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout)
-{
+i2c_status_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout) {
   i2c_status_t status = i2c_start(address | I2C_WRITE, timeout);
-  if (status) return status;
 
-  for (uint16_t i = 0; i < length; i++) {
+  for (uint16_t i = 0; i < length && status >= 0; i++) {
     status = i2c_write(data[i], timeout);
-    if (status) return status;
   }
 
-  status = i2c_stop(timeout);
-  if (status) return status;
+  i2c_stop();
 
-  return I2C_STATUS_SUCCESS;
+  return status;
 }
 
-i2c_status_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout)
-{
+i2c_status_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout) {
   i2c_status_t status = i2c_start(address | I2C_READ, timeout);
-  if (status) return status;
 
-  for (uint16_t i = 0; i < (length-1); i++) {
+  for (uint16_t i = 0; i < (length - 1) && status >= 0; i++) {
     status = i2c_read_ack(timeout);
     if (status >= 0) {
       data[i] = status;
-    } else {
-      return status;
     }
   }
 
-  status = i2c_read_nack(timeout);
-  if (status >= 0 ) {
-    data[(length-1)] = status;
-  } else {
-    return status;
+  if (status >= 0) {
+    status = i2c_read_nack(timeout);
+    if (status >= 0) {
+      data[(length - 1)] = status;
+    }
   }
 
-  status = i2c_stop(timeout);
-  if (status) return status;
+  i2c_stop();
 
-  return I2C_STATUS_SUCCESS;
+  return (status < 0) ? status : I2C_STATUS_SUCCESS;
 }
 
-i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout)
-{
+i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout) {
   i2c_status_t status = i2c_start(devaddr | 0x00, timeout);
-  if (status) return status;
+  if (status >= 0) {
+    status = i2c_write(regaddr, timeout);
 
-  status = i2c_write(regaddr, timeout);
-  if (status) return status;
-
-  for (uint16_t i = 0; i < length; i++) {
-    status = i2c_write(data[i], timeout);
-    if (status) return status;
+    for (uint16_t i = 0; i < length && status >= 0; i++) {
+      status = i2c_write(data[i], timeout);
+    }
   }
 
-  status = i2c_stop(timeout);
-  if (status) return status;
+  i2c_stop();
 
-  return I2C_STATUS_SUCCESS;
+  return status;
 }
 
-i2c_status_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout)
-{
+i2c_status_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout) {
   i2c_status_t status = i2c_start(devaddr, timeout);
-  if (status) return status;
+  if (status < 0) {
+    goto error;
+  }
 
   status = i2c_write(regaddr, timeout);
-  if (status) return status;
-
-  status = i2c_stop(timeout);
-  if (status) return status;
+  if (status < 0) {
+    goto error;
+  }
 
   status = i2c_start(devaddr | 0x01, timeout);
-  if (status) return status;
 
-  for (uint16_t i = 0; i < (length-1); i++) {
+  for (uint16_t i = 0; i < (length - 1) && status >= 0; i++) {
     status = i2c_read_ack(timeout);
     if (status >= 0) {
       data[i] = status;
-    } else {
-      return status;
     }
   }
 
-  status = i2c_read_nack(timeout);
-  if (status >= 0 ) {
-    data[(length-1)] = status;
-  } else {
-    return status;
+  if (status >= 0) {
+    status = i2c_read_nack(timeout);
+    if (status >= 0) {
+      data[(length - 1)] = status;
+    }
   }
 
-  status = i2c_stop(timeout);
-  if (status) return status;
+error:
+  i2c_stop();
 
-  return I2C_STATUS_SUCCESS;
+  return (status < 0) ? status : I2C_STATUS_SUCCESS;
 }
 
-i2c_status_t i2c_stop(uint16_t timeout)
-{
+void i2c_stop(void) {
   // transmit STOP condition
-  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
-
-  uint16_t timeout_timer = timer_read();
-  while(TWCR & (1<<TWSTO)) {
-    if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
-      return I2C_STATUS_TIMEOUT;
-    }
-  }
-
-  return I2C_STATUS_SUCCESS;
+  TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO);
 }

drivers/avr/i2c_master.h

@@ -26,6 +26,6 @@ i2c_status_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint1
 i2c_status_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);
 i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
 i2c_status_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
-i2c_status_t i2c_stop(uint16_t timeout);
+void i2c_stop(void);
 
 #endif // I2C_MASTER_H

drivers/avr/i2c_slave.c

@@ -16,7 +16,7 @@ static volatile bool slave_has_register_set = false;
 
 void i2c_slave_init(uint8_t address){
     // load address into TWI address register
-    TWAR = (address << 1);
+    TWAR = address;
     // set the TWCR to enable address matching and enable TWI, clear TWINT, enable TWI interrupt
     TWCR = (1 << TWIE) | (1 << TWEA) | (1 << TWINT) | (1 << TWEN);
 }

keyboards/1upkeyboards/1up60hse/1up60hse.h

@@ -13,8 +13,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 KB_H
-#define KB_H
+#pragma once
 
 #include "quantum.h"
 
@@ -36,4 +35,3 @@
 	{ K30,  K31,  K32,  K33,   K34,   K35, K36,   K37,   K38,   K39, K3A, KC_NO, KC_NO, K3D }, \
 	{ K40,  K41,  K42,  KC_NO, KC_NO, K45, KC_NO, KC_NO, KC_NO, K49, K4A, K4B,   KC_NO, K4D }  \
 }
-#endif

keyboards/1upkeyboards/1up60hse/rules.mk

@@ -68,5 +68,6 @@ 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 (+400)
+EXTRAFLAGS += -flto
 
 LAYOUTS = 60_ansi

keyboards/1upkeyboards/1up60hte/keymaps/default/keymap.c

@@ -46,35 +46,9 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 }
 
 void led_set_user(uint8_t usb_led) {
-
-	if (usb_led & (1 << USB_LED_NUM_LOCK)) {
-
-	} else {
-
-	}
-
-	if (usb_led & (1 << USB_LED_CAPS_LOCK)) {
+	if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK)) {
 		writePinLow(B6);
 	} else {
 		writePinHigh(B6);
 	}
-
-	if (usb_led & (1 << USB_LED_SCROLL_LOCK)) {
-
-	} else {
-
-	}
-
-	if (usb_led & (1 << USB_LED_COMPOSE)) {
-
-	} else {
-
-	}
-
-	if (usb_led & (1 << USB_LED_KANA)) {
-
-	} else {
-
-	}
-
 }

keyboards/1upkeyboards/1up60hte/rules.mk

@@ -54,5 +54,6 @@ NKRO_ENABLE = yes		# USB Nkey Rollover - if this doesn't work, see here: https:/
 BACKLIGHT_ENABLE = yes  # Enable keyboard backlight functionality
 AUDIO_ENABLE = no
 RGBLIGHT_ENABLE = yes
+EXTRAFLAGS += -flto
 
 LAYOUTS = 60_hhkb

keyboards/1upkeyboards/1up60rgb/1up60rgb.h

@@ -1,5 +1,4 @@
-#ifndef KB_H
-#define KB_H
+#pragma once
 
 #include "quantum.h"
 
@@ -77,5 +76,3 @@
 	K300, KC_NO,K302, K303, K304, K305, K306, K307, K308, K309, K310, K311,       K313, K314, \
 	KC_NO,K401,       K403,             K406,                   KC_NO,K411,       K413, KC_NO \
 )
-
-#endif

keyboards/1upkeyboards/1up60rgb/config.h

@@ -1,5 +1,4 @@
-#ifndef CONFIG_H
-#define CONFIG_H
+#pragma once
 
 #include "config_common.h"
 
@@ -46,5 +45,3 @@
 #define RGBLIGHT_SAT_STEP 8
 #define RGBLIGHT_VAL_STEP 8
 #endif
-
-#endif

keyboards/1upkeyboards/1up60rgb/keymaps/mdyevimnav/keymap.c

@@ -0,0 +1,48 @@
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+/*
+ * Layer 0
+ * ,-----------------------------------------------------------------------------------------.
+ * |  ~  |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  |  0  |  -  |  =  |    Bksp   |
+ * |-----------------------------------------------------------------------------------------+
+ * | Tab    |  q  |  w  |  e  |  r  |  t  |  y  |  u  |  i  |  o  |  p  |  [  |  ]  |   \    |
+ * |-----------------------------------------------------------------------------------------+
+ * | Esc     |  a  |  s  |  d  |  f  |  g  |  h  |  j  |  k  |  l  |  ;  |  '  |    Enter    |
+ * |-----------------------------------------------------------------------------------------+
+ * | Shift      |  z  |  x  |  c  |  v  |  b  |  n  |  m  |  ,  |  .  |  /  |    Shift       |
+ * |-----------------------------------------------------------------------------------------+
+ * | Ctrl  |  L1   |  Alt  |               space             |  Alt  |  Sup  |  L1   | Ctrl  |
+ * \-----------------------------------------------------------------------------------------/
+ *
+ */
+  LAYOUT_all(
+    KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_BSPC,
+    KC_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_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KC_ENT,
+    KC_LSHIFT, KC_LSHIFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSHIFT, KC_RSHIFT,
+    KC_LCTL, MO(1), KC_LALT, KC_SPC, KC_RALT, KC_RGUI, MO(1), KC_RCTL),
+
+/*
+ * Layer 1
+ * ,-----------------------------------------------------------------------------------------.
+ * |     |  f1 |  f2 |  f3 |  f4 |  f5 |  f6 |  f7 |  f8 |  f9 | f10 | f11 | f12 |    Del    |
+ * |-----------------------------------------------------------------------------------------+
+ * |        |     |     |     |     |     |     |     | Ins |     | Paus|     |     |  Prnt  |
+ * |-----------------------------------------------------------------------------------------+
+ * |         |     |     |     |     |     |  L  |  D  |  U  |  R  |     |     |             |
+ * |-----------------------------------------------------------------------------------------+
+ * |            |     |     |     |     |     | Hom | PDn | PUp | End |     |                |
+ * |-----------------------------------------------------------------------------------------+
+ * |       |       |       |                                 |       |       |       |       |
+ * \-----------------------------------------------------------------------------------------/
+ *
+ */
+  LAYOUT_all(
+    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_TRNS, KC_DEL,
+    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_INS, KC_TRNS, KC_PAUS, KC_TRNS, KC_TRNS, KC_PSCR,
+    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_HOME, KC_PGDN, KC_PGUP, KC_END, KC_TRNS, KC_TRNS, KC_TRNS,
+    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS)
+};

keyboards/1upkeyboards/1up60rgb/readme.md

@@ -1,4 +1,4 @@
-# 1upkeyboards 60% RGB
+# 1up60rgb 60% RGB
 
 Firmware for custom keyboard PCB with 60% key layout.
 

keyboards/1upkeyboards/1up60rgb/rules.mk

@@ -44,15 +44,15 @@ OPT_DEFS += -DBOOTLOADER_SIZE=4096
 # Build Options
 #   comment out to disable the options.
 #
-BOOTMAGIC_ENABLE ?= yes	# Virtual DIP switch configuration(+1000)
-MOUSEKEY_ENABLE ?= yes	# Mouse keys(+4700)
-EXTRAKEY_ENABLE ?= yes	# Audio control and System control(+450)
-CONSOLE_ENABLE ?= no	# Console for debug(+400)
-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 ?= yes  # Enable keyboard backlight functionality
-AUDIO_ENABLE ?= no
-RGBLIGHT_ENABLE ?= yes
+BOOTMAGIC_ENABLE = yes	# Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = yes	# Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes	# Audio control and System control(+450)
+CONSOLE_ENABLE = no	# Console for debug(+400)
+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 = yes  # Enable keyboard backlight functionality
+AUDIO_ENABLE = no
+RGBLIGHT_ENABLE = yes
 
 LAYOUTS = 60_ansi 60_iso 60_ansi_split_bs_rshift 60_hhkb

keyboards/1upkeyboards/readme.md

@@ -1,5 +1,7 @@
 # 1UP Keyboards
 
+1UP Keyboards is an online mechanical keyboard retailer located in New York, USA.
+
 Website: [1UP Keyboards](https://www.1upkeyboards.com/)  
 Discord: [Server Invite](https://discordapp.com/invite/c6SYn8)  
 YouTube: [skiwithpete](https://www.youtube.com/user/skiwithpete)  

keyboards/1upkeyboards/super16/keymaps/default/config.h

@@ -1,4 +1,4 @@
-/* Copyright 2019 'mechmerlin'
+/* Copyright 2019 MechMerlin
  *
  * 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

keyboards/1upkeyboards/super16/rules.mk

@@ -80,4 +80,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 (+400)
 
-LAYOUTS = ortho_4x4
+LAYOUTS = ortho_4x4

keyboards/1upkeyboards/sweet16/config.h

@@ -1,5 +1,4 @@
-#ifndef CONFIG_H
-#define CONFIG_H
+#pragma once
 
 #include "config_common.h"
 
@@ -47,4 +46,3 @@
 #define RGBLIGHT_VAL_STEP 8
 #endif
 
-#endif

keyboards/1upkeyboards/sweet16/readme.md

@@ -1,5 +1,4 @@
-Sweet16
-===
+# Sweet 16 Macropad
 
 A 4x4 numpad/macro pad sold by 1up Keyboards - designed by Bishop Keyboards
 

keyboards/1upkeyboards/sweet16/rules.mk

@@ -53,4 +53,5 @@ 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
+RGBLIGHT_ENABLE = yes
+EXTRAFLAGS += -flto

keyboards/1upkeyboards/sweet16/sweet16.h

@@ -1,5 +1,4 @@
-#ifndef KB_H
-#define KB_H
+#pragma once
 
 #include "quantum.h"
 
@@ -29,4 +28,3 @@
     { KC_NO, K31,   K32,   KC_NO }  \
 }
 
-#endif

keyboards/40percentclub/foobar/info.json

@@ -2,10 +2,12 @@
     "keyboard_name": "foobar",
     "url": "",
     "maintainer": "qmk",
-    "width": 6,
-    "height": 2,
+    "width": 10,
+    "height": 3,
     "layouts": {
         "LAYOUT_macro": {
+            "width": 5,
+            "height": 3,
             "key_count": 15,
             "layout": [
               {"x":0, "y":0}, {"x":1, "y":0}, {"x":2, "y":0}, {"x":3, "y":0}, {"x":4, "y":0},

keyboards/40percentclub/half_n_half/config.h

@@ -46,12 +46,13 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define UNUSED_PINS
 
 /* COL2ROW, ROW2COL*/
-#define DIODE_DIRECTION 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 D0 // or D1, D2, D3, E6
+#define USE_SERIAL
 
 // #define BACKLIGHT_PIN B7
 // #define BACKLIGHT_BREATHING

keyboards/40percentclub/half_n_half/half_n_half.h

@@ -16,6 +16,7 @@
 #pragma once
 
 #include "quantum.h"
+#define ___ KC_NO
 
 /* This a shortcut to help you visually see your layout.
  *
@@ -26,18 +27,22 @@
  * represents the switch matrix.
  */
 #define LAYOUT( \
-    K00, K01, K02, K03, K04, K05, K06,     K50, K51, K52, K53, K54, K55, K56, \
-    K10, K11, K12, K13, K14, K15, K16,     K60, K61, K62, K63, K64, K65, K66, \
-    K20, K21, K22, K23, K24, K25, K26,     K70, K71, K72, K73, K74, K75, K76, \
-                        K34,                         K82 \
+    L00, L01, L02, L03, L04, L05, L06,     R00, R01, R02, R03, R04, R05, R06, \
+    L10, L11, L12, L13, L14, L15, L16,     R10, R11, R12, R13, R14, R15, R16, \
+    L20, L21, L22, L23, L24, L25, L26,     R20, R21, R22, R23, R24, R25, R26, \
+                        L34,                         R32 \
 ) { \
-    { K00,   K01,   K02,   K03,   K04, K05,   K06   }, \
-    { K10,   K11,   K12,   K13,   K14, K15,   K16   }, \
-    { K20,   K21,   K22,   K23,   K24, K25,   K26   }, \
-    { KC_NO, KC_NO, KC_NO, KC_NO, K34, KC_NO, KC_NO }, \
+    { L00, L01, L02, L03, L04, L05, L06 }, \
+    { L10, L11, L12, L13, L14, L15, L16 }, \
+    { L20, L21, L22, L23, L24, L25, L26 }, \
+    { ___, ___, ___, ___, L34, ___, ___ }, \
 \
-    { K56,   K55,   K54,   K53,   K52, K51,   K50   }, \
-    { K66,   K65,   K64,   K63,   K62, K61,   K60   }, \
-    { K76,   K75,   K74,   K73,   K72, K71,   K70   }, \
-    { KC_NO, KC_NO, KC_NO, KC_NO, K82, KC_NO, KC_NO }  \
+    { R06, R05, R04, R03, R02, R01, R00 }, \
+    { R16, R15, R14, R13, R12, R11, R10 }, \
+    { R26, R25, R24, R23, R22, R21, R20 }, \
+    { ___, ___, ___, ___, R32, ___, ___ }  \
 }
+
+#ifdef USE_I2C
+  #error "I2C not Supported"
+#endif

keyboards/40percentclub/half_n_half/info.json

@@ -0,0 +1,62 @@
+{
+  "keyboard_name": "half_n_half",
+  "url": "",
+  "maintainer": "qmk",
+  "width": 14,
+  "height": 4,
+  "layouts": {
+    "LAYOUT": {
+      "key_count": 44,
+      "layout": [
+          {"label":"L00", "x":0, "y":0},
+          {"label":"L01", "x":1, "y":0},
+          {"label":"L02", "x":2, "y":0},
+          {"label":"L03", "x":3, "y":0},
+          {"label":"L04", "x":4, "y":0},
+          {"label":"L05", "x":5, "y":0},
+          {"label":"L06", "x":6, "y":0},
+          {"label":"R00", "x":7, "y":0},
+          {"label":"R01", "x":8, "y":0},
+          {"label":"R02", "x":9, "y":0},
+          {"label":"R03", "x":10, "y":0},
+          {"label":"R04", "x":11, "y":0},
+          {"label":"R05", "x":12, "y":0},
+          {"label":"R06", "x":13, "y":0},
+
+          {"label":"L10", "x":0, "y":1},
+          {"label":"L11", "x":1, "y":1},
+          {"label":"L12", "x":2, "y":1},
+          {"label":"L13", "x":3, "y":1},
+          {"label":"L14", "x":4, "y":1},
+          {"label":"L15", "x":5, "y":1},
+          {"label":"L16", "x":6, "y":1},
+          {"label":"R10", "x":7, "y":1},
+          {"label":"R11", "x":8, "y":1},
+          {"label":"R12", "x":9, "y":1},
+          {"label":"R13", "x":10, "y":1},
+          {"label":"R14", "x":11, "y":1},
+          {"label":"R15", "x":12, "y":1},
+          {"label":"R16", "x":13, "y":1},
+
+          {"label":"L20", "x":0, "y":2},
+          {"label":"L21", "x":1, "y":2},
+          {"label":"L22", "x":2, "y":2},
+          {"label":"L23", "x":3, "y":2},
+          {"label":"L24", "x":4, "y":2},
+          {"label":"L25", "x":5, "y":2},
+          {"label":"L26", "x":6, "y":2},
+          {"label":"R20", "x":7, "y":2},
+          {"label":"R21", "x":8, "y":2},
+          {"label":"R22", "x":9, "y":2},
+          {"label":"R23", "x":10, "y":2},
+          {"label":"R24", "x":11, "y":2},
+          {"label":"R25", "x":12, "y":2},
+          {"label":"R26", "x":13, "y":2},
+ 
+          {"label":"L34", "x":4, "y":3, "w":2},
+          {"label":"R32", "x":8, "y":3, "w":2}
+      ]
+    }
+  }
+}
+  

keyboards/40percentclub/half_n_half/keymaps/Boy_314/config.h

@@ -0,0 +1,22 @@
+/* Copyright 2019 Boy_314
+ *
+ * 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
+
+// place overrides here
+#define IGNORE_MOD_TAP_INTERRUPT
+#define PERMISSIVE_HOLD
+#define TAPPING_TERM 200

keyboards/40percentclub/half_n_half/keymaps/Boy_314/keymap.c

@@ -0,0 +1,141 @@
+/* Copyright 2019 Boy_314
+ *
+ * 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
+
+// Tap Dance Declarations
+enum {
+	TD_SWAP_LAYERS = 0
+};
+
+enum layers {
+	DVORAK,
+	QWERTY,
+	LOWER,
+	RAISE
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+	/* DVORAK
+	 * ,-------------------------------------------------------------------------------------------------.
+	 * |Tab   |'     |,     |.     |P     |Y     |Brght+|=     |F     |G     |C     |R     |L     |Bksp  |
+	 * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
+	 * |CtlCps|A     |O     |E     |U     |I     |Brght-|Ctrl+F|D     |H     |T     |N     |S     |Enter |
+	 * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
+	 * |LShift|;     |Q     |J     |K     |X     |LAlt  |-     |B     |M     |W     |V     |Z     |RShift|
+	 * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
+	 *                             |TD Swap Layer|             |Space        |      
+	 *                             `-------------'             `-------------'
+	 */
+	[DVORAK] = LAYOUT(/* Base Dvorak */
+	  KC_TAB,           KC_QUOT, KC_COMM, KC_DOT, KC_P, KC_Y, KC_BRIU, KC_EQL,     KC_F, KC_G, KC_C,    KC_R,   KC_L,   KC_BSPC, 
+	  LCTL_T(KC_CAPS),  KC_A,    KC_O,    KC_E,   KC_U, KC_I, KC_BRID, LCTL(KC_F), KC_D, KC_H, KC_T,    KC_N,   KC_S,   KC_ENT, 
+	  KC_LSPO,          KC_SCLN, KC_Q,    KC_J,   KC_K, KC_X, KC_LALT, KC_MINS,    KC_B, KC_M, KC_W,    KC_V,   KC_Z,   KC_RSPC, 
+	                                      TD(TD_SWAP_LAYERS),                      KC_SPC
+	),
+	
+	/* QWERTY
+	 * ,-------------------------------------------------------------------------------------------------.
+	 * |Tab   |Q     |W     |E     |R     |T     |Brght+|'     |Y     |U     |I     |O     |P     |Bksp  |
+	 * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
+	 * |LCtrl |A     |S     |D     |F     |G     |Brght-|Ctrl+F|H     |J     |K     |L     |;     |Enter |
+	 * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
+	 * |LShift|Z     |X     |C     |V     |B     |LAlt  |-     |N     |M     |,     |.     |/     |RShift|
+	 * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
+	 *                             |TD Swap Layer|             |Space        |      
+	 *                             `-------------'             `-------------'
+	 */
+	[QWERTY] = LAYOUT(/* Base Qwerty */
+	  KC_TAB,   KC_Q,    KC_W,    KC_E,   KC_R, KC_T, KC_BRIU, KC_QUOT,    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_BRID, LCTL(KC_F), KC_H, KC_J, KC_K,    KC_L,   KC_SCLN, KC_ENT, 
+	  KC_LSPO,  KC_Z,    KC_X,    KC_C,   KC_V, KC_B, KC_LALT, KC_MINS,    KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSPC, 
+	                                      TD(TD_SWAP_LAYERS),                    KC_SPC
+	),
+	
+	/* LOWER
+	 * ,-------------------------------------------------------------------------------------------------.
+	 * |Esc   |1     |2     |3     |4     |5     |      |=     |6     |7     |8     |9     |0     |/     |
+	 * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
+	 * |Caps  |F1    |F2    |F3    |F4    |F5    |F6    |Vol Up|Play  |_     |+     |{     |}     ||     |
+	 * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
+	 * |      |F7    |F8    |F9    |F10   |F11   |F12   |Vol Dn|Next  |Home  |PgDn  |PgUp  |End   |      |
+	 * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
+	 *                             |             |             |             |      
+	 *                             `-------------'             `-------------'
+	 */
+	[LOWER] = LAYOUT(/* Numbers, Function Row, Media Control, Shifted Symbols, Dvorak Slash Key */
+	  KC_GESC, KC_1,  KC_2,  KC_3,  KC_4,   KC_5,   KC_TRNS, KC_TRNS, KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_SLSH, 
+	  KC_CAPS, KC_F1, KC_F2, KC_F3, KC_F4,  KC_F5,  KC_F6,   KC_VOLU, KC_MPLY, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE, 
+	  KC_TRNS, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12,  KC_VOLD, KC_MNXT, KC_HOME, KC_PGDN, KC_PGUP, KC_END,  KC_TRNS,
+									KC_TRNS,    					           KC_TRNS
+	),
+	
+	/* RAISE
+	 * ,-------------------------------------------------------------------------------------------------.
+	 * |Reset |      |      |Up    |      |      |      |      |      |      |      |      |      |Del   |
+	 * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
+	 * |`     |      |Left  |Down  |Right |      |      |      |      |-     |=     |[     |]     |\     |
+	 * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
+	 * |      |!     |@     |#     |$     |%     |      |      |^     |&     |*     |(     |)     |      |
+	 * |------+------+------+------+------+------+------+------+------+------+------+------+------+------|
+	 *                             |             |             |             |      
+	 *                             `-------------'             `-------------'
+	 */
+	[RAISE] = LAYOUT(/* Arrows, Shifted Numbers, Symbols, Delete, Reset Key */
+	  RESET,   KC_TRNS, KC_TRNS, KC_UP,   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_DEL,
+	  KC_GRV,  KC_TRNS, KC_LEFT, KC_DOWN, KC_RGHT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_MINS, KC_EQL,  KC_LBRC, KC_RBRC, KC_BSLS, 
+	  KC_TRNS, KC_EXLM, KC_AT,   KC_HASH, KC_DLR,  KC_PERC, KC_TRNS, KC_TRNS, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_TRNS, 
+										  KC_TRNS, 									   KC_TRNS
+	)
+};
+
+void tap_dance_choose_layer (qk_tap_dance_state_t *state, void *user_data) {
+	switch (state->count) {
+		case 1:
+			layer_on(LOWER);
+			break;
+		case 2:
+			layer_on(RAISE);
+			break;
+	}
+}
+
+void tap_dance_choose_layer_reset (qk_tap_dance_state_t *state, void *user_data) {
+	switch (state->count) {
+		case 1:
+			layer_off(LOWER);
+			break;
+		case 2:
+			layer_off(RAISE);
+			break;
+		case 3:
+			if (default_layer_state == DVORAK) {
+				default_layer_set(QWERTY);
+				layer_on(QWERTY);
+				layer_off(DVORAK);
+			}
+			else if (default_layer_state == QWERTY) {
+				default_layer_set(DVORAK);
+				layer_on(DVORAK);
+				layer_off(QWERTY);
+			}
+			break;
+	}
+}
+
+qk_tap_dance_action_t tap_dance_actions[] = {
+	// ACTION_TAP_DANCE_FN_ADVANCED(on_each_tap_fn, on_dance_finished_fn, on_dance_reset_fn)
+	[TD_SWAP_LAYERS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, tap_dance_choose_layer, tap_dance_choose_layer_reset)
+};

keyboards/40percentclub/half_n_half/keymaps/Boy_314/readme.md

@@ -0,0 +1,2 @@
+# Boy_314's keymap for half_n_half
+# Currently only supports DVORAK. QWERTY Support is on the TODO list.

keyboards/40percentclub/half_n_half/keymaps/Boy_314/rules.mk

@@ -0,0 +1,5 @@
+TAP_DANCE_ENABLE = yes      # Enable Tap Dance
+NKRO_ENABLE = yes           # USB Nkey Rollover
+
+# Enable generic behavior for split boards
+SPLIT_KEYBOARD = yes

keyboards/40percentclub/half_n_half/rules.mk

@@ -79,3 +79,6 @@ 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 (+400)
+
+# Enable generic behavior for split boards
+SPLIT_KEYBOARD = yes

keyboards/40percentclub/mf68/config.h

@@ -52,6 +52,28 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define BACKLIGHT_BREATHING
 #define BACKLIGHT_LEVELS 3
 
+// #define RGB_DI_PIN E2
+// #ifdef RGB_DI_PIN
+//   #define RGBLED_NUM 16
+//   #define RGBLIGHT_HUE_STEP 8
+//   #define RGBLIGHT_SAT_STEP 8
+//   #define RGBLIGHT_VAL_STEP 8
+//   #define RGBLIGHT_LIMIT_VAL 255 /* The maximum brightness level */
+//   #define RGBLIGHT_SLEEP  /* If defined, the RGB lighting will be switched off when the host goes to sleep */
+// /*== all animations enable ==*/
+//   #define RGBLIGHT_ANIMATIONS
+// /*== or choose animations ==*/
+//   #define RGBLIGHT_EFFECT_BREATHING
+//   #define RGBLIGHT_EFFECT_RAINBOW_MOOD
+//   #define RGBLIGHT_EFFECT_RAINBOW_SWIRL
+//   #define RGBLIGHT_EFFECT_SNAKE
+//   #define RGBLIGHT_EFFECT_KNIGHT
+//   #define RGBLIGHT_EFFECT_CHRISTMAS
+//   #define RGBLIGHT_EFFECT_STATIC_GRADIENT
+//   #define RGBLIGHT_EFFECT_RGB_TEST
+//   #define RGBLIGHT_EFFECT_ALTERNATING
+// #endif
+
 /* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
 #define DEBOUNCING_DELAY 5
 

keyboards/40percentclub/mf68/keymaps/mf68_ble/config.h

@@ -0,0 +1,43 @@
+/*
+Copyright 2012 Jun Wako <wakojun@gmail.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
+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"
+
+/* Overrides for Feather 32u4 Bluefruit */
+
+/* USB Device descriptor parameter */
+#undef DESCRIPTION
+#define DESCRIPTION     Magicforce 68 BLE
+
+/*
+ * Keyboard Matrix Assignments
+ *
+ * Change this to how you wired your keyboard
+ * COLS: AVR pins used for columns, left to right
+ * ROWS: AVR pins used for rows, top to bottom
+ * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode)
+ *                  ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
+ *
+*/
+#undef MATRIX_ROW_PINS
+#undef MATRIX_COL_PINS
+#undef UNUSED_PINS
+#define MATRIX_ROW_PINS { D1, D0, C6, D7, B5, B6, B7, D6 }
+#define MATRIX_COL_PINS { C7, F7, F6, F5, F4, F1, F0, D2, D3 }
+#define UNUSED_PINS {B5}

keyboards/40percentclub/mf68/keymaps/mf68_ble/readme.md

@@ -1,6 +1,6 @@
 # mf68_ble
 
-![mf68_ble](https://3.bp.blogspot.com/-0YCA3Hx2Rq0/WD3U3GWhyvI/AAAAAAAB_Uo/RWTeyCPblGcxDrDwT9WL9ck2ZRuR26DgACLcB/s640/IMG_20161129_063741.jpg)
+![mf68_ble](https://i.imgur.com/zuTyy7k.jpg)
 ===
 
 Magicforce 68 with [replacement PCB](https://github.com/di0ib/tmk_keyboard/tree/master/keyboard/mf68) designed by [di0ib](https://github.com/di0ib).
@@ -24,6 +24,6 @@ Below is how you wire the Feather to PCB
 
 Make example for this keyboard (after setting up your build environment):  
 
-    make 40percentclub/mf68_ble:default
+    make 40percentclub/mf68:mf68_ble
 
 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).

keyboards/40percentclub/mf68/keymaps/mf68_ble/rules.mk

@@ -0,0 +1,66 @@
+# Overrides for Feather 32u4 Bluefruit
+# MCU name
+MCU = atmega32u4
+
+# Processor frequency.
+#     This will define a symbol, F_CPU, in all source code files equal to the
+#     processor frequency in Hz. You can then use this symbol in your source code to
+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#     automatically to create a 32-bit value in your source code.
+#
+#     This will be an integer division of F_USB below, as it is sourced by
+#     F_USB after it has run through any CPU prescalers. Note that this value
+#     does not *change* the processor frequency - it should merely be updated to
+#     reflect the processor speed set externally so that the code can use accurate
+#     software delays.
+F_CPU = 8000000
+
+
+#
+# LUFA specific
+#
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+# Input clock frequency.
+#     This will define a symbol, F_USB, in all source code files equal to the
+#     input clock frequency (before any prescaling is performed) in Hz. This value may
+#     differ from F_CPU if prescaling is used on the latter, and is required as the
+#     raw input clock is fed directly to the PLL sections of the AVR for high speed
+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
+#     at the end, this will be done automatically to create a 32-bit value in your
+#     source code.
+#
+#     If no clock division is performed on the input clock inside the AVR (via the
+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
+F_USB = $(F_CPU)
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   atmega32a    bootloadHID
+BOOTLOADER = caterina
+
+
+# If you don't know the bootloader type, then you can specify the
+# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
+#   Teensy halfKay      512
+#   Teensy++ halfKay    1024
+#   Atmel DFU loader    4096
+#   LUFA bootloader     4096
+#   USBaspLoader        2048
+# OPT_DEFS += -DBOOTLOADER_SIZE=4096
+
+
+# Build Options
+#   change yes to no to disable
+#
+BLUETOOTH = AdafruitBLE
+BACKLIGHT_ENABLE = no

keyboards/40percentclub/mf68/rules.mk

@@ -63,13 +63,14 @@ BOOTLOADER = caterina
 BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration(+1000)
 MOUSEKEY_ENABLE = yes       # Mouse keys(+4700)
 EXTRAKEY_ENABLE = yes       # Audio control and System control(+450)
-CONSOLE_ENABLE = yes        # Console for debug(+400)
-COMMAND_ENABLE = yes        # Commands for debug and configuration
+CONSOLE_ENABLE = no         # Console for debug(+400)
+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 = yes      # Enable keyboard backlight functionality on B7 by default
+RGBLIGHT_ENABLE = no        # Enable keyboard RGB underglow
 MIDI_ENABLE = no            # MIDI controls
 UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID

keyboards/40percentclub/mf68_ble/info.json

@@ -1,12 +0,0 @@
-{
-  "keyboard_name": "MF68 BLE",
-  "url": "",
-  "maintainer": "qmk",
-  "width": 17.25,
-  "height": 5,
-  "layouts": {
-      "LAYOUT_68_ansi": {
-          "layout": [{"label":"~", "x":0, "y":0}, {"label":"!", "x":1, "y":0}, {"label":"@", "x":2, "y":0}, {"label":"#", "x":3, "y":0}, {"label":"$", "x":4, "y":0}, {"label":"%", "x":5, "y":0}, {"label":"^", "x":6, "y":0}, {"label":"&", "x":7, "y":0}, {"label":"*", "x":8, "y":0}, {"label":"(", "x":9, "y":0}, {"label":")", "x":10, "y":0}, {"label":"_", "x":11, "y":0}, {"label":"+", "x":12, "y":0}, {"label":"Backspace", "x":13, "y":0, "w":2}, {"x":15.25, "y":0}, {"x":16.25, "y":0}, {"label":"Tab", "x":0, "y":1, "w":1.5}, {"label":"Q", "x":1.5, "y":1}, {"label":"W", "x":2.5, "y":1}, {"label":"E", "x":3.5, "y":1}, {"label":"R", "x":4.5, "y":1}, {"label":"T", "x":5.5, "y":1}, {"label":"Y", "x":6.5, "y":1}, {"label":"U", "x":7.5, "y":1}, {"label":"I", "x":8.5, "y":1}, {"label":"O", "x":9.5, "y":1}, {"label":"P", "x":10.5, "y":1}, {"label":"{", "x":11.5, "y":1}, {"label":"}", "x":12.5, "y":1}, {"label":"|", "x":13.5, "y":1, "w":1.5}, {"x":15.25, "y":1}, {"x":16.25, "y":1}, {"label":"Caps Lock", "x":0, "y":2, "w":1.75}, {"label":"A", "x":1.75, "y":2}, {"label":"S", "x":2.75, "y":2}, {"label":"D", "x":3.75, "y":2}, {"label":"F", "x":4.75, "y":2}, {"label":"G", "x":5.75, "y":2}, {"label":"H", "x":6.75, "y":2}, {"label":"J", "x":7.75, "y":2}, {"label":"K", "x":8.75, "y":2}, {"label":"L", "x":9.75, "y":2}, {"label":":", "x":10.75, "y":2}, {"label":"\"", "x":11.75, "y":2}, {"label":"Enter", "x":12.75, "y":2, "w":2.25}, {"label":"Shift", "x":0, "y":3, "w":2.25}, {"label":"Z", "x":2.25, "y":3}, {"label":"X", "x":3.25, "y":3}, {"label":"C", "x":4.25, "y":3}, {"label":"V", "x":5.25, "y":3}, {"label":"B", "x":6.25, "y":3}, {"label":"N", "x":7.25, "y":3}, {"label":"M", "x":8.25, "y":3}, {"label":"<", "x":9.25, "y":3}, {"label":">", "x":10.25, "y":3}, {"label":"?", "x":11.25, "y":3}, {"label":"Shift", "x":12.25, "y":3, "w":2.75}, {"x":15.25, "y":3}, {"label":"Ctrl", "x":0, "y":4, "w":1.25}, {"label":"Win", "x":1.25, "y":4, "w":1.25}, {"label":"Alt", "x":2.5, "y":4, "w":1.25}, {"x":3.75, "y":4, "w":6.25}, {"label":"Alt", "x":10, "y":4, "w":1.25}, {"label":"Win", "x":11.25, "y":4, "w":1.25}, {"label":"Menu", "x":12.5, "y":4, "w":1.25}, {"x":14.25, "y":4}, {"x":15.25, "y":4}, {"x":16.25, "y":4}]
-      }
-  }
-}

keyboards/40percentclub/mf68_ble/mf68_ble.c

@@ -1,8 +0,0 @@
-#include "mf68_ble.h"
-
-void matrix_init_kb(void) {
-	// put your keyboard start-up code here
-	// runs once when the firmware starts up
-
-	matrix_init_user();
-}

keyboards/40percentclub/mf68_ble/mf68_ble.h

@@ -1,37 +0,0 @@
-#pragma once
-
-#include "quantum.h"
-
-#define LAYOUT_68_ansi( \
-    K00, K01, K02, K03, K04, K05, K06, K07, K08, K10, K11, K12, K13, K14,     K15, K16, \
-    K17, K18, K20, K21, K22, K23, K24, K25, K26, K27, K28, K30, K31, K32,     K33, K34, \
-    K35,  K36, K37, K38, K40, K41, K42, K43, K44, K45, K46, K47,     K48, \
-    K50,   K51, K52, K53, K54, K55, K56, K57, K58, K60, K61,    K62,          K63, \
-    K64,  K65,  K66,                 K67,              K68,  K70,  K71,  K72, K73, K74 \
-) { \
-    { K00, K01, K02, K03, K04, K05, K06, K07, K08 }, \
-    { K10, K11, K12, K13, K14, K15, K16, K17, K18 }, \
-    { K20, K21, K22, K23, K24, K25, K26, K27, K28 }, \
-    { K30, K31, K32, K33, K34, K35, K36, K37, K38 }, \
-    { K40, K41, K42, K43, K44, K45, K46, K47, K48 }, \
-    { K50, K51, K52, K53, K54, K55, K56, K57, K58 }, \
-    { K60, K61, K62, K63, K64, K65, K66, K67, K68 }, \
-    { K70, K71, K72, K73, K74 } \
-}
-
-#define LAYOUT_kc( \
-    K00, K01, K02, K03, K04, K05, K06, K07, K08, K10, K11, K12, K13, K14,     K15, K16, \
-    K17, K18, K20, K21, K22, K23, K24, K25, K26, K27, K28, K30, K31, K32,     K33, K34, \
-    K35,  K36, K37, K38, K40, K41, K42, K43, K44, K45, K46, K47,     K48, \
-    K50,   K51, K52, K53, K54, K55, K56, K57, K58, K60, K61,    K62,          K63, \
-    K64,  K65,  K66,                 K67,              K68,  K70,  K71,  K72, K73, K74 \
-) LAYOUT_68_ansi( \
-    KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07, KC_##K08, \
-    KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17, KC_##K18, \
-    KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27, KC_##K28, \
-    KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37, KC_##K38, \
-    KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47, KC_##K48, \
-    KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57, KC_##K58, \
-    KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_##K66, KC_##K67, KC_##K68, \
-    KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_##K74 \
-)

keyboards/ai03/orbit/config.h

@@ -0,0 +1,249 @@
+/*
+Copyright 2018 Ryota Goto
+
+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       0xA103
+#define PRODUCT_ID      0x0003
+#define DEVICE_VER      0x0003
+#define MANUFACTURER    ai03 Keyboard Designs
+#define PRODUCT         Orbit
+#define DESCRIPTION     Split ergonomic keyboard
+
+/* key matrix size */
+#define MATRIX_ROWS 10 // Double rows for split keyboards. Orbit has 5, so define 10
+#define MATRIX_COLS 7
+
+/*
+ * Keyboard Matrix Assignments
+ *
+ * Change this to how you wired your keyboard
+ * COLS: AVR pins used for columns, left to right
+ * ROWS: AVR pins used for rows, top to bottom
+ * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode)
+ *                  ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
+ *
+*/
+#define MATRIX_ROW_PINS { F7, F6, F5, F4, D3 }
+#define MATRIX_COL_PINS { C7, B4, D7, D6, D4, F1, F0 }
+#define MATRIX_ROW_PINS_RIGHT { B6, B5, B4, D7, E6 }
+#define MATRIX_COL_PINS_RIGHT { D4, D6, F1, F0, F4, F5, C6 }
+
+#define SPLIT_HAND_PIN D5
+
+//#define USE_I2C
+
+#define SELECT_SOFT_SERIAL_SPEED 1
+
+#define UNUSED_PINS
+
+/* COL2ROW, ROW2COL, or CUSTOM_MATRIX */
+#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 D0 // or D1, D2, D3, E6
+
+#define BACKLIGHT_PIN B7
+// #define BACKLIGHT_BREATHING
+#define BACKLIGHT_LEVELS 3
+
+// #define RGB_DI_PIN E2
+// #ifdef RGB_DI_PIN
+//   #define RGBLED_NUM 16
+//   #define RGBLIGHT_HUE_STEP 8
+//   #define RGBLIGHT_SAT_STEP 8
+//   #define RGBLIGHT_VAL_STEP 8
+//   #define RGBLIGHT_LIMIT_VAL 255 /* The maximum brightness level */
+//   #define RGBLIGHT_SLEEP  /* If defined, the RGB lighting will be switched off when the host goes to sleep */
+// /*== all animations enable ==*/
+//   #define RGBLIGHT_ANIMATIONS
+// /*== or choose animations ==*/
+//   #define RGBLIGHT_EFFECT_BREATHING
+//   #define RGBLIGHT_EFFECT_RAINBOW_MOOD
+//   #define RGBLIGHT_EFFECT_RAINBOW_SWIRL
+//   #define RGBLIGHT_EFFECT_SNAKE
+//   #define RGBLIGHT_EFFECT_KNIGHT
+//   #define RGBLIGHT_EFFECT_CHRISTMAS
+//   #define RGBLIGHT_EFFECT_STATIC_GRADIENT
+//   #define RGBLIGHT_EFFECT_RGB_TEST
+//   #define RGBLIGHT_EFFECT_ALTERNATING
+// #endif
+
+/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
+#define DEBOUNCING_DELAY 5
+
+/* define if matrix has ghost (lacks anti-ghosting diodes) */
+//#define MATRIX_HAS_GHOST
+
+/* number of backlight levels */
+
+/* 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
+
+/*
+ * Force NKRO
+ *
+ * Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved
+ * state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the
+ * makefile for this to work.)
+ *
+ * If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N)
+ * until the next keyboard reset.
+ *
+ * NKRO may prevent your keystrokes from being detected in the BIOS, but it is
+ * fully operational during normal computer usage.
+ *
+ * For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N)
+ * or via bootmagic (hold SPACE+N while plugging in the keyboard). Once set by
+ * bootmagic, NKRO mode will always be enabled until it is toggled again during a
+ * power-up.
+ *
+ */
+//#define FORCE_NKRO
+
+/*
+ * Magic Key Options
+ *
+ * Magic keys are hotkey commands that allow control over firmware functions of
+ * the keyboard. They are best used in combination with the HID Listen program,
+ * found here: https://www.pjrc.com/teensy/hid_listen.html
+ *
+ * The options below allow the magic key functionality to be changed. This is
+ * useful if your keyboard/keypad is missing keys and you want magic key support.
+ *
+ */
+
+/* control how magic key switches layers */
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS  true
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS  true
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM false
+
+/* override magic key keymap */
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM
+//#define MAGIC_KEY_HELP1          H
+//#define MAGIC_KEY_HELP2          SLASH
+//#define MAGIC_KEY_DEBUG          D
+//#define MAGIC_KEY_DEBUG_MATRIX   X
+//#define MAGIC_KEY_DEBUG_KBD      K
+//#define MAGIC_KEY_DEBUG_MOUSE    M
+//#define MAGIC_KEY_VERSION        V
+//#define MAGIC_KEY_STATUS         S
+//#define MAGIC_KEY_CONSOLE        C
+//#define MAGIC_KEY_LAYER0_ALT1    ESC
+//#define MAGIC_KEY_LAYER0_ALT2    GRAVE
+//#define MAGIC_KEY_LAYER0         0
+//#define MAGIC_KEY_LAYER1         1
+//#define MAGIC_KEY_LAYER2         2
+//#define MAGIC_KEY_LAYER3         3
+//#define MAGIC_KEY_LAYER4         4
+//#define MAGIC_KEY_LAYER5         5
+//#define MAGIC_KEY_LAYER6         6
+//#define MAGIC_KEY_LAYER7         7
+//#define MAGIC_KEY_LAYER8         8
+//#define MAGIC_KEY_LAYER9         9
+//#define MAGIC_KEY_BOOTLOADER     PAUSE
+//#define MAGIC_KEY_LOCK           CAPS
+//#define MAGIC_KEY_EEPROM         E
+//#define MAGIC_KEY_NKRO           N
+//#define MAGIC_KEY_SLEEP_LED      Z
+
+/*
+ * Feature disable options
+ *  These options are also useful to firmware size reduction.
+ */
+
+/* disable debug print */
+//#define NO_DEBUG
+
+/* disable print */
+//#define NO_PRINT
+
+/* disable action features */
+//#define NO_ACTION_LAYER
+//#define NO_ACTION_TAPPING
+//#define NO_ACTION_ONESHOT
+//#define NO_ACTION_MACRO
+//#define NO_ACTION_FUNCTION
+
+/*
+ * 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 1
+
+/*
+ * HD44780 LCD Display Configuration
+ */
+/*
+#define LCD_LINES           2     //< number of visible lines of the display
+#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
+
+#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
+
+#if LCD_IO_MODE
+#define LCD_PORT         PORTB        //< port for the LCD lines
+#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
+#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
+#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
+#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
+#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
+#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
+#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
+#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
+#define LCD_RS_PORT      LCD_PORT     //< port for RS line
+#define LCD_RS_PIN       3            //< pin  for RS line
+#define LCD_RW_PORT      LCD_PORT     //< port for RW line
+#define LCD_RW_PIN       2            //< pin  for RW line
+#define LCD_E_PORT       LCD_PORT     //< port for Enable line
+#define LCD_E_PIN        1            //< pin  for Enable line
+#endif
+*/
+
+/* Bootmagic Lite key configuration */
+// #define BOOTMAGIC_LITE_ROW 0
+// #define BOOTMAGIC_LITE_COLUMN 0

keyboards/ai03/orbit/keymaps/default/keymap.c

@@ -0,0 +1,91 @@
+/* Copyright 2018 Ryota Goto
+ *
+ * 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
+
+// Defines the keycodes used by our macros in process_record_user
+enum custom_keycodes {
+  MANUAL = SAFE_RANGE,
+  DBLZERO
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+	[0] = LAYOUT( /* Base */
+		TO(1),   KC_ESC,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_LBRC, KC_BSPC, \
+		TO(1),   KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_RBRC, KC_BSLS, \
+		KC_NO,   KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_ENT,  \
+		KC_NO,   KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_PSCR, KC_DEL,  \
+			     KC_LCTL, KC_LCTL, KC_LGUI, KC_LALT, MO(1),   KC_SPC,  KC_SPC,  MO(2),   KC_GRV,  KC_MENU, KC_MINS, KC_EQL 
+	),
+	[1] = LAYOUT( /* Fn, Arrowkeys, Media control, Backlight */
+		TO(2),   _______, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_VOLU, _______, \
+		TO(2),   _______, _______, KC_PGUP, _______, _______, KC_F11,  KC_F12,  _______, KC_UP,   _______, _______, KC_VOLD, BL_STEP, \
+		TO(0),   _______, KC_HOME, KC_PGDN, KC_END,  _______, _______, _______, KC_LEFT, KC_DOWN, KC_RGHT, _______, KC_MPLY, _______, \
+		TO(0),   _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_INS,  \
+			     _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
+	),
+	[2] = LAYOUT( /* Mousekeys and Numpad */
+		KC_NO,   _______, _______, _______, _______, _______, _______, KC_NLCK, KC_P7,   KC_P8,   KC_P9,   KC_PSLS, _______, _______, \
+		KC_NO,   _______, KC_BTN1, KC_MS_U, KC_BTN2, KC_WH_U, _______, _______, KC_P4,   KC_P5,   KC_P6,   KC_PAST, _______, _______, \
+		TO(1),   _______, KC_MS_L, KC_MS_D, KC_MS_R, KC_WH_D, _______, _______, KC_P1,   KC_P2,   KC_P3,   KC_PMNS, _______, _______, \
+		TO(1),   _______, KC_ACL0, KC_ACL1, KC_ACL2, KC_BTN3, _______, DBLZERO, KC_P0,   KC_PDOT, KC_PENT, KC_PPLS, _______, MANUAL,  \
+			     _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
+	)
+};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+	switch (keycode) {
+		case MANUAL:
+			if (record->event.pressed) 
+			{
+				// Keypress
+				SEND_STRING("https://kb.ai03.me/redir/orbit");
+			} 
+			else 
+			{
+				// Key release
+			}
+			break;
+		case DBLZERO:
+			if (record->event.pressed) 
+			{
+				// Keypress
+				SEND_STRING("00");
+			} 
+			else 
+			{
+				// Key release
+			}
+			break;
+  }
+  return true;
+}
+
+void matrix_init_user(void) {
+
+}
+
+void matrix_scan_user(void) {
+
+}
+
+void led_set_user(uint8_t usb_led) {
+
+}
+
+uint32_t layer_state_set_user(uint32_t state) {
+		
+	return state;
+}

keyboards/ai03/orbit/keymaps/default/readme.md

@@ -0,0 +1,3 @@
+# The default keymap for Orbit
+
+[KLE of layout](http://www.keyboard-layout-editor.com/#/gists/53ebf59524de12515cb7e2e6de94f0d6)

keyboards/ai03/orbit/matrix.c

@@ -0,0 +1,328 @@
+/*
+Copyright 2012 Jun Wako <wakojun@gmail.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
+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 "wait.h"
+#include "util.h"
+#include "matrix.h"
+#include "split_util.h"
+#include "config.h"
+#include "split_flags.h"
+#include "quantum.h"
+#include "debounce.h"
+#include "transport.h"
+
+#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)
+#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
+
+#define ERROR_DISCONNECT_COUNT 5
+
+//#define ROWS_PER_HAND (MATRIX_ROWS / 2)
+
+#ifdef DIRECT_PINS
+static pin_t direct_pins[MATRIX_ROWS][MATRIX_COLS] = DIRECT_PINS;
+#else
+static pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
+static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
+#endif
+
+/* matrix state(1:on, 0:off) */
+static matrix_row_t matrix[MATRIX_ROWS];
+static matrix_row_t raw_matrix[ROWS_PER_HAND];
+
+// row offsets for each hand
+uint8_t thisHand, thatHand;
+
+// user-defined overridable functions
+
+__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) {}
+
+__attribute__((weak)) void matrix_slave_scan_user(void) {}
+
+// helper functions
+
+inline uint8_t matrix_rows(void) { return MATRIX_ROWS; }
+
+inline uint8_t matrix_cols(void) { return MATRIX_COLS; }
+
+bool matrix_is_modified(void) {
+  if (debounce_active()) 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_matrix_header();
+
+  for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
+    phex(row);
+    print(": ");
+    print_matrix_row(row);
+    print("\n");
+  }
+}
+
+uint8_t matrix_key_count(void) {
+  uint8_t count = 0;
+  for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+    count += matrix_bitpop(i);
+  }
+  return count;
+}
+
+// matrix code
+
+#ifdef DIRECT_PINS
+
+static void init_pins(void) {
+  for (int row = 0; row < MATRIX_ROWS; row++) {
+    for (int col = 0; col < MATRIX_COLS; col++) {
+      pin_t pin = direct_pins[row][col];
+      if (pin != NO_PIN) {
+        setPinInputHigh(pin);
+      }
+    }
+  }
+}
+
+static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
+  matrix_row_t last_row_value = current_matrix[current_row];
+  current_matrix[current_row] = 0;
+
+  for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
+    pin_t pin = direct_pins[current_row][col_index];
+    if (pin != NO_PIN) {
+      current_matrix[current_row] |= readPin(pin) ? 0 : (ROW_SHIFTER << col_index);
+    }
+  }
+
+  return (last_row_value != current_matrix[current_row]);
+}
+
+#elif (DIODE_DIRECTION == COL2ROW)
+
+static void select_row(uint8_t row) {
+  setPinOutput(row_pins[row]);
+  writePinLow(row_pins[row]);
+}
+
+static void unselect_row(uint8_t row) { setPinInputHigh(row_pins[row]); }
+
+static void unselect_rows(void) {
+  for (uint8_t x = 0; x < ROWS_PER_HAND; x++) {
+    setPinInputHigh(row_pins[x]);
+  }
+}
+
+static void init_pins(void) {
+  unselect_rows();
+  for (uint8_t x = 0; x < MATRIX_COLS; x++) {
+    setPinInputHigh(col_pins[x]);
+  }
+}
+
+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++) {
+    // Populate the matrix row with the state of the col pin
+    current_matrix[current_row] |= readPin(col_pins[col_index]) ? 0 : (ROW_SHIFTER << col_index);
+  }
+
+  // Unselect row
+  unselect_row(current_row);
+
+  return (last_row_value != current_matrix[current_row]);
+}
+
+#elif (DIODE_DIRECTION == ROW2COL)
+
+static void select_col(uint8_t col) {
+  setPinOutput(col_pins[col]);
+  writePinLow(col_pins[col]);
+}
+
+static void unselect_col(uint8_t col) { setPinInputHigh(col_pins[col]); }
+
+static void unselect_cols(void) {
+  for (uint8_t x = 0; x < MATRIX_COLS; x++) {
+    setPinInputHigh(col_pins[x]);
+  }
+}
+
+static void init_pins(void) {
+  unselect_cols();
+  for (uint8_t x = 0; x < ROWS_PER_HAND; x++) {
+    setPinInputHigh(row_pins[x]);
+  }
+}
+
+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 (readPin(row_pins[row_index])) {
+      // Pin HI, clear col bit
+      current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
+    } else {
+      // Pin LO, set 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;
+}
+
+#endif
+
+void matrix_init(void) {
+  debug_enable = true;
+  debug_matrix = true;
+  debug_mouse  = true;
+
+  // Set pinout for right half if pinout for that half is defined
+  if (!isLeftHand) {
+#ifdef MATRIX_ROW_PINS_RIGHT
+    const uint8_t row_pins_right[MATRIX_ROWS] = MATRIX_ROW_PINS_RIGHT;
+    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+      row_pins[i] = row_pins_right[i];
+    }
+#endif
+#ifdef MATRIX_COL_PINS_RIGHT
+    const uint8_t col_pins_right[MATRIX_COLS] = MATRIX_COL_PINS_RIGHT;
+    for (uint8_t i = 0; i < MATRIX_COLS; i++) {
+      col_pins[i] = col_pins_right[i];
+    }
+#endif
+  }
+
+  thisHand = isLeftHand ? 0 : (ROWS_PER_HAND);
+  thatHand = ROWS_PER_HAND - thisHand;
+
+  // initialize key pins
+  init_pins();
+
+  // initialize matrix state: all keys off
+  for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+    matrix[i] = 0;
+  }
+
+  debounce_init(ROWS_PER_HAND);
+
+  matrix_init_quantum();
+}
+
+uint8_t _matrix_scan(void) {
+  bool changed = false;
+
+#if defined(DIRECT_PINS) || (DIODE_DIRECTION == COL2ROW)
+  // Set row, read cols
+  for (uint8_t current_row = 0; current_row < ROWS_PER_HAND; current_row++) {
+    changed |= read_cols_on_row(raw_matrix, current_row);
+  }
+#elif (DIODE_DIRECTION == ROW2COL)
+  // Set col, read rows
+  for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
+    changed |= read_rows_on_col(raw_matrix, current_col);
+  }
+#endif
+
+  debounce(raw_matrix, matrix + thisHand, ROWS_PER_HAND, changed);
+
+  return 1;
+}
+
+uint8_t matrix_scan(void) {
+  uint8_t ret = _matrix_scan();
+
+  if (is_keyboard_master()) {
+    static uint8_t error_count;
+
+    if (!transport_master(matrix + thatHand)) {
+      error_count++;
+
+      if (error_count > ERROR_DISCONNECT_COUNT) {
+        // reset other half if disconnected
+        for (int i = 0; i < ROWS_PER_HAND; ++i) {
+          matrix[thatHand + i] = 0;
+        }
+      }
+    } else {
+      error_count = 0;
+    }
+
+    matrix_scan_quantum();
+  } else {
+    transport_slave(matrix + thisHand);
+    matrix_slave_scan_user();
+  }
+
+  return ret;
+}

keyboards/ai03/orbit/matrix.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#include <common/matrix.h>

keyboards/ai03/orbit/orbit.c

@@ -0,0 +1,228 @@
+/* Copyright 2018 Ryota Goto
+ *
+ * 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 "orbit.h"
+#include "split_util.h"
+#include "transport.h"
+
+
+// Call led_toggle to set LEDs easily
+// LED IDs:
+// 
+// (LEFT) 0 1 2   |   3 4 5 (RIGHT)
+
+void led_toggle(int id, bool on) {
+	
+	if (isLeftHand) {
+		switch(id) {
+			case 0:
+				// Left hand C6
+				if (on)
+					//PORTC |= (1<<6);
+					writePinHigh(C6);
+				else
+					//PORTC &= ~(1<<6);
+					writePinLow(C6);
+				break;
+			case 1:
+				// Left hand B6
+				if (on)
+					//PORTB |= (1<<6);
+					writePinHigh(B6);
+				else
+					//PORTB &= ~(1<<6);
+					writePinLow(B6);
+				break;
+			case 2:
+				// Left hand B5
+				if (on)
+					//PORTB |= (1<<5);
+					writePinHigh(B5);
+				else
+					//PORTB &= ~(1<<5);
+					writePinLow(B5);
+				break;
+			default:
+				break;
+		}
+	} else {
+		switch(id) {
+			case 3:
+				// Right hand F6
+				if (on)
+					//PORTF |= (1<<6);
+					writePinHigh(F6);
+				else
+					//PORTF &= ~(1<<6);
+					writePinLow(F6);
+				break;
+			case 4:
+				// Right hand F7
+				if (on)
+					//PORTF |= (1<<7);
+					writePinHigh(F7);
+				else
+					//PORTF &= ~(1<<7);
+					writePinLow(F7);
+				break;
+			case 5:
+				// Right hand C7
+				if (on)
+					//PORTC |= (1<<7);
+					writePinHigh(C7);
+				else
+					//PORTC &= ~(1<<7);
+					writePinLow(C7);
+				break;
+			default:
+				break;
+		}
+	}
+}
+
+// Set all LEDs at once using an array of 6 booleans
+// LED IDs:
+// 
+// (LEFT) 0 1 2   |   3 4 5 (RIGHT)
+// 
+// Ex. set_all_leds({ false, false, false, true, true, true }) would turn off left hand, turn on right hand
+
+void set_all_leds(bool leds[6]) {
+	for (int i = 0; i < 6; i++) {
+		led_toggle(i, leds[i]);
+	}
+}
+
+void set_layer_indicators(uint8_t layer) {
+	
+	switch (layer)
+	{
+		case 0:
+			led_toggle(0, true);
+			led_toggle(1, false);
+			led_toggle(2, false);
+			break;
+		case 1:
+			led_toggle(0, true);
+			led_toggle(1, true);
+			led_toggle(2, false);
+			break;
+		case 2:
+			led_toggle(0, true);
+			led_toggle(1, true);
+			led_toggle(2, true);
+			break;
+		case 3:
+			led_toggle(0, false);
+			led_toggle(1, true);
+			led_toggle(2, true);
+			break;
+		case 4:
+			led_toggle(0, false);
+			led_toggle(1, false);
+			led_toggle(2, true);
+			break;
+		default:
+			led_toggle(0, true);
+			led_toggle(1, false);
+			led_toggle(2, true);
+			break;
+	}
+	
+}
+
+void matrix_init_kb(void) {
+	// put your keyboard start-up code here
+	// runs once when the firmware starts up
+	
+	// Initialize indicator LEDs to output
+	if (isLeftHand)
+	{
+		setPinOutput(C6);
+		setPinOutput(B6);
+		setPinOutput(B5);
+		//DDRC |= (1<<6);
+		//DDRB |= (1<<6);
+		//DDRB |= (1<<5);
+	}
+	else
+	{
+		setPinOutput(F6);
+		setPinOutput(F7);
+		setPinOutput(C7);
+		//DDRF |= (1<<6);
+		//DDRF |= (1<<7);
+		//DDRC |= (1<<7);
+	}
+
+	set_layer_indicators(0);
+	
+	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
+	
+	if (is_keyboard_master()) {
+	
+		serial_m2s_buffer.nlock_led = IS_LED_ON(usb_led, USB_LED_NUM_LOCK);
+		serial_m2s_buffer.clock_led = IS_LED_ON(usb_led, USB_LED_CAPS_LOCK);
+		serial_m2s_buffer.slock_led = IS_LED_ON(usb_led, USB_LED_SCROLL_LOCK);
+
+		led_toggle(3, IS_LED_ON(usb_led, USB_LED_NUM_LOCK));
+		led_toggle(4, IS_LED_ON(usb_led, USB_LED_CAPS_LOCK));
+		led_toggle(5, IS_LED_ON(usb_led, USB_LED_SCROLL_LOCK));
+		
+	}
+
+	led_set_user(usb_led);
+}
+
+uint32_t layer_state_set_kb(uint32_t state) {
+	
+	if (is_keyboard_master())
+	{
+		
+		current_layer = biton32(state);
+		serial_m2s_buffer.current_layer = biton32(state);
+		
+		// If left half, do the LED toggle thing
+		if (isLeftHand)
+		{
+			set_layer_indicators(biton32(state));
+		}
+		
+	}
+	// NOTE: Do not set slave LEDs here.
+	// This is not called on slave
+	
+	return layer_state_set_user(state);
+}
+
+

keyboards/ai03/orbit/orbit.h

@@ -0,0 +1,65 @@
+/* Copyright 2018 Ryota Goto
+ *
+ * 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/>.
+ */
+#ifndef ORBIT_H
+#define ORBIT_H
+
+#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.
+ */
+ 
+#ifdef USE_I2C
+#include <stddef.h>
+#ifdef __AVR__
+  #include <avr/io.h>
+  #include <avr/interrupt.h>
+#endif
+#endif
+
+
+#define LAYOUT( \
+    L00, L01, L02, L03, L04, L05, L06, R00, R01, R02, R03, R04, R05, R06, \
+	L10, L11, L12, L13, L14, L15, L16, R10, R11, R12, R13, R14, R15, R16, \
+	L20, L21, L22, L23, L24, L25, L26, R20, R21, R22, R23, R24, R25, R26, \
+	L30, L31, L32, L33, L34, L35, L36, R30, R31, R32, R33, R34, R35, R36, \
+         L41, L42, L43, L44, L45, L46, R40, R41, R42, R43, R44, R45 \
+) \
+{ \
+	{ L00,   L01,   L02,   L03,   L04,   L05,   L06 }, \
+	{ L10,   L11,   L12,   L13,   L14,   L15,   L16 }, \
+	{ L20,   L21,   L22,   L23,   L24,   L25,   L26 }, \
+	{ L30,   L31,   L32,   L33,   L34,   L35,   L36 }, \
+	{ KC_NO, L41,   L42,   L43,   L44,   L45,   L46 }, \
+	{ R00,   R01,   R02,   R03,   R04,   R05,   R06 }, \
+	{ R10,   R11,   R12,   R13,   R14,   R15,   R16 }, \
+	{ R20,   R21,   R22,   R23,   R24,   R25,   R26 }, \
+	{ R30,   R31,   R32,   R33,   R34,   R35,   R36 }, \
+	{ R40,   R41,   R42,   R43,   R44,   R45, KC_NO }  \
+}
+
+uint8_t current_layer;
+
+extern void led_toggle(int id, bool on);
+void set_all_leds(bool leds[6]);
+extern void set_layer_indicators(uint8_t layer);
+
+#endif

keyboards/ai03/orbit/readme.md

@@ -0,0 +1,15 @@
+# Orbit
+
+![Orbit](https://raw.githubusercontent.com/ai03-2725/Orbit/master/Images/PCB-R2.0.jpg) 
+
+A split ergonomic keyboard project.  
+
+Keyboard Maintainer: [ai03](https://github.com/ai03-2725)  
+Hardware Supported: The [Orbit PCB](https://github.com/ai03-2725/Orbit)  
+Hardware Availability: [This repository](https://github.com/ai03-2725/Orbit) has PCB files. Case group buy orders are currently closed.  
+
+Make example for this keyboard (after setting up your build environment):
+
+    make ai03/orbit: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).

keyboards/ai03/orbit/rules.mk

@@ -0,0 +1,92 @@
+SRC += split_util.c \
+	   split_flags.c \
+	   serial.c \
+	   transport.c \
+	   matrix.c
+
+# MCU name
+#MCU = at90usb1286
+MCU = atmega32u4
+
+# Processor frequency.
+#     This will define a symbol, F_CPU, in all source code files equal to the
+#     processor frequency in Hz. You can then use this symbol in your source code to
+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#     automatically to create a 32-bit value in your source code.
+#
+#     This will be an integer division of F_USB below, as it is sourced by
+#     F_USB after it has run through any CPU prescalers. Note that this value
+#     does not *change* the processor frequency - it should merely be updated to
+#     reflect the processor speed set externally so that the code can use accurate
+#     software delays.
+F_CPU = 16000000
+
+
+#
+# LUFA specific
+#
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+# Input clock frequency.
+#     This will define a symbol, F_USB, in all source code files equal to the
+#     input clock frequency (before any prescaling is performed) in Hz. This value may
+#     differ from F_CPU if prescaling is used on the latter, and is required as the
+#     raw input clock is fed directly to the PLL sections of the AVR for high speed
+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
+#     at the end, this will be done automatically to create a 32-bit value in your
+#     source code.
+#
+#     If no clock division is performed on the input clock inside the AVR (via the
+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
+F_USB = $(F_CPU)
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   atmega32a    bootloadHID
+BOOTLOADER = atmel-dfu
+
+
+# If you don't know the bootloader type, then you can specify the
+# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
+#   Teensy halfKay      512
+#   Teensy++ halfKay    1024
+#   Atmel DFU loader    4096
+#   LUFA bootloader     4096
+#   USBaspLoader        2048
+# OPT_DEFS += -DBOOTLOADER_SIZE=4096
+
+
+# Build Options
+#   change yes to no to disable
+#
+BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = yes       # Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes       # Audio control and System control(+450)
+CONSOLE_ENABLE = no         # Console for debug(+400)
+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 = yes      # Enable keyboard backlight functionality on B7 by default
+RGBLIGHT_ENABLE = no        # Enable keyboard RGB underglow
+MIDI_ENABLE = no            # MIDI support (+2400 to 4200, depending on config)
+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 (+400)
+USE_I2C = no                # I2C for split communication
+CUSTOM_MATRIX = yes			# For providing custom matrix.c (in this case, override regular matrix.c with split matrix.c)
+# SPLIT_KEYBOARD = yes		# Split keyboard flag disabled as manual edits had to be done to the split common files
+
+

keyboards/ai03/orbit/serial.c

@@ -0,0 +1,546 @@
+/*
+ * WARNING: be careful changing this code, it is very timing dependent
+ *
+ * 2018-10-28 checked
+ *  avr-gcc 4.9.2
+ *  avr-gcc 5.4.0
+ *  avr-gcc 7.3.0
+ */
+
+#ifndef F_CPU
+#define F_CPU 16000000
+#endif
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <util/delay.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include "serial.h"
+//#include <pro_micro.h>
+
+#ifdef SOFT_SERIAL_PIN
+
+#ifdef __AVR_ATmega32U4__
+  // if using ATmega32U4 I2C, can not use PD0 and PD1 in soft serial.
+  #ifdef USE_AVR_I2C
+    #if SOFT_SERIAL_PIN == D0 || SOFT_SERIAL_PIN == D1
+      #error Using ATmega32U4 I2C, so can not use PD0, PD1
+    #endif
+  #endif
+
+  #if SOFT_SERIAL_PIN >= D0 && SOFT_SERIAL_PIN <= D3
+    #define SERIAL_PIN_DDR   DDRD
+    #define SERIAL_PIN_PORT  PORTD
+    #define SERIAL_PIN_INPUT PIND
+    #if SOFT_SERIAL_PIN == D0
+      #define SERIAL_PIN_MASK _BV(PD0)
+      #define EIMSK_BIT       _BV(INT0)
+      #define EICRx_BIT       (~(_BV(ISC00) | _BV(ISC01)))
+      #define SERIAL_PIN_INTERRUPT INT0_vect
+    #elif  SOFT_SERIAL_PIN == D1
+      #define SERIAL_PIN_MASK _BV(PD1)
+      #define EIMSK_BIT       _BV(INT1)
+      #define EICRx_BIT       (~(_BV(ISC10) | _BV(ISC11)))
+      #define SERIAL_PIN_INTERRUPT INT1_vect
+    #elif  SOFT_SERIAL_PIN == D2
+      #define SERIAL_PIN_MASK _BV(PD2)
+      #define EIMSK_BIT       _BV(INT2)
+      #define EICRx_BIT       (~(_BV(ISC20) | _BV(ISC21)))
+      #define SERIAL_PIN_INTERRUPT INT2_vect
+    #elif  SOFT_SERIAL_PIN == D3
+      #define SERIAL_PIN_MASK _BV(PD3)
+      #define EIMSK_BIT       _BV(INT3)
+      #define EICRx_BIT       (~(_BV(ISC30) | _BV(ISC31)))
+      #define SERIAL_PIN_INTERRUPT INT3_vect
+    #endif
+  #elif  SOFT_SERIAL_PIN == E6
+    #define SERIAL_PIN_DDR   DDRE
+    #define SERIAL_PIN_PORT  PORTE
+    #define SERIAL_PIN_INPUT PINE
+    #define SERIAL_PIN_MASK  _BV(PE6)
+    #define EIMSK_BIT        _BV(INT6)
+    #define EICRx_BIT        (~(_BV(ISC60) | _BV(ISC61)))
+    #define SERIAL_PIN_INTERRUPT INT6_vect
+  #else
+  #error invalid SOFT_SERIAL_PIN value
+  #endif
+
+#else
+ #error serial.c now support ATmega32U4 only
+#endif
+
+#define ALWAYS_INLINE __attribute__((always_inline))
+#define NO_INLINE __attribute__((noinline))
+#define _delay_sub_us(x)    __builtin_avr_delay_cycles(x)
+
+// parity check
+#define ODD_PARITY 1
+#define EVEN_PARITY 0
+#define PARITY EVEN_PARITY
+
+#ifdef SERIAL_DELAY
+  // custom setup in config.h
+  // #define TID_SEND_ADJUST 2
+  // #define SERIAL_DELAY 6             // micro sec
+  // #define READ_WRITE_START_ADJUST 30 // cycles
+  // #define READ_WRITE_WIDTH_ADJUST 8 // cycles
+#else
+// ============ Standard setups ============
+
+#ifndef SELECT_SOFT_SERIAL_SPEED
+#define SELECT_SOFT_SERIAL_SPEED 1
+//  0: about 189kbps (Experimental only)
+//  1: about 137kbps (default)
+//  2: about 75kbps
+//  3: about 39kbps
+//  4: about 26kbps
+//  5: about 20kbps
+#endif
+
+#if __GNUC__ < 6
+  #define TID_SEND_ADJUST 14
+#else
+  #define TID_SEND_ADJUST 2
+#endif
+
+#if SELECT_SOFT_SERIAL_SPEED == 0
+  // Very High speed
+  #define SERIAL_DELAY 4             // micro sec
+  #if __GNUC__ < 6
+    #define READ_WRITE_START_ADJUST 33 // cycles
+    #define READ_WRITE_WIDTH_ADJUST 3 // cycles
+  #else
+    #define READ_WRITE_START_ADJUST 34 // cycles
+    #define READ_WRITE_WIDTH_ADJUST 7 // cycles
+  #endif
+#elif SELECT_SOFT_SERIAL_SPEED == 1
+  // High speed
+  #define SERIAL_DELAY 6             // micro sec
+  #if __GNUC__ < 6
+    #define READ_WRITE_START_ADJUST 30 // cycles
+    #define READ_WRITE_WIDTH_ADJUST 3 // cycles
+  #else
+    #define READ_WRITE_START_ADJUST 33 // cycles
+    #define READ_WRITE_WIDTH_ADJUST 7 // cycles
+  #endif
+#elif SELECT_SOFT_SERIAL_SPEED == 2
+  // Middle speed
+  #define SERIAL_DELAY 12            // micro sec
+  #define READ_WRITE_START_ADJUST 30 // cycles
+  #if __GNUC__ < 6
+    #define READ_WRITE_WIDTH_ADJUST 3 // cycles
+  #else
+    #define READ_WRITE_WIDTH_ADJUST 7 // cycles
+  #endif
+#elif SELECT_SOFT_SERIAL_SPEED == 3
+  // Low speed
+  #define SERIAL_DELAY 24            // micro sec
+  #define READ_WRITE_START_ADJUST 30 // cycles
+  #if __GNUC__ < 6
+    #define READ_WRITE_WIDTH_ADJUST 3 // cycles
+  #else
+    #define READ_WRITE_WIDTH_ADJUST 7 // cycles
+  #endif
+#elif SELECT_SOFT_SERIAL_SPEED == 4
+  // Very Low speed
+  #define SERIAL_DELAY 36            // micro sec
+  #define READ_WRITE_START_ADJUST 30 // cycles
+  #if __GNUC__ < 6
+    #define READ_WRITE_WIDTH_ADJUST 3 // cycles
+  #else
+    #define READ_WRITE_WIDTH_ADJUST 7 // cycles
+  #endif
+#elif SELECT_SOFT_SERIAL_SPEED == 5
+  // Ultra Low speed
+  #define SERIAL_DELAY 48            // micro sec
+  #define READ_WRITE_START_ADJUST 30 // cycles
+  #if __GNUC__ < 6
+    #define READ_WRITE_WIDTH_ADJUST 3 // cycles
+  #else
+    #define READ_WRITE_WIDTH_ADJUST 7 // cycles
+  #endif
+#else
+#error invalid SELECT_SOFT_SERIAL_SPEED value
+#endif /* SELECT_SOFT_SERIAL_SPEED */
+#endif /* SERIAL_DELAY */
+
+#define SERIAL_DELAY_HALF1 (SERIAL_DELAY/2)
+#define SERIAL_DELAY_HALF2 (SERIAL_DELAY - SERIAL_DELAY/2)
+
+#define SLAVE_INT_WIDTH_US 1
+#ifndef SERIAL_USE_MULTI_TRANSACTION
+  #define SLAVE_INT_RESPONSE_TIME SERIAL_DELAY
+#else
+  #define SLAVE_INT_ACK_WIDTH_UNIT 2
+  #define SLAVE_INT_ACK_WIDTH 4
+#endif
+
+static SSTD_t *Transaction_table = NULL;
+static uint8_t Transaction_table_size = 0;
+
+inline static void serial_delay(void) ALWAYS_INLINE;
+inline static
+void serial_delay(void) {
+  _delay_us(SERIAL_DELAY);
+}
+
+inline static void serial_delay_half1(void) ALWAYS_INLINE;
+inline static
+void serial_delay_half1(void) {
+  _delay_us(SERIAL_DELAY_HALF1);
+}
+
+inline static void serial_delay_half2(void) ALWAYS_INLINE;
+inline static
+void serial_delay_half2(void) {
+  _delay_us(SERIAL_DELAY_HALF2);
+}
+
+inline static void serial_output(void) ALWAYS_INLINE;
+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) ALWAYS_INLINE;
+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) ALWAYS_INLINE;
+inline static
+uint8_t serial_read_pin(void) {
+  return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK);
+}
+
+inline static void serial_low(void) ALWAYS_INLINE;
+inline static
+void serial_low(void) {
+  SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;
+}
+
+inline static void serial_high(void) ALWAYS_INLINE;
+inline static
+void serial_high(void) {
+  SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
+}
+
+void soft_serial_initiator_init(SSTD_t *sstd_table, int sstd_table_size)
+{
+    Transaction_table = sstd_table;
+    Transaction_table_size = (uint8_t)sstd_table_size;
+    serial_output();
+    serial_high();
+}
+
+void soft_serial_target_init(SSTD_t *sstd_table, int sstd_table_size)
+{
+    Transaction_table = sstd_table;
+    Transaction_table_size = (uint8_t)sstd_table_size;
+    serial_input_with_pullup();
+
+    // Enable INT0-INT3,INT6
+    EIMSK |= EIMSK_BIT;
+#if SERIAL_PIN_MASK == _BV(PE6)
+    // Trigger on falling edge of INT6
+    EICRB &= EICRx_BIT;
+#else
+    // Trigger on falling edge of INT0-INT3
+    EICRA &= EICRx_BIT;
+#endif
+}
+
+// Used by the sender to synchronize timing with the reciver.
+static void sync_recv(void) NO_INLINE;
+static
+void sync_recv(void) {
+  for (uint8_t i = 0; i < SERIAL_DELAY*5 && serial_read_pin(); i++ ) {
+  }
+  // This shouldn't hang if the target disconnects because the
+  // serial line will float to high if the target does disconnect.
+  while (!serial_read_pin());
+}
+
+// Used by the reciver to send a synchronization signal to the sender.
+static void sync_send(void) NO_INLINE;
+static
+void sync_send(void) {
+  serial_low();
+  serial_delay();
+  serial_high();
+}
+
+// Reads a byte from the serial line
+static uint8_t serial_read_chunk(uint8_t *pterrcount, uint8_t bit) NO_INLINE;
+static uint8_t serial_read_chunk(uint8_t *pterrcount, uint8_t bit) {
+    uint8_t byte, i, p, pb;
+
+  _delay_sub_us(READ_WRITE_START_ADJUST);
+  for( i = 0, byte = 0, p = PARITY; i < bit; i++ ) {
+      serial_delay_half1();   // read the middle of pulses
+      if( serial_read_pin() ) {
+          byte = (byte << 1) | 1; p ^= 1;
+      } else {
+          byte = (byte << 1) | 0; p ^= 0;
+      }
+      _delay_sub_us(READ_WRITE_WIDTH_ADJUST);
+      serial_delay_half2();
+  }
+  /* recive parity bit */
+  serial_delay_half1();   // read the middle of pulses
+  pb = serial_read_pin();
+  _delay_sub_us(READ_WRITE_WIDTH_ADJUST);
+  serial_delay_half2();
+
+  *pterrcount += (p != pb)? 1 : 0;
+
+  return byte;
+}
+
+// Sends a byte with MSB ordering
+void serial_write_chunk(uint8_t data, uint8_t bit) NO_INLINE;
+void serial_write_chunk(uint8_t data, uint8_t bit) {
+    uint8_t b, p;
+    for( p = PARITY, b = 1<<(bit-1); b ; b >>= 1) {
+        if(data & b) {
+            serial_high(); p ^= 1;
+        } else {
+            serial_low();  p ^= 0;
+        }
+        serial_delay();
+    }
+    /* send parity bit */
+    if(p & 1) { serial_high(); }
+    else      { serial_low(); }
+    serial_delay();
+
+    serial_low(); // sync_send() / senc_recv() need raise edge
+}
+
+static void serial_send_packet(uint8_t *buffer, uint8_t size) NO_INLINE;
+static
+void serial_send_packet(uint8_t *buffer, uint8_t size) {
+  for (uint8_t i = 0; i < size; ++i) {
+    uint8_t data;
+    data = buffer[i];
+    sync_send();
+    serial_write_chunk(data,8);
+  }
+}
+
+static uint8_t serial_recive_packet(uint8_t *buffer, uint8_t size) NO_INLINE;
+static
+uint8_t serial_recive_packet(uint8_t *buffer, uint8_t size) {
+  uint8_t pecount = 0;
+  for (uint8_t i = 0; i < size; ++i) {
+    uint8_t data;
+    sync_recv();
+    data = serial_read_chunk(&pecount, 8);
+    buffer[i] = data;
+  }
+  return pecount == 0;
+}
+
+inline static
+void change_sender2reciver(void) {
+    sync_send();          //0
+    serial_delay_half1(); //1
+    serial_low();         //2
+    serial_input_with_pullup(); //2
+    serial_delay_half1(); //3
+}
+
+inline static
+void change_reciver2sender(void) {
+    sync_recv();     //0
+    serial_delay();  //1
+    serial_low();    //3
+    serial_output(); //3
+    serial_delay_half1(); //4
+}
+
+static inline uint8_t nibble_bits_count(uint8_t bits)
+{
+    bits = (bits & 0x5) + (bits >> 1 & 0x5);
+    bits = (bits & 0x3) + (bits >> 2 & 0x3);
+    return bits;
+}
+
+// interrupt handle to be used by the target device
+ISR(SERIAL_PIN_INTERRUPT) {
+
+#ifndef SERIAL_USE_MULTI_TRANSACTION
+  serial_low();
+  serial_output();
+  SSTD_t *trans = Transaction_table;
+#else
+  // recive transaction table index
+  uint8_t tid, bits;
+  uint8_t pecount = 0;
+  sync_recv();
+  bits = serial_read_chunk(&pecount,7);
+  tid = bits>>3;
+  bits = (bits&7) != nibble_bits_count(tid);
+  if( bits || pecount> 0 || tid > Transaction_table_size ) {
+      return;
+  }
+  serial_delay_half1();
+
+  serial_high(); // response step1 low->high
+  serial_output();
+  _delay_sub_us(SLAVE_INT_ACK_WIDTH_UNIT*SLAVE_INT_ACK_WIDTH);
+  SSTD_t *trans = &Transaction_table[tid];
+  serial_low(); // response step2 ack high->low
+#endif
+
+  // target send phase
+  if( trans->target2initiator_buffer_size > 0 )
+      serial_send_packet((uint8_t *)trans->target2initiator_buffer,
+                         trans->target2initiator_buffer_size);
+  // target switch to input
+  change_sender2reciver();
+
+  // target recive phase
+  if( trans->initiator2target_buffer_size > 0 ) {
+      if (serial_recive_packet((uint8_t *)trans->initiator2target_buffer,
+                               trans->initiator2target_buffer_size) ) {
+          *trans->status = TRANSACTION_ACCEPTED;
+      } else {
+          *trans->status = TRANSACTION_DATA_ERROR;
+      }
+  } else {
+      *trans->status = TRANSACTION_ACCEPTED;
+  }
+
+  sync_recv(); //weit initiator output to high
+}
+
+/////////
+//  start transaction by initiator
+//
+// int  soft_serial_transaction(int sstd_index)
+//
+// Returns:
+//    TRANSACTION_END
+//    TRANSACTION_NO_RESPONSE
+//    TRANSACTION_DATA_ERROR
+// this code is very time dependent, so we need to disable interrupts
+#ifndef SERIAL_USE_MULTI_TRANSACTION
+int  soft_serial_transaction(void) {
+  SSTD_t *trans = Transaction_table;
+#else
+int  soft_serial_transaction(int sstd_index) {
+  if( sstd_index > Transaction_table_size )
+      return TRANSACTION_TYPE_ERROR;
+  SSTD_t *trans = &Transaction_table[sstd_index];
+#endif
+  cli();
+
+  // signal to the target that we want to start a transaction
+  serial_output();
+  serial_low();
+  _delay_us(SLAVE_INT_WIDTH_US);
+
+#ifndef SERIAL_USE_MULTI_TRANSACTION
+  // wait for the target response
+  serial_input_with_pullup();
+  _delay_us(SLAVE_INT_RESPONSE_TIME);
+
+  // check if the target is present
+  if (serial_read_pin()) {
+    // target failed to pull the line low, assume not present
+    serial_output();
+    serial_high();
+    *trans->status = TRANSACTION_NO_RESPONSE;
+    sei();
+    return TRANSACTION_NO_RESPONSE;
+  }
+
+#else
+  // send transaction table index
+  int tid = (sstd_index<<3) | (7 & nibble_bits_count(sstd_index));
+  sync_send();
+  _delay_sub_us(TID_SEND_ADJUST);
+  serial_write_chunk(tid, 7);
+  serial_delay_half1();
+
+  // wait for the target response (step1 low->high)
+  serial_input_with_pullup();
+  while( !serial_read_pin() ) {
+      _delay_sub_us(2);
+  }
+
+  // check if the target is present (step2 high->low)
+  for( int i = 0; serial_read_pin(); i++ ) {
+      if (i > SLAVE_INT_ACK_WIDTH + 1) {
+          // slave failed to pull the line low, assume not present
+          serial_output();
+          serial_high();
+          *trans->status = TRANSACTION_NO_RESPONSE;
+          sei();
+          return TRANSACTION_NO_RESPONSE;
+      }
+      _delay_sub_us(SLAVE_INT_ACK_WIDTH_UNIT);
+  }
+#endif
+
+  // initiator recive phase
+  // if the target is present syncronize with it
+  if( trans->target2initiator_buffer_size > 0 ) {
+      if (!serial_recive_packet((uint8_t *)trans->target2initiator_buffer,
+                                trans->target2initiator_buffer_size) ) {
+          serial_output();
+          serial_high();
+          *trans->status = TRANSACTION_DATA_ERROR;
+          sei();
+          return TRANSACTION_DATA_ERROR;
+      }
+   }
+
+  // initiator switch to output
+  change_reciver2sender();
+
+  // initiator send phase
+  if( trans->initiator2target_buffer_size > 0 ) {
+      serial_send_packet((uint8_t *)trans->initiator2target_buffer,
+                         trans->initiator2target_buffer_size);
+  }
+
+  // always, release the line when not in use
+  sync_send();
+
+  *trans->status = TRANSACTION_END;
+  sei();
+  return TRANSACTION_END;
+}
+
+#ifdef SERIAL_USE_MULTI_TRANSACTION
+int soft_serial_get_and_clean_status(int sstd_index) {
+    SSTD_t *trans = &Transaction_table[sstd_index];
+    cli();
+    int retval = *trans->status;
+    *trans->status = 0;;
+    sei();
+    return retval;
+}
+#endif
+
+#endif
+
+// Helix serial.c history
+//   2018-1-29 fork from let's split and add PD2, modify sync_recv() (#2308, bceffdefc)
+//   2018-6-28 bug fix master to slave comm and speed up (#3255, 1038bbef4)
+//             (adjusted with avr-gcc 4.9.2)
+//   2018-7-13 remove USE_SERIAL_PD2 macro (#3374, f30d6dd78)
+//             (adjusted with avr-gcc 4.9.2)
+//   2018-8-11 add support multi-type transaction (#3608, feb5e4aae)
+//             (adjusted with avr-gcc 4.9.2)
+//   2018-10-21 fix serial and RGB animation conflict (#4191, 4665e4fff)
+//             (adjusted with avr-gcc 7.3.0)
+//   2018-10-28 re-adjust compiler depend value of delay (#4269, 8517f8a66)
+//             (adjusted with avr-gcc 5.4.0, 7.3.0)
+//   2018-12-17 copy to TOP/quantum/split_common/ and remove backward compatibility code (#4669)

keyboards/ai03/orbit/serial.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <stdbool.h>
+
+// /////////////////////////////////////////////////////////////////
+// Need Soft Serial defines in config.h
+// /////////////////////////////////////////////////////////////////
+// ex.
+//  #define SOFT_SERIAL_PIN ??   // ?? = D0,D1,D2,D3,E6
+//  OPTIONAL: #define SELECT_SOFT_SERIAL_SPEED ? // ? = 1,2,3,4,5
+//                                               //  1: about 137kbps (default)
+//                                               //  2: about 75kbps
+//                                               //  3: about 39kbps
+//                                               //  4: about 26kbps
+//                                               //  5: about 20kbps
+//
+// //// USE simple API (using signle-type transaction function)
+//   /* nothing */
+// //// USE flexible API (using multi-type transaction function)
+//   #define SERIAL_USE_MULTI_TRANSACTION
+//
+// /////////////////////////////////////////////////////////////////
+
+// Soft Serial Transaction Descriptor
+typedef struct _SSTD_t  {
+    uint8_t *status;
+    uint8_t initiator2target_buffer_size;
+    uint8_t *initiator2target_buffer;
+    uint8_t target2initiator_buffer_size;
+    uint8_t *target2initiator_buffer;
+} SSTD_t;
+#define TID_LIMIT( table ) (sizeof(table) / sizeof(SSTD_t))
+
+// initiator is transaction start side
+void soft_serial_initiator_init(SSTD_t *sstd_table, int sstd_table_size);
+// target is interrupt accept side
+void soft_serial_target_init(SSTD_t *sstd_table, int sstd_table_size);
+
+// initiator resullt
+#define TRANSACTION_END 0
+#define TRANSACTION_NO_RESPONSE 0x1
+#define TRANSACTION_DATA_ERROR  0x2
+#define TRANSACTION_TYPE_ERROR  0x4
+#ifndef SERIAL_USE_MULTI_TRANSACTION
+int  soft_serial_transaction(void);
+#else
+int  soft_serial_transaction(int sstd_index);
+#endif
+
+// target status
+// *SSTD_t.status has
+//   initiator:
+//       TRANSACTION_END
+//    or TRANSACTION_NO_RESPONSE
+//    or TRANSACTION_DATA_ERROR
+//   target:
+//       TRANSACTION_DATA_ERROR
+//    or TRANSACTION_ACCEPTED
+#define TRANSACTION_ACCEPTED 0x8
+#ifdef SERIAL_USE_MULTI_TRANSACTION
+int  soft_serial_get_and_clean_status(int sstd_index);
+#endif

keyboards/ai03/orbit/split_util.c

@@ -0,0 +1,87 @@
+#include "split_util.h"
+#include "matrix.h"
+#include "keyboard.h"
+#include "config.h"
+#include "timer.h"
+#include "split_flags.h"
+#include "transport.h"
+#include "quantum.h"
+
+#ifdef EE_HANDS
+#   include "tmk_core/common/eeprom.h"
+#   include "eeconfig.h"
+#endif
+
+volatile bool isLeftHand = true;
+
+__attribute__((weak))
+bool is_keyboard_left(void) {
+  #ifdef 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);
+  #else
+    #ifdef EE_HANDS
+      return eeprom_read_byte(EECONFIG_HANDEDNESS);
+    #else
+      #ifdef MASTER_RIGHT
+        return !is_keyboard_master();
+      #else
+        return is_keyboard_master();
+      #endif
+    #endif
+  #endif
+}
+
+bool is_keyboard_master(void)
+{
+#ifdef __AVR__
+  static enum { UNKNOWN, MASTER, SLAVE } usbstate = UNKNOWN;
+
+  // only check once, as this is called often
+  if (usbstate == UNKNOWN)
+  {
+    USBCON |= (1 << OTGPADE);  // enables VBUS pad
+    wait_us(5);
+
+    usbstate = (USBSTA & (1 << VBUS)) ? MASTER : SLAVE;  // checks state of VBUS
+  }
+
+  return (usbstate == MASTER);
+#else
+  return true;
+#endif
+}
+
+static void keyboard_master_setup(void) {
+#if defined(USE_I2C) || defined(EH)
+  #ifdef SSD1306OLED
+    matrix_master_OLED_init ();
+  #endif
+#endif
+  transport_master_init();
+
+  // For master the Backlight info needs to be sent on startup
+  // Otherwise the salve won't start with the proper info until an update
+  BACKLIT_DIRTY = true;
+}
+
+static void keyboard_slave_setup(void)
+{
+  transport_slave_init();
+}
+
+// this code runs before the usb and keyboard is initialized
+void matrix_setup(void)
+{
+  isLeftHand = is_keyboard_left();
+
+  if (is_keyboard_master())
+  {
+    keyboard_master_setup();
+  }
+  else
+  {
+    keyboard_slave_setup();
+  }
+}

keyboards/ai03/orbit/split_util.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+extern volatile bool isLeftHand;
+
+void matrix_master_OLED_init (void);

keyboards/ai03/orbit/transport.c

@@ -0,0 +1,238 @@
+
+#include "transport.h"
+
+#include "config.h"
+#include "matrix.h"
+#include "quantum.h"
+
+#include "orbit.h"
+
+#define ROWS_PER_HAND (MATRIX_ROWS/2)
+
+#ifdef RGBLIGHT_ENABLE
+#   include "rgblight.h"
+#endif
+
+#ifdef BACKLIGHT_ENABLE
+# include "backlight.h"
+  extern backlight_config_t backlight_config;
+#endif
+
+#if defined(USE_I2C) || defined(EH)
+
+#include "i2c.h"
+
+#ifndef SLAVE_I2C_ADDRESS
+#  define SLAVE_I2C_ADDRESS           0x32
+#endif
+
+#if (MATRIX_COLS > 8)
+#  error "Currently only supports 8 COLS"
+#endif
+
+// Get rows from other half over i2c
+bool transport_master(matrix_row_t matrix[]) {
+  int err = 0;
+
+  // write backlight info
+#ifdef BACKLIGHT_ENABLE
+  if (BACKLIT_DIRTY) {
+    err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
+    if (err) { goto i2c_error; }
+
+    // Backlight location
+    err = i2c_master_write(I2C_BACKLIT_START);
+    if (err) { goto i2c_error; }
+
+    // Write backlight
+    i2c_master_write(get_backlight_level());
+
+    BACKLIT_DIRTY = false;
+  }
+#endif
+
+  err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
+  if (err) { goto i2c_error; }
+
+  // start of matrix stored at I2C_KEYMAP_START
+  err = i2c_master_write(I2C_KEYMAP_START);
+  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[i] = i2c_master_read(I2C_ACK);
+    }
+    matrix[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 false;
+  }
+
+#ifdef RGBLIGHT_ENABLE
+  if (RGB_DIRTY) {
+    err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
+    if (err) { goto i2c_error; }
+
+    // RGB Location
+    err = i2c_master_write(I2C_RGB_START);
+    if (err) { goto i2c_error; }
+
+    uint32_t dword = eeconfig_read_rgblight();
+
+    // Write RGB
+    err = i2c_master_write_data(&dword, 4);
+    if (err) { goto i2c_error; }
+
+    RGB_DIRTY = false;
+    i2c_master_stop();
+  }
+#endif
+
+  return true;
+}
+
+void transport_slave(matrix_row_t matrix[]) {
+
+  for (int i = 0; i < ROWS_PER_HAND; ++i)
+  {
+    i2c_slave_buffer[I2C_KEYMAP_START + i] = matrix[i];
+  }
+  // Read Backlight Info
+  #ifdef BACKLIGHT_ENABLE
+  if (BACKLIT_DIRTY)
+  {
+    backlight_set(i2c_slave_buffer[I2C_BACKLIT_START]);
+    BACKLIT_DIRTY = false;
+  }
+  #endif
+  #ifdef RGBLIGHT_ENABLE
+  if (RGB_DIRTY)
+  {
+    // Disable interupts (RGB data is big)
+    cli();
+    // Create new DWORD for RGB data
+    uint32_t dword;
+
+    // Fill the new DWORD with the data that was sent over
+    uint8_t * dword_dat = (uint8_t *)(&dword);
+    for (int i = 0; i < 4; i++)
+    {
+      dword_dat[i] = i2c_slave_buffer[I2C_RGB_START + i];
+    }
+
+    // Update the RGB now with the new data and set RGB_DIRTY to false
+    rgblight_update_dword(dword);
+    RGB_DIRTY = false;
+    // Re-enable interupts now that RGB is set
+    sei();
+  }
+  #endif
+}
+
+void transport_master_init(void) {
+  i2c_master_init();
+}
+
+void transport_slave_init(void) {
+  i2c_slave_init(SLAVE_I2C_ADDRESS);
+}
+
+#else // USE_SERIAL
+
+#include "serial.h"
+
+
+
+volatile Serial_s2m_buffer_t serial_s2m_buffer = {};
+volatile Serial_m2s_buffer_t serial_m2s_buffer = {};
+uint8_t volatile status0 = 0;
+
+SSTD_t transactions[] = {
+  { (uint8_t *)&status0,
+    sizeof(serial_m2s_buffer), (uint8_t *)&serial_m2s_buffer,
+    sizeof(serial_s2m_buffer), (uint8_t *)&serial_s2m_buffer
+  }
+};
+
+uint8_t slave_layer_cache;
+uint8_t slave_nlock_cache;
+uint8_t slave_clock_cache;
+uint8_t slave_slock_cache;
+
+void transport_master_init(void)
+{ soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); }
+
+void transport_slave_init(void)
+{ 
+	soft_serial_target_init(transactions, TID_LIMIT(transactions)); 
+	slave_layer_cache = 255;
+	slave_nlock_cache = 255;
+	slave_clock_cache = 255;
+	slave_slock_cache = 255;
+}
+
+bool transport_master(matrix_row_t matrix[]) {
+
+  if (soft_serial_transaction()) {
+    return false;
+  }
+
+  // TODO:  if MATRIX_COLS > 8 change to unpack()
+  for (int i = 0; i < ROWS_PER_HAND; ++i) {
+    matrix[i] = serial_s2m_buffer.smatrix[i];
+  }
+
+  #if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
+    // Code to send RGB over serial goes here (not implemented yet)
+  #endif
+
+  #ifdef BACKLIGHT_ENABLE
+    // Write backlight level for slave to read
+    serial_m2s_buffer.backlight_level = backlight_config.enable ? backlight_config.level : 0;
+  #endif
+
+  return true;
+}
+
+void transport_slave(matrix_row_t matrix[]) {
+
+  // TODO: if MATRIX_COLS > 8 change to pack()
+  for (int i = 0; i < ROWS_PER_HAND; ++i)
+  {
+    serial_s2m_buffer.smatrix[i] = matrix[i];
+  }
+  #ifdef BACKLIGHT_ENABLE
+    backlight_set(serial_m2s_buffer.backlight_level);
+  #endif
+  #if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
+  // Add serial implementation for RGB here
+  #endif
+  
+  if (slave_layer_cache != serial_m2s_buffer.current_layer) {  
+	slave_layer_cache = serial_m2s_buffer.current_layer;
+	set_layer_indicators(slave_layer_cache);
+  }
+  
+  if (slave_nlock_cache != serial_m2s_buffer.nlock_led) {
+	slave_nlock_cache = serial_m2s_buffer.nlock_led;
+	led_toggle(3, slave_nlock_cache);
+  }
+  if (slave_clock_cache != serial_m2s_buffer.clock_led) {
+	slave_clock_cache = serial_m2s_buffer.clock_led;
+	led_toggle(4, slave_clock_cache);
+  }
+  if (slave_slock_cache != serial_m2s_buffer.slock_led) {
+	slave_slock_cache = serial_m2s_buffer.slock_led;
+	led_toggle(5, slave_slock_cache);
+  }
+  
+}
+
+#endif

keyboards/ai03/orbit/transport.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <common/matrix.h>
+
+#define ROWS_PER_HAND (MATRIX_ROWS/2)
+
+typedef struct _Serial_s2m_buffer_t {
+  // TODO: if MATRIX_COLS > 8 change to uint8_t packed_matrix[] for pack/unpack
+  matrix_row_t smatrix[ROWS_PER_HAND];
+} Serial_s2m_buffer_t;
+
+typedef struct _Serial_m2s_buffer_t {
+#ifdef BACKLIGHT_ENABLE
+    uint8_t backlight_level;
+#endif
+#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
+    rgblight_config_t rgblight_config; //not yet use
+    //
+    // When MCUs on both sides drive their respective RGB LED chains,
+    // it is necessary to synchronize, so it is necessary to communicate RGB information.
+    // In that case, define the RGBLIGHT_SPLIT macro.
+    //
+    // Otherwise, if the master side MCU drives both sides RGB LED chains,
+    // there is no need to communicate.
+#endif
+
+	uint8_t current_layer;
+	uint8_t nlock_led;
+	uint8_t clock_led;
+	uint8_t slock_led;
+
+} Serial_m2s_buffer_t;
+
+extern volatile Serial_s2m_buffer_t serial_s2m_buffer;
+extern volatile Serial_m2s_buffer_t serial_m2s_buffer;
+
+void transport_master_init(void);
+void transport_slave_init(void);
+
+// returns false if valid data not received from slave
+bool transport_master(matrix_row_t matrix[]);
+void transport_slave(matrix_row_t matrix[]);

keyboards/alice/program

@@ -1,106 +0,0 @@
-#!/usr/bin/env python
-# Copyright 2017 Luiz Ribeiro <luizribeiro@gmail.com>, Sebastian Kaim <sebb@sebb767.de>
-#
-# 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/>.
-
-from __future__ import print_function
-
-import os
-import sys
-import time
-import usb
-
-
-def checkForKeyboardInNormalMode():
-    """Returns a device if a ps2avrGB device in normal made (that is in keyboard mode) or None if it is not found."""
-    return usb.core.find(idVendor=0x20A0, idProduct=0x422D)
-
-def checkForKeyboardInBootloaderMode():
-    """Returns True if a ps2avrGB device in bootloader (flashable) mode is found and False otherwise."""
-    return (usb.core.find(idVendor=0x16c0, idProduct=0x05df) is not None)
-
-def flashKeyboard(firmware_file):
-    """Calls bootloadHID to flash the given file to the device."""
-    print('Flashing firmware to device ...')
-    if os.system('bootloadHID -r "%s"' % firmware_file) == 0:
-        print('\nDone!')
-    else:
-        print('\nbootloadHID returned an error.')
-
-def printDeviceInfo(dev):
-    """Prints all infos for a given USB device"""
-    print('Device Information:')
-    print('  idVendor: %d (0x%04x)' % (dev.idVendor, dev.idVendor))
-    print('  idProduct: %d (0x%04x)' % (dev.idProduct, dev.idProduct))
-    print('Manufacturer: %s' % (dev.iManufacturer))
-    print('Serial: %s' % (dev.iSerialNumber))
-    print('Product: %s' % (dev.iProduct), end='\n\n')
-
-def sendDeviceToBootloaderMode(dev):
-    """Tries to send a given ps2avrGB keyboard to bootloader mode to allow flashing."""
-    try:
-        dev.set_configuration()
-
-        request_type = usb.util.build_request_type(
-                usb.util.CTRL_OUT,
-                usb.util.CTRL_TYPE_CLASS,
-                usb.util.CTRL_RECIPIENT_DEVICE)
-
-        USBRQ_HID_SET_REPORT = 0x09
-        HID_REPORT_OPTION = 0x0301
-
-        dev.ctrl_transfer(request_type, USBRQ_HID_SET_REPORT, HID_REPORT_OPTION, 0, [0, 0, 0xFF] + [0] * 5)
-    except usb.core.USBError:
-        # for some reason I keep getting USBError, but it works!
-        pass
-
-
-if len(sys.argv) < 2:
-    print('Usage: %s <firmware.hex>' % sys.argv[0])
-    sys.exit(1)
-
-kb = checkForKeyboardInNormalMode()
-
-if kb is not None:
-    print('Found a keyboard in normal mode. Attempting to send it to bootloader mode ...', end='')
-    printDeviceInfo(kb)
-    sendDeviceToBootloaderMode(kb)
-    print(' done.')
-    print("Hint: If your keyboard can't be set to bootloader mode automatically, plug it in while pressing the bootloader key to do so manually.")
-    print("      You can find more infos about this here: https://github.com/qmk/qmk_firmware/tree/master/keyboards/ps2avrGB#setting-the-board-to-bootloader-mode")
-
-attempts = 12  # 60 seconds
-found = False
-for attempt in range(1, attempts + 1):
-    print("Searching for keyboard in bootloader mode (%i/%i) ... " % (attempt, attempts), end='')
-
-    if checkForKeyboardInBootloaderMode():
-        print('Found', end='\n\n')
-        flashKeyboard(sys.argv[1])
-        found = True
-        break
-    else:
-        print('Nothing.', end='')
-
-        if attempt != attempts:  # no need to wait on the last attempt
-            print(' Sleeping 5 seconds.', end='')
-            time.sleep(5)
-
-        # print a newline
-        print()
-
-if not found:
-    print("Couldn't find a flashable keyboard. Aborting.")
-    sys.exit(2)
-

keyboards/alice/rules.mk

@@ -45,4 +45,4 @@ OPT_DEFS = -DDEBUG_LEVEL=0
 SRC += i2c_master.c
 
 # programming options
-PROGRAM_CMD = ./keyboards/ps2avrGB/program $(TARGET).hex
+PROGRAM_CMD = ./util/atmega32a_program.py $(TARGET).hex

keyboards/atreus/keymaps/default/keymap.c

@@ -38,7 +38,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    */
   [_LW] = LAYOUT( /* [> LOWER <] */
     KC_INS,  KC_HOME, KC_UP,   KC_END,  KC_PGUP,                   KC_UP,   KC_F7,   KC_F8,   KC_F9,   KC_F10  ,
-    KC_DELT, KC_LEFT, KC_DOWN, KC_RGHT, KC_DOWN,                   KC_DOWN, KC_F4,   KC_F5,   KC_F6,   KC_F11  ,
+    KC_DELT, KC_LEFT, KC_DOWN, KC_RGHT, KC_PGDN,                   KC_DOWN, KC_F4,   KC_F5,   KC_F6,   KC_F11  ,
     KC_NO,   KC_VOLU, KC_NO,   KC_NO,   RESET,                     KC_NO,   KC_F1,   KC_F2,   KC_F3,   KC_F12  ,
     KC_NO,   KC_VOLD, KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_LALT, KC_SPC,  TO(_QW), KC_PSCR, KC_SLCK, KC_PAUS )
 };

keyboards/atreus/keymaps/yttyx/README.md

@@ -1,77 +1,103 @@
 # Overview
 
-A Balance 12 layout for the Atreus keyboard.
+This layout is based on Balance Twelve (mirror variant) by Sasha Viminitz. Please see [this page](https://mathematicalmulticore.wordpress.com/the-keyboard-layout-project/) 
+for more information. It's designed for left-handers who use their right hand for the mouse.
 
-Balance 12 was created by Sasha Viminitz. Please see [this page](https://mathematicalmulticore.wordpress.com/the-keyboard-layout-project/)
-for some background on the design of the layout.
+## To build
 
-* The variant used here is a mirror of the original for left-handers
-* The central column of punctuation keys has been moved elsewhere
-* Home positions for the left and right forefingers are *T* and *A* respectively
+```
+sudo make atreus:yttyx
+```
 
-## To build/flash
+## To flash (example)
 
-> make atreus:yttyx:avrdude
+```
+sudo avrdude -p atmega32u4 -c avr109 -U flash:w:atreus_yttyx.hex -P /dev/ttyACM0
+```
 
 ## Layers
 
 ### Base:
 
-      .----------------------------------.         .------------------------------.
-      | P    | L    | C    | D   | W     |         | U    | O   | Y   | K   | Q   |
-      +------+------+------+-----+-------|         |------+-----+-----+-----+-----|
-      | N    | R    | S    | T   | M     |         | A    | E   | I   | H   | V   |
-      +------+------+------+-----+-------|         |------+-----+-----+-----+-----|
-      | Z    | J    | F    | G   | B     |         | ,    | .   | ;   | X   | -   |
-      +------+------+------+-----+-------+---------+------+-----+-----+-----+-----|
-      | Shft | Ctl  | Alt  | BS  | Space | L1 | R1 | Shft | R2  | Win | Ctl | Alt |
-      '---------------------------------------------------------------------------'
+    .--------.-------.-------.-------.--------.                           .-------.-------.-------.-------.------.
+    | P      | L     | C     | D     | W      |                           | U     | O     | Y     | K     | Q    |
+    |--------+-------+-------+-------+--------|                           |-------+-------+-------+-------+------|
+    | N      | R     | S     | T     | M      |                           | A     | E     | I     | H     | V    |
+    |--------+-------+-------+-------+--------|                           |-------+-------+-------+-------+------|
+    | Z Sft  | J Ctl | F Alt | G     | B      |                           | ,     | . Alt | ; Ctl | X Sft | Sup  |
+    '--------'-------'-------+-------+--------+-----.               .-----+-------+-------+-------'-------'------'
+                             | BS P1 | Spc P2 | P3  |               |     | Sft   |       |
+                             '-------'--------'-----'               '-----'-------'-------'
 
-### L1:
+### P1: Punctuation (1)
 
-      .---------------------------------.         .--------------------------------.
-      | 1    | 2    | 3    | 4  | 5     |         | 6    | 7  | 8   | 9    | 0     |
-      |------+------+------+----+-------|         |------+----+-----+------+-------|
-      | Tab  | ?    | =    | -  | _     |         | '    | "  | +   | *    | Enter |
-      |------+------+------+----+-------|         |------+----+-----+------+-------|
-      | Esc  | !    | &    |    |       |         | ,    | .  | ;   |      | -     |
-      |------+------+------+----+-------+---------+------+----+-----+------+-------|
-      | Shft | Ctrl | Alt  | Bk | Space | L1 | R1 | Shft | R2 | Sup | Ctrl | Alt   |
-      '----------------------------------------------------------------------------'
 
-### R1:
+    .--------.-------.-------.-------.-------.                              .------.-------.-------.-------.------.
+    | Esc    |       |       |       | RS    |                              | |    | /     | ^     | <20>     |  ~   |
+    |--------+-------+-------+-------+-------|                              |------+-------+-------+-------+------|
+    | Tab    |       |       |       |       |                              | &    | \     | `     | $     | Ent  |
+    |--------+-------+-------+-------+-------|                              |------+-------+-------+-------+------|
+    | Sft    | Ctl   | Alt   | Del   |       |                              | %    | Alt   | Ctl   | Sft   | Sup  |
+    '--------'-------'-------+-------+-------+-----.                  .-----+------+-------+-------'-------'------'
+                             | P1    |       |     |                  |     | Sft  |       |
+                             '-------'-------'-----'                  '-----'------'-------'
 
-      .---------------------------------.         .-------------------------------.
-      | <    | >    | {   | }   | @     |         | $    | <20>  |     |      | R3   |
-      +------+------+-----+-----|-------|         |------+----+-----+------+------|
-      | [    | ]    | (   | )   | #     |         | '    | "  | ~   | `    | Caps |
-      |------+------+-----+-----+-------|         |------+----+-----+------+------|
-      | /    | \    | ^   | |   | %     |         | ,    | .  | ;   |      | PScn |
-      |------+------+-----+-----+-------+---------+------+----+-----+------+------|
-      | Shft | Ctrl | Alt | Del | Space | L1 | R1 | Shft | R2 | Sup | Ctrl | Alt  |
-      '---------------------------------------------------------------------------'
+### P2: Punctuation (2)
 
-### R2:
+    .-------.-------.-------.-------.-------.                               .-------.-------.-------.-------.------.
+    | Esc   |       | NC    | FV    |       |                               | (     | )     | "     | ?     |      |
+    |-------+-------+-------+-------+-------|                               |-------+-------+-------+-------+------|
+    | Tab   | Ctl-X | Ctl-C | Ctl-V | Ctl-Z |                               | {     | }     | '     | !     | Ent  |
+    |-------+-------+-------+-------+-------|                               |-------+-------+-------+-------+------|
+    | Sft   | Ctl   | Alt   | Del   | Ent   |                               | #     | Alt   | Ctl   | Sft   | Sup  |
+    '-------'-------'-------+-------+-------+-----.                   .-----+-------+-------+-------'-------'------'
+                            | BS    | P2    |     |                   |     | Sft   |       |
+                            '-------'-------'-----'                   '-----'-------'-------'
 
-      .-----------------------------------.         .--------------------.-----------------.
-      | F12  | F11  | F10  | F9   | Copy  |         | Home | Up   | End  | PgUp | Insert   |
-      |------+------+------+------+-------|         |------+------+------+------+----------|
-      | F8   | F7   | F6   | F5   | Paste |         | Left | Down | Right| PgDn | Enter    |
-      |------+------+------+------+-------|         |------+------+------+------+----------|
-      | F4   | F3   | F2   | F1   | Cut   |         | ^Tab |      | Tab  |      |          |
-      |------+------+------+------+-------+---------+------+------+------+------+----------|
-      | Shft | Ctrl | Alt  | Del  | Undo  | L1 | R1 | Shft | R2   | Sup  | Ctrl | WinRight |
-      '------------------------------------------------------------------------------------'
+### P3: Punctuation (3)
 
-### R3:
+    .-------.-------.-------.-------.-------.                             .------.-------.-------.-------.------.
+    | Esc   |       | Break | Pscr  | ScLk  |                             | <    | >     | +     | _     | =    |
+    |-------+-------+-------+-------+-------|                             |------+-------+-------+-------+------|
+    | Tab   |       |       | Caps  |       |                             | [    | ]     | *     | -     | Ent  |
+    |-------+-------+-------+-------+-------|                             |------+-------+-------+-------+------|
+    | Sft   | Ctl   | Alt   | Del   |       |                             | @    | Alt   | Ctl   | Sft   | Sup  |
+    '-------'-------'-------+-------+-------+-----.                 .-----+------+-------+-------'-------'------'
+                            | BS    |       | P3  |                 |     | Sft  |       |
+                            '-------'-------'-----'                 '-----'------'-------'
 
-      .----------------------------.         .------------------------.
-      | RESET |    |     |    |    |         |    |    |    |    | R3 |
-      |-------+----+-----+----+----|         |----+----+----+----+----|
-      |       |    |     |    |    |         |    |    |    |    |    |
-      |-------+----+-----+----+----|         |----+----+----+----+----|
-      |       |    |     |    |    |         |    |    |    |    |    |
-      |-------+----+-----+----+----+---------+----+----+----+----+----|
-      |       |    |     |    |    |    |    |    |    |    |    |    |
-      '---------------------------------------------------------------'
+### Numerals / Cursor control
 
+    .-------.-------.-------.------.-------.                              .------.-------.-------.------.------.
+    | 1     | 2     | 3     | 4    | 5     |                              | Home | Up    | End   | PgUp |      |
+    |-------+-------+-------+------+-------|                              |------+-------+-------+------+------|
+    | 6     | 7     | 8     | 9    | 0     |                              | Left | Down  | Right | PgDn |      |
+    |-------+-------+-------+------+-------|                              |------+-------+-------+------+------|
+    | Sft   | Ctl   | Alt   | Del  | .     |                              | Ins  | Alt   | Ctl   | Sft  | Sup  |
+    '-------'-------'-------+------+-------+-----.                  .-----+------+-------+-------'------'------'
+                            | BS   | BA    |     |                  |     | Sft  |       |
+                            '------'-------'-----'                  '-----'------'-------'
+
+### FV: Function keys / Cursor control (Vim)
+
+    .-------.------.-------.-----.-------.                                .------.-------.-----.-------.------.
+    | F1    | F2   | F3    | F4  | F5    |                                | 0    | K     | $   | Ctl-B |      |
+    |-------+------+-------+-----+-------|                                |------+-------+-----+-------+------|
+    | F6    | F7   | F8    | F9  | F10   |                                | H    | J     | L   | Ctl-F |      |
+    |-------+------+-------+-----+-------|                                |------+-------+-----+-------+------|
+    | Sft   | Ctl  | Alt   | F11 | F12   |                                |      | Alt   | Ctl | Sft   | Sup  |
+    '-------'------'-------+-----+-------+-----.                    .-----+------+-------+-----'-------'------'
+                           | BS  | BA    |     |                    |     | Sft  |       |
+                           '-----'-------'-----'                    '-----'------'-------'
+
+### RS: Reset
+
+    .-------.------.-------.-----.-------.                                .------.-------.-----.-------.------.
+    | RESET |      |       |     |       |                                |      |       |     |       |      |
+    |-------+------+-------+-----+-------|                                |------+-------+-----+-------+------|
+    |       |      |       |     |       |                                |      |       |     |       |      |
+    |-------+------+-------+-----+-------|                                |------+-------+-----+-------+------|
+    |       |      |       |     |       |                                |      |       |     |       |      |
+    '-------'------'-------+-----+-------+-----.                    .-----+------+-------+-----'-------'------'
+                           |     | BA    |     |                    |     |      |       |
+                           '-----'-------'-----'                    '-----'------'-------'

keyboards/atreus/keymaps/yttyx/config.h

@@ -1,12 +1,4 @@
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#define ONESHOT_TIMEOUT       500   // Time (in ms) before the one shot key is released
-
-// Disable some options to reduce firmware size
-#define NO_PRINT
-#define NO_ACTION_TAPPING
+#pragma once
+#define NO_ACTION_ONESHOT
 #define NO_ACTION_MACRO
 #define NO_ACTION_FUNCTION
-
-#endif

keyboards/atreus/keymaps/yttyx/keymap.c

@@ -2,115 +2,158 @@
 #include QMK_KEYBOARD_H
 
 enum layers {
-  BASE,         // Balance Twelve
-  L1,           // (momentary)
-  R1,           // (momentary)
-  R2,           // (momentary)
-  R3            // (momentary)
+  BA,           // Base (Balance Twelve mirror variant)
+  P1,           // Punctuation (1)
+  P2,           // Punctuation (2)
+  P3,           // Punctuation (2)
+  NC,           // Numerals / Cursor control
+  FV,           // Function keys / Cursor control (Vim)
+  RS            // Reset
 };
 
-// Aliases from replicaJunction's atreus layout
-#define KCX_LST   LSFT(KC_TAB)
-#define KX_COPY   LCTL(KC_C)
-#define KX_CUT    LCTL(KC_X)
-#define KX_PAST   LCTL(KC_V)
-#define KX_UNDO   LCTL(KC_Z)
+// Abbreviations - base
+#define KX_P1_BSPC      LT(P1, KC_BSPC)
+#define KX_P2_SPC       LT(P2, KC_SPC)
 
-#define KX_AT     LSFT(KC_QUOT)
-#define KX_PIPE   LSFT(KC_NUBS)
-#define KX_WINR   LSFT(LGUI(KC_RGHT))   // Move window to next monitor (Windows)
+#define KX_SFT_Z        MT(MOD_LSFT, KC_Z)
+#define KX_CTL_J        MT(MOD_LCTL, KC_J)
+#define KX_ALT_F        MT(MOD_LALT, KC_F)
 
+#define KX_ALT_DOT      MT(MOD_LALT, KC_DOT)
+#define KX_CTL_SCLN     MT(MOD_LCTL, KC_SCLN)
+#define KX_SFT_X        MT(MOD_LSFT, KC_X)
 
+#define KX_AT           LSFT(KC_QUOT)
+#define KX_DQUOT        LSFT(KC_2)
+#define KX_PIPE         LSFT(KC_NUBS)
+#define KX_TILDA        LSFT(KC_NUHS)
+
+ 
 const uint16_t PROGMEM keymaps[][ MATRIX_ROWS ][ MATRIX_COLS ] = {
-
- /* Balance Twelve mirror variant (left-handed)
-  .--------------------------------.         .------------------------------.
-  | P    | L    | C   | D  | W     |         | U    | O  | Y   | K    | Q   |
-  +------+------+-----+----+-------|         |------+----+-----+------+-----|
-  | N    | R    | S   | T  | M     |         | A    | E  | I   | H    | V   |
-  +------+------+-----+----+-------|         |------+----+-----+------+-----|
-  | Z    | J    | F   | G  | B     |         | ,    | .  | ;   | X    | -   |
-  +------+------+-----+----+-------+---------+------+----+-----+------+-----|
-  | Shft | Ctrl | Alt | Bk | Space | L1 | R1 | Shft | R2 | Win | Ctrl | Alt |
-  '-------------------------------------------------------------------------'
-  */
-  [BASE] = LAYOUT(
-    KC_P,    KC_L,    KC_C,    KC_D,    KC_W,                   KC_U,          KC_O,   KC_Y,    KC_K,    KC_Q,
-    KC_N,    KC_R,    KC_S,    KC_T,    KC_M,                   KC_A,          KC_E,   KC_I,    KC_H,    KC_V,
-    KC_Z,    KC_J,    KC_F,    KC_G,    KC_B,                   KC_COMM,       KC_DOT, KC_SCLN, KC_X,    KC_MINS,
-    KC_LSFT, KC_LCTL, KC_LALT, KC_BSPC, KC_SPC, MO(L1), MO(R1), OSM(MOD_LSFT), MO(R2), KC_LWIN, KC_RCTL, KC_RALT
+  /*
+    .--------.-------.-------.-------.--------.                           .-------.-------.-------.-------.------.
+    | P      | L     | C     | D     | W      |                           | U     | O     | Y     | K     | Q    |
+    |--------+-------+-------+-------+--------|                           |-------+-------+-------+-------+------|
+    | N      | R     | S     | T     | M      |                           | A     | E     | I     | H     | V    |
+    |--------+-------+-------+-------+--------|                           |-------+-------+-------+-------+------|
+    | Z Sft  | J Ctl | F Alt | G     | B      |                           | ,     | . Alt | ; Ctl | X Sft | Sup  |
+    '--------'-------'-------+-------+--------+-----.               .-----+-------+-------+-------'-------'------'
+                             | BS P1 | Spc P2 | P3  |               |     | Sft   |       |
+                             '-------'--------'-----'               '-----'-------'-------'
+  */                                                               
+  [BA] = LAYOUT(                                                   
+    KC_P,     KC_L,     KC_C,     KC_D,       KC_W,                          KC_U,    KC_O,       KC_Y,        KC_K,     KC_Q,
+    KC_N,     KC_R,     KC_S,     KC_T,       KC_M,                          KC_A,    KC_E,       KC_I,        KC_H,     KC_V,
+    KX_SFT_Z, KX_CTL_J, KX_ALT_F, KC_G,       KC_B,                          KC_COMM, KX_ALT_DOT, KX_CTL_SCLN, KX_SFT_X, KC_LGUI,
+    XXXXXXX,  XXXXXXX,  XXXXXXX,  KX_P1_BSPC, KX_P2_SPC, MO(P3),    XXXXXXX, KC_RSFT, XXXXXXX,    XXXXXXX,     XXXXXXX,  XXXXXXX
   ),
 
- /* L1
-  .---------------------------------.         .--------------------------------.
-  | 1    | 2    | 3    | 4  | 5     |         | 6    | 7  | 8   | 9    | 0     |
-  |------+------+------+----+-------|         |------+----+-----+------+-------|
-  | Tab  | ?    | =    | -  | _     |         | '    | "  | +   | *    | Enter |
-  |------+------+------+----+-------|         |------+----+-----+------+-------|
-  | Esc  | !    | &    |    |       |         | ,    | .  | ;   |      | -     |
-  |------+------+------+----+-------+---------+------+----+-----+------+-------|
-  | Shft | Ctrl | Alt  | Bk | Space | L1 | R1 | Shft | R2 | Sup | Ctrl | Alt   |
-  '----------------------------------------------------------------------------'
+  /* P1: Punctuation (1)
+    .--------.-------.-------.-------.-------.                              .------.-------.-------.-------.------.
+    | Esc    |       |       |       | RS    |                              | |    | /     | ^     | <EFBFBD>     |  ~   |
+    |--------+-------+-------+-------+-------|                              |------+-------+-------+-------+------|
+    | Tab    |       |       |       |       |                              | &    | \     | `     | $     | Ent  |
+    |--------+-------+-------+-------+-------|                              |------+-------+-------+-------+------|
+    | Sft    | Ctl   | Alt   | Del   |       |                              | %    | Alt   | Ctl   | Sft   | Sup  |
+    '--------'-------'-------+-------+-------+-----.                  .-----+------+-------+-------'-------'------'
+                             | P1    |       |     |                  |     | Sft  |       |
+                             '-------'-------'-----'                  '-----'------'-------'
   */
-  [L1] = LAYOUT(
-    KC_1,    KC_2,    KC_3,    KC_4,    KC_5,                      KC_6,    KC_7,       KC_8,    KC_9,    KC_0,
-    KC_TAB,  KC_QUES, KC_EQL,  KC_MINS, KC_UNDS,                   KC_QUOT, LSFT(KC_2), KC_PLUS, KC_ASTR, KC_ENT,
-    KC_ESC,  KC_EXLM, KC_AMPR, XXXXXXX, XXXXXXX,                   _______, _______,    _______, XXXXXXX, _______,
-    _______, _______, _______, _______, _______, _______, _______, _______, _______,    _______, _______, _______
+  [P1] = LAYOUT(
+    KC_ESC,  XXXXXXX,    XXXXXXX,    XXXXXXX,  TO(RS),                         KX_PIPE, KC_SLSH, KC_CIRC, KC_HASH, KX_TILDA,  
+    KC_TAB,  XXXXXXX,    XXXXXXX,    XXXXXXX,  XXXXXXX,                        KC_AMPR, KC_NUBS, KC_GRV,  KC_DLR,  KC_ENT,
+    KC_LSFT, KC_LCTL,    KC_LALT,    KC_DEL,   XXXXXXX,                        KC_PERC, KC_LALT, KC_LCTL, KC_LSFT, _______,
+    XXXXXXX, XXXXXXX,    XXXXXXX,    _______,  XXXXXXX, XXXXXXX,      XXXXXXX, _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX
   ),
 
- /* R1
-  .---------------------------------.         .-------------------------------.
-  | <    | >    | {   | }   | @     |         | $    | <EFBFBD>  |     |      | R3   |
-  +------+------+-----+-----|-------|         |------+----+-----+------+------|
-  | [    | ]    | (   | )   | #     |         | '    | "  | ~   | `    | Caps |
-  |------+------+-----+-----+-------|         |------+----+-----+------+------|
-  | /    | \    | ^   | |   | %     |         | ,    | .  | ;   |      | PScn |
-  |------+------+-----+-----+-------+---------+------+----+-----+------+------|
-  | Shft | Ctrl | Alt | Del | Space | L1 | R1 | Shft | R2 | Sup | Ctrl | Alt  |
-  '---------------------------------------------------------------------------'
+  /* P2: Punctuation (2)
+    .-------.-------.-------.-------.-------.                               .-------.-------.-------.-------.------.
+    | Esc   |       | NC    | FV    |       |                               | (     | )     | "     | ?     |      |
+    |-------+-------+-------+-------+-------|                               |-------+-------+-------+-------+------|
+    | Tab   | Ctl-X | Ctl-C | Ctl-V | Ctl-Z |                               | {     | }     | '     | !     | Ent  |
+    |-------+-------+-------+-------+-------|                               |-------+-------+-------+-------+------|
+    | Sft   | Ctl   | Alt   | Del   | Ent   |                               | #     | Alt   | Ctl   | Sft   | Sup  |
+    '-------'-------'-------+-------+-------+-----.                   .-----+-------+-------+-------'-------'------'
+                            | BS    | P2    |     |                   |     | Sft   |       |
+                            '-------'-------'-----'                   '-----'-------'-------'
   */
-  [R1] = LAYOUT(
-    KC_LABK, KC_RABK,  KC_LCBR,  KC_RCBR, KX_AT,                     KC_DLR,  KC_HASH,    XXXXXXX,       XXXXXXX, MO(R3),
-    KC_LBRC, KC_RBRC,  KC_LPRN,  KC_RPRN, KC_NUHS,                   KC_QUOT, LSFT(KC_2), LSFT(KC_NUHS), KC_GRV,  KC_CAPS,
-    KC_SLSH, KC_NUBS,  KC_CIRC,  KX_PIPE, KC_PERC,                   _______, _______,    _______,       XXXXXXX, KC_PSCR,
-    _______, _______,  _______,  KC_DEL,  _______, _______, _______, _______, _______,    _______,       _______, _______
+  [P2] = LAYOUT(
+    KC_ESC,  XXXXXXX,    TO(NC),     TO(FV),     XXXXXXX,                      KC_LPRN, KC_RPRN, KX_DQUOT, KC_QUES, XXXXXXX,
+    KC_TAB,  LCTL(KC_X), LCTL(KC_C), LCTL(KC_V), LCTL(KC_Z),                   KC_LCBR, KC_RCBR, KC_QUOT,  KC_EXLM, KC_ENT,
+    KC_LSFT, KC_LCTL,    KC_LALT,    KC_DEL,     KC_ENT,                       KC_NUHS, KC_LALT, KC_LCTL,  KC_LSFT, _______,
+    XXXXXXX, XXXXXXX,    XXXXXXX,    KC_BSPC,    _______,    XXXXXXX, XXXXXXX, _______, XXXXXXX, XXXXXXX,  XXXXXXX, XXXXXXX
   ),
 
- /* R2
-  .-----------------------------------.         .--------------------.-----------------.
-  | F12  | F11  | F10  | F9   | Copy  |         | Home | Up   | End  | PgUp | Insert   |
-  |------+------+------+------+-------|         |------+------+------+------+----------|
-  | F8   | F7   | F6   | F5   | Paste |         | Left | Down | Right| PgDn | Enter    |
-  |------+------+------+------+-------|         |------+------+------+------+----------|
-  | F4   | F3   | F2   | F1   | Cut   |         | ^Tab |      | Tab  |      |          |
-  |------+------+------+------+-------+---------+------+------+------+------+----------|
-  | Shft | Ctrl | Alt  | Del  | Undo  | L1 | R1 | Shft | R2   | Sup  | Ctrl | WinRight |
-  '------------------------------------------------------------------------------------'
+  /* P3: Punctuation (3)
+    .-------.-------.-------.-------.-------.                             .------.-------.-------.-------.------.
+    | Esc   |       | Break | Pscr  | ScLk  |                             | <    | >     | +     | _     | =    |
+    |-------+-------+-------+-------+-------|                             |------+-------+-------+-------+------|
+    | Tab   |       |       | Caps  |       |                             | [    | ]     | *     | -     | Ent  |
+    |-------+-------+-------+-------+-------|                             |------+-------+-------+-------+------|
+    | Sft   | Ctl   | Alt   | Del   |       |                             | @    | Alt   | Ctl   | Sft   | Sup  |
+    '-------'-------'-------+-------+-------+-----.                 .-----+------+-------+-------'-------'------'
+                            | BS    |       | P3  |                 |     | Sft  |       |
+                            '-------'-------'-----'                 '-----'------'-------'
   */
-  [R2] = LAYOUT(
-    KC_F12,  KC_F11,  KC_F10,  KC_F9,  KX_COPY,                   KC_HOME, KC_UP,   KC_END,  KC_PGUP, KC_INS, 
-    KC_F8,   KC_F7,   KC_F6,   KC_F5,  KX_PAST,                   KC_LEFT, KC_DOWN, KC_RGHT, KC_PGDN, KC_ENT,
-    KC_F4,   KC_F3,   KC_F2,   KC_F1,  KX_CUT,                    KCX_LST, XXXXXXX, KC_TAB,  XXXXXXX, XXXXXXX, 
-    _______, _______, _______, KC_DEL, KX_UNDO, _______, _______, _______, _______, _______, _______, KX_WINR
+  [P3] = LAYOUT(
+    KC_ESC,  XXXXXXX, KC_BRK,  KC_PSCR, KC_SLCK,                             KC_LABK, KC_RABK, KC_PLUS, KC_UNDS, KC_EQL,
+    KC_TAB,  XXXXXXX, XXXXXXX, KC_CAPS, XXXXXXX,                             KC_LBRC, KC_RBRC, KC_ASTR, KC_MINS, KC_ENT,
+    KC_LSFT, KC_LCTL, KC_LALT, KC_DEL,  XXXXXXX,                             KX_AT,   KC_LALT, KC_LCTL, KC_LSFT, _______,
+    XXXXXXX, XXXXXXX, XXXXXXX, KC_BSPC, XXXXXXX, _______,           XXXXXXX, _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX
   ),
 
- /* R3
-  .----------------------------.         .------------------------.
-  | RESET |    |     |    |    |         |    |    |    |    | R3 |
-  |-------+----+-----+----+----|         |----+----+----+----+----|
-  |       |    |     |    |    |         |    |    |    |    |    |
-  |-------+----+-----+----+----|         |----+----+----+----+----|
-  |       |    |     |    |    |         |    |    |    |    |    |
-  |-------+----+-----+----+----+---------+----+----+----+----+----|
-  |       |    |     |    |    |    |    |    |    |    |    |    |
-  '---------------------------------------------------------------'
+  /* NC: Numerals / Cursor control
+    .-------.-------.-------.------.-------.                              .------.-------.-------.------.------.
+    | 1     | 2     | 3     | 4    | 5     |                              | Home | Up    | End   | PgUp |      |
+    |-------+-------+-------+------+-------|                              |------+-------+-------+------+------|
+    | 6     | 7     | 8     | 9    | 0     |                              | Left | Down  | Right | PgDn |      |
+    |-------+-------+-------+------+-------|                              |------+-------+-------+------+------|
+    | Sft   | Ctl   | Alt   | Del  | .     |                              | Ins  | Alt   | Ctl   | Sft  | Sup  |
+    '-------'-------'-------+------+-------+-----.                  .-----+------+-------+-------'------'------'
+                            | BS   | BA    |     |                  |     | Sft  |       |
+                            '------'-------'-----'                  '-----'------'-------'
   */
-  [R3] = LAYOUT(
-    RESET,   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, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX
+  [NC] = LAYOUT(
+    KC_1,    KC_2,    KC_3,    KC_4,    KC_5,                                KC_HOME, KC_UP,   KC_END,  KC_PGUP, XXXXXXX,
+    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,                                KC_LEFT, KC_DOWN, KC_RGHT, KC_PGDN, XXXXXXX,
+    KC_LSFT, KC_LCTL, KC_LALT, KC_DEL,  KC_DOT,                              KC_INS,  KC_LALT, KC_LCTL, KC_LSFT, _______,
+    XXXXXXX, XXXXXXX, XXXXXXX, KC_BSPC, TO(BA), XXXXXXX,            XXXXXXX, _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX
+  ),
+
+  /* FV: Function keys / Cursor control (Vim)
+    .-------.------.-------.-----.-------.                                .------.-------.-----.-------.------.
+    | F1    | F2   | F3    | F4  | F5    |                                | 0    | K     | $   | Ctl-B |      |
+    |-------+------+-------+-----+-------|                                |------+-------+-----+-------+------|
+    | F6    | F7   | F8    | F9  | F10   |                                | H    | J     | L   | Ctl-F |      |
+    |-------+------+-------+-----+-------|                                |------+-------+-----+-------+------|
+    | Sft   | Ctl  | Alt   | F11 | F12   |                                |      | Alt   | Ctl | Sft   | Sup  |
+    '-------'------'-------+-----+-------+-----.                    .-----+------+-------+-----'-------'------'
+                           | BS  | BA    |     |                    |     | Sft  |       |
+                           '-----'-------'-----'                    '-----'------'-------'
+  */
+  [FV] = LAYOUT(
+    KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,                               KC_0,    KC_K,    KC_DLR,   LCTL(KC_B), XXXXXXX,
+    KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,                              KC_H,    KC_J,    KC_L,     LCTL(KC_F), XXXXXXX,
+    KC_LSFT, KC_LCTL, KC_LALT, KC_F11,  KC_F12,                              XXXXXXX, KC_LALT, KC_LCTL,  KC_LSFT,    _______,
+    XXXXXXX, XXXXXXX, XXXXXXX, KC_BSPC, TO(BA), XXXXXXX,            XXXXXXX, _______, XXXXXXX, XXXXXXX,  XXXXXXX,    XXXXXXX
+  ),
+
+ /* RS: Reset
+    .-------.------.-------.-----.-------.                                .------.-------.-----.-------.------.
+    | RESET |      |       |     |       |                                |      |       |     |       |      |
+    |-------+------+-------+-----+-------|                                |------+-------+-----+-------+------|
+    |       |      |       |     |       |                                |      |       |     |       |      |
+    |-------+------+-------+-----+-------|                                |------+-------+-----+-------+------|
+    |       |      |       |     |       |                                |      |       |     |       |      |
+    '-------'------'-------+-----+-------+-----.                    .-----+------+-------+-----'-------'------'
+                           |     | BA    |     |                    |     |      |       |
+                           '-----'-------'-----'                    '-----'------'-------'
+  */
+  [RS] = LAYOUT(
+    RESET,   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, XXXXXXX, TO(BA),  XXXXXXX,           XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX
   )
 };
 

keyboards/atreus62/keymaps/jarred/config.h

@@ -0,0 +1,21 @@
+/* Copyright 2018 Jarred Steenvoorden
+ *
+ * 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
+
+// My hand wire diodes are in the opposite direction to the Atreus62 PCB
+#undef DIODE_DIRECTION
+#define DIODE_DIRECTION COL2ROW

keyboards/atreus62/keymaps/jarred/keymap.c

@@ -0,0 +1,26 @@
+/* Copyright 2018 Jarred Steenvoorden
+ *
+ * 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 "jarred.h"
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    [_QW] = LAYOUT_atreus62_grid_wrapper(BLANK_12, QWERTY_1_12, QWERTY_2_12, QWERTY_3_12, QWERTY_L4, KC_NO, KC_NO, QWERTY_R4),
+    [_LW] = LAYOUT_atreus62_grid_wrapper(BLANK_12, LOWER_1_12 , LOWER_2_12 , LOWER_3_12 , LOWER_L4 , KC_NO, KC_NO, LOWER_R4 ),
+    [_NV] = LAYOUT_atreus62_grid_wrapper(BLANK_12, NAV_1_12   , NAV_2_12   , NAV_3_12   , NAV_L4   , KC_NO, KC_NO, NAV_R4   ),
+    [_NP] = LAYOUT_atreus62_grid_wrapper(BLANK_12, NUMPAD_1_12, NUMPAD_2_12, NUMPAD_3_12, NUMPAD_L4, KC_NO, KC_NO, NUMPAD_R4),
+    [_MS] = LAYOUT_atreus62_grid_wrapper(BLANK_12, MOUSE_1_12 , MOUSE_2_12 , MOUSE_3_12 , MOUSE_L4 , KC_NO, KC_NO, MOUSE_R4 )
+};

keyboards/bm16a/bm16a.c

@@ -0,0 +1,43 @@
+/* Copyright 2019
+ *
+ * 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 "bm16a.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);
+}

keyboards/bm16a/bm16a.h

@@ -0,0 +1,39 @@
+/* Copyright 2019
+ *
+ * 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"
+
+/* 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_ortho_4x4( \
+	K01, K02, K03, K04, \
+	K11, K12, K13, K14, \
+	K21, K22, K23, K24, \
+	K31, K32, K33, K34 \
+) \
+{ \
+  { K01, K02, K03, K04 }, \
+  { K11, K12, K13, K14 }, \
+  { K21, K22, K23, K24 }, \
+  { K31, K32, K33, K34 } \
+}

keyboards/bm16a/config.h

@@ -0,0 +1,246 @@
+/* Copyright 2019
+ *
+ * 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      0x424D
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    KPrepublic
+#define PRODUCT         bm16a
+#define DESCRIPTION     KPrepublic bm16a
+
+/* key matrix size */
+#define MATRIX_ROWS 4
+#define MATRIX_COLS 4
+
+/*
+ * Keyboard Matrix Assignments
+ *
+ * Change this to how you wired your keyboard
+ * COLS: AVR pins used for columns, left to right
+ * ROWS: AVR pins used for rows, top to bottom
+ * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode)
+ *                  ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
+ *
+*/
+#define MATRIX_ROW_PINS { D3, D5, D1, D2}
+#define MATRIX_COL_PINS { D6, D4, D7, B4}
+#define UNUSED_PINS
+
+/* 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 D0 // or D1, D2, D3, E6
+
+#define BACKLIGHT_PIN B6
+// #define BACKLIGHT_BREATHING
+#define BACKLIGHT_LEVELS 5
+
+#define RGB_DI_PIN E2
+#define RGBLED_NUM 4
+#define RGBLIGHT_ANIMATIONS
+// #ifdef RGB_DI_PIN
+//   #define RGBLED_NUM 16
+//   #define RGBLIGHT_HUE_STEP 8
+//   #define RGBLIGHT_SAT_STEP 8
+//   #define RGBLIGHT_VAL_STEP 8
+//   #define RGBLIGHT_LIMIT_VAL 255 /* The maximum brightness level */
+//   #define RGBLIGHT_SLEEP  /* If defined, the RGB lighting will be switched off when the host goes to sleep */
+// /*== all animations enable ==*/
+//   #define RGBLIGHT_ANIMATIONS
+// /*== or choose animations ==*/
+//   #define RGBLIGHT_EFFECT_BREATHING
+//   #define RGBLIGHT_EFFECT_RAINBOW_MOOD
+//   #define RGBLIGHT_EFFECT_RAINBOW_SWIRL
+//   #define RGBLIGHT_EFFECT_SNAKE
+//   #define RGBLIGHT_EFFECT_KNIGHT
+//   #define RGBLIGHT_EFFECT_CHRISTMAS
+//   #define RGBLIGHT_EFFECT_STATIC_GRADIENT
+//   #define RGBLIGHT_EFFECT_RGB_TEST
+//   #define RGBLIGHT_EFFECT_ALTERNATING
+// #endif
+
+/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
+#define DEBOUNCING_DELAY 5
+
+/* define if matrix has ghost (lacks anti-ghosting diodes) */
+//#define MATRIX_HAS_GHOST
+
+/* number of backlight levels */
+
+/* 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
+
+/*
+ * Force NKRO
+ *
+ * Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved
+ * state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the
+ * makefile for this to work.)
+ *
+ * If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N)
+ * until the next keyboard reset.
+ *
+ * NKRO may prevent your keystrokes from being detected in the BIOS, but it is
+ * fully operational during normal computer usage.
+ *
+ * For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N)
+ * or via bootmagic (hold SPACE+N while plugging in the keyboard). Once set by
+ * bootmagic, NKRO mode will always be enabled until it is toggled again during a
+ * power-up.
+ *
+ */
+//#define FORCE_NKRO
+
+/*
+ * Magic Key Options
+ *
+ * Magic keys are hotkey commands that allow control over firmware functions of
+ * the keyboard. They are best used in combination with the HID Listen program,
+ * found here: https://www.pjrc.com/teensy/hid_listen.html
+ *
+ * The options below allow the magic key functionality to be changed. This is
+ * useful if your keyboard/keypad is missing keys and you want magic key support.
+ *
+ */
+
+/* key combination for magic key command */
+/* defined by default; to change, uncomment and set to the combination you want */
+// #define IS_COMMAND() (get_mods() == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)))
+
+/* control how magic key switches layers */
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS  true
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS  true
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM false
+
+/* override magic key keymap */
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM
+//#define MAGIC_KEY_HELP           H
+//#define MAGIC_KEY_HELP_ALT       SLASH
+//#define MAGIC_KEY_DEBUG          D
+//#define MAGIC_KEY_DEBUG_MATRIX   X
+//#define MAGIC_KEY_DEBUG_KBD      K
+//#define MAGIC_KEY_DEBUG_MOUSE    M
+//#define MAGIC_KEY_VERSION        V
+//#define MAGIC_KEY_STATUS         S
+//#define MAGIC_KEY_CONSOLE        C
+//#define MAGIC_KEY_LAYER0         0
+//#define MAGIC_KEY_LAYER0_ALT     GRAVE
+//#define MAGIC_KEY_LAYER1         1
+//#define MAGIC_KEY_LAYER2         2
+//#define MAGIC_KEY_LAYER3         3
+//#define MAGIC_KEY_LAYER4         4
+//#define MAGIC_KEY_LAYER5         5
+//#define MAGIC_KEY_LAYER6         6
+//#define MAGIC_KEY_LAYER7         7
+//#define MAGIC_KEY_LAYER8         8
+//#define MAGIC_KEY_LAYER9         9
+//#define MAGIC_KEY_BOOTLOADER     B
+//#define MAGIC_KEY_BOOTLOADER_ALT ESC
+//#define MAGIC_KEY_LOCK           CAPS
+//#define MAGIC_KEY_EEPROM         E
+//#define MAGIC_KEY_EEPROM_CLEAR   BSPACE
+//#define MAGIC_KEY_NKRO           N
+//#define MAGIC_KEY_SLEEP_LED      Z
+
+/*
+ * Feature disable options
+ *  These options are also useful to firmware size reduction.
+ */
+
+/* disable debug print */
+//#define NO_DEBUG
+
+/* disable print */
+//#define NO_PRINT
+
+/* disable action features */
+//#define NO_ACTION_LAYER
+//#define NO_ACTION_TAPPING
+//#define NO_ACTION_ONESHOT
+//#define NO_ACTION_MACRO
+//#define NO_ACTION_FUNCTION
+
+/*
+ * 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 1
+
+/*
+ * HD44780 LCD Display Configuration
+ */
+/*
+#define LCD_LINES           2     //< number of visible lines of the display
+#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
+
+#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
+
+#if LCD_IO_MODE
+#define LCD_PORT         PORTB        //< port for the LCD lines
+#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
+#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
+#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
+#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
+#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
+#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
+#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
+#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
+#define LCD_RS_PORT      LCD_PORT     //< port for RS line
+#define LCD_RS_PIN       3            //< pin  for RS line
+#define LCD_RW_PORT      LCD_PORT     //< port for RW line
+#define LCD_RW_PIN       2            //< pin  for RW line
+#define LCD_E_PORT       LCD_PORT     //< port for Enable line
+#define LCD_E_PIN        1            //< pin  for Enable line
+#endif
+*/
+
+/* Bootmagic Lite key configuration */
+// #define BOOTMAGIC_LITE_ROW 0
+// #define BOOTMAGIC_LITE_COLUMN 0

keyboards/bm16a/info.json

@@ -0,0 +1,30 @@
+{
+    "keyboard_name": "bm16a",
+    "url": "",
+    "maintainer": "qmk",
+    "width": 4,
+    "height": 4,
+    "layouts": {
+      "LAYOUT_ortho_4x4": {
+        "key_count": 16,
+        "layout": [
+          {"x":0, "y":0},
+          {"x":1, "y":0},
+          {"x":2, "y":0},
+          {"x":3, "y":0},
+          {"x":0, "y":1},
+          {"x":1, "y":1},
+          {"x":2, "y":1},
+          {"x":3, "y":1},
+          {"x":0, "y":2},
+          {"x":1, "y":2},
+          {"x":2, "y":2},
+          {"x":3, "y":2},
+          {"x":0, "y":3},
+          {"x":1, "y":3},
+          {"x":2, "y":3},
+          {"x":3, "y":3}
+        ]
+      }
+    }
+  }

keyboards/bm16a/keymaps/default/config.h

@@ -0,0 +1,19 @@
+/* Copyright 2019
+ *
+ * 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
+
+// place overrides here

keyboards/bm16a/keymaps/default/keymap.c

@@ -0,0 +1,73 @@
+/* Copyright 2019
+ *
+ * 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
+
+enum layers {
+  _BASE = 0,
+  _FN1,
+  _FN2,
+};
+
+// Defines the keycodes used by our macros in process_record_user
+enum custom_keycodes {
+  QMKBEST = SAFE_RANGE,
+  QMKURL
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+  [_BASE] = LAYOUT_ortho_4x4(
+    KC_PGUP,  KC_HOME,  KC_UP,    KC_END , \
+    KC_PGDN,  KC_LEFT,  KC_DOWN,  KC_RGHT, \
+    MO(_FN2), KC_VOLU,  KC_MPLY,  KC_MPRV, \
+    MO(_FN1), KC_VOLD,  KC_MUTE,  KC_MNXT  \
+  ),
+  [_FN1] = LAYOUT_ortho_4x4(
+    KC_ESC,   KC_P7,    KC_P8,    KC_P9,   \
+    KC_TAB,   KC_P4,    KC_P5,    KC_P6,   \
+    KC_ENT,   KC_P1,    KC_P2,    KC_P3,   \
+    _______,  KC_P0,    KC_P0,    KC_DOT   \
+  ),
+  [_FN2] = LAYOUT_ortho_4x4(
+    RGB_TOG,  RGB_HUI,  RGB_SAI,  RGB_VAI, \
+    RGB_MOD,  RGB_HUD,  RGB_SAD,  RGB_VAD, \
+    _______,  _______,  _______,  RESET,   \
+    BL_STEP,  _______,  QMKBEST,  QMKURL   \
+  )
+
+};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case QMKBEST:
+      if (record->event.pressed) {
+        // when keycode QMKBEST is pressed
+        SEND_STRING("QMK is the best thing ever!");
+      } else {
+        // when keycode QMKBEST is released
+      }
+      break;
+    case QMKURL:
+      if (record->event.pressed) {
+        // when keycode QMKURL is pressed
+        SEND_STRING("https://qmk.fm/" SS_TAP(X_ENTER));
+      } else {
+        // when keycode QMKURL is released
+      }
+      break;
+  }
+  return true;
+}

keyboards/bm16a/keymaps/default/readme.md

@@ -0,0 +1 @@
+# The default keymap for bm16a

keyboards/bm16a/readme.md

@@ -0,0 +1,15 @@
+# bm16a
+
+![bm16a](https://ae01.alicdn.com/kf/HTB1RRRQaZfrK1RjSszcq6xGGFXaY.jpg)
+
+A 16 key macropad, with USB C, RGB underglow and backlight.
+
+Keyboard Maintainer: QMK Community  
+Hardware Supported: The PCBs, controllers supported  
+Hardware Availability: [KPrepublic](https://kprepublic.com/products/bm16a-16-keys-custom-mechanical-keyboard-pcb-plate-programmed-numpad-layouts-qmk-firmware-with-rgb-bottom-underglow-alps-mx); [AliExpress](https://www.aliexpress.com/store/product/bm16a-16-keys-Custom-Mechanical-Keyboard-PCB-plate-programmed-numpad-layouts-qmk-firmware-with-rgb-bottom/3034003_32970629907.html)
+
+Make example for this keyboard (after setting up your build environment):
+
+    make bm16a: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).

keyboards/bm16a/rules.mk

@@ -0,0 +1,82 @@
+# MCU name
+MCU = atmega32u4
+
+# Processor frequency.
+#     This will define a symbol, F_CPU, in all source code files equal to the
+#     processor frequency in Hz. You can then use this symbol in your source code to
+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#     automatically to create a 32-bit value in your source code.
+#
+#     This will be an integer division of F_USB below, as it is sourced by
+#     F_USB after it has run through any CPU prescalers. Note that this value
+#     does not *change* the processor frequency - it should merely be updated to
+#     reflect the processor speed set externally so that the code can use accurate
+#     software delays.
+F_CPU = 16000000
+
+
+#
+# LUFA specific
+#
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+# Input clock frequency.
+#     This will define a symbol, F_USB, in all source code files equal to the
+#     input clock frequency (before any prescaling is performed) in Hz. This value may
+#     differ from F_CPU if prescaling is used on the latter, and is required as the
+#     raw input clock is fed directly to the PLL sections of the AVR for high speed
+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
+#     at the end, this will be done automatically to create a 32-bit value in your
+#     source code.
+#
+#     If no clock division is performed on the input clock inside the AVR (via the
+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
+F_USB = $(F_CPU)
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   atmega32a    bootloadHID
+BOOTLOADER = atmel-dfu
+
+
+# If you don't know the bootloader type, then you can specify the
+# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
+#   Teensy halfKay      512
+#   Teensy++ halfKay    1024
+#   Atmel DFU loader    4096
+#   LUFA bootloader     4096
+#   USBaspLoader        2048
+# OPT_DEFS += -DBOOTLOADER_SIZE=4096
+
+
+# Build Options
+#   change yes to no to disable
+#
+BOOTMAGIC_ENABLE = lite     # Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = yes       # Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes       # Audio control and System control(+450)
+CONSOLE_ENABLE = no         # Console for debug(+400)
+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 = yes      # Enable keyboard backlight functionality on B7 by default
+RGBLIGHT_ENABLE = yes       # Enable keyboard RGB underglow
+MIDI_ENABLE = no            # MIDI support (+2400 to 4200, depending on config)
+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 (+400)
+
+LAYOUTS = ortho_4x4

keyboards/boardwalk/boardwalk.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#include "quantum.h"
+
+#define LAYOUT_ortho_5x14( \
+  k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k010, k011, k012, k013, \
+  k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k110, k111, k112, k113, \
+  k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k210, k211, k212, k213, \
+  k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k310, k311, k312, k313, \
+  k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k410, k411, k412, k413 \
+) \
+{ \
+  { k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k010, k011, k012, k013 }, \
+  { k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k110, k111, k112, k113 }, \
+  { k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k210, k211, k212, k213 }, \
+  { k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k310, k311, k312, k313 }, \
+  { k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k410, k411, k412, k413 } \
+}
+
+#define LAYOUT_ortho_hhkb( \
+  k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k010, k011, k012, k013, \
+  k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k110, k111, k112, k113, \
+  k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k210, k211, k212, k213, \
+  k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k310, k311, k312, k313, \
+       k41, k42, k43, k44,   k45,     k47,     k49, k410, k411, k412       \
+) \
+{ \
+  { k00,   k01, k02, k03, k04, k05, k06,   k07, k08,   k09, k010, k011, k012, k013   }, \
+  { k10,   k11, k12, k13, k14, k15, k16,   k17, k18,   k19, k110, k111, k112, k113   }, \
+  { k20,   k21, k22, k23, k24, k25, k26,   k27, k28,   k29, k210, k211, k212, k213   }, \
+  { k30,   k31, k32, k33, k34, k35, k36,   k37, k38,   k39, k310, k311, k312, k313   }, \
+  { KC_NO, k41, k42, k43, k44, k45, KC_NO, k47, KC_NO, k49, k410, k411, k412, KC_NO } \
+}
+
+#define LAYOUT_ortho_7u( \
+  k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k010, k011, k012, k013, \
+  k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k110, k111, k112, k113, \
+  k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k210, k211, k212, k213, \
+  k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k310, k311, k312, k313, \
+       k41, k42,                       k46,               k411, k412        \
+) \
+{ \
+  { k00,   k01, k02, k03,   k04,   k05,   k06, k07,   k08,   k09,   k010,  k011, k012, k013   }, \
+  { k10,   k11, k12, k13,   k14,   k15,   k16, k17,   k18,   k19,   k110,  k111, k112, k113   }, \
+  { k20,   k21, k22, k23,   k24,   k25,   k26, k27,   k28,   k29,   k210,  k211, k212, k213   }, \
+  { k30,   k31, k32, k33,   k34,   k35,   k36, k37,   k38,   k39,   k310,  k311, k312, k313   }, \
+  { KC_NO, k41, k42, KC_NO, KC_NO, KC_NO, k46, KC_NO, KC_NO, KC_NO, KC_NO, k411, k412, KC_NO } \
+}
+
+#define LAYOUT_2u_arrow( \
+  k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k010, k011, k012, k013, \
+  k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k110, k111, k112, k113, \
+  k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k210, k211, k212, k213, \
+  k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k310, k311, k312, k313, \
+  k40, k41, k42, k43,    k44,      k46,   k48, k49, k410, k411, k412, k413 \
+) \
+{ \
+  { k00, k01, k02, k03, k04, k05,   k06, k07,   k08, k09, k010, k011, k012, k013 }, \
+  { k10, k11, k12, k13, k14, k15,   k16, k17,   k18, k19, k110, k111, k112, k113 }, \
+  { k20, k21, k22, k23, k24, k25,   k26, k27,   k28, k29, k210, k211, k212, k213 }, \
+  { k30, k31, k32, k33, k34, k35,   k36, k37,   k38, k39, k310, k311, k312, k313 }, \
+  { k40, k41, k42, k43, k44, KC_NO, k46, KC_NO, k48, k49, k410, k411, k412, k413 } \
+}
+
+#define LAYOUT_625u_arrow( \
+  k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k010, k011, k012, k013, \
+  k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k110, k111, k112, k113, \
+  k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k210, k211, k212, k213, \
+  k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k310, k311, k312, k313, \
+  k40, k41, k42,              k45,             k49, k410, k411, k412, k413 \
+) \
+{ \
+  { k00, k01, k02, k03,   k04,   k05,   k06,   k07,   k08,   k09, k010, k011, k012, k013 }, \
+  { k10, k11, k12, k13,   k14,   k15,   k16,   k17,   k18,   k19, k110, k111, k112, k113 }, \
+  { k20, k21, k22, k23,   k24,   k25,   k26,   k27,   k28,   k29, k210, k211, k212, k213 }, \
+  { k30, k31, k32, k33,   k34,   k35,   k36,   k37,   k38,   k39, k310, k311, k312, k313 }, \
+  { k40, k41, k42, KC_NO, KC_NO, k45,   KC_NO, KC_NO, KC_NO, k49, k410, k411, k412, k413 } \
+}

keyboards/boardwalk/config.h

@@ -0,0 +1,84 @@
+/*
+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       0xCDCD
+#define PRODUCT_ID      0x5337
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    shens
+#define PRODUCT         Boardwalk
+#define DESCRIPTION     QMK keyboard firmware for Boardwalk
+
+/* key matrix size */
+#define MATRIX_ROWS 5
+#define MATRIX_COLS 14
+
+/*
+ * Keyboard Matrix Assignments
+ *
+ * Change this to how you wired your keyboard
+ * COLS: AVR pins used for columns, left to right
+ * ROWS: AVR pins used for rows, top to bottom
+ * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode)
+ *                  ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
+ *
+*/
+#define MATRIX_ROW_PINS { F0, F1, F4, F5, F6 }
+#define MATRIX_COL_PINS { F7, C7, C6, B6, B5, B4, D7, D6, D4, D5, D3, D2, D1, D0 }
+#define UNUSED_PINS
+
+/* COL2ROW, ROW2COL, or CUSTOM_MATRIX */
+#define DIODE_DIRECTION COL2ROW
+
+// #define BACKLIGHT_PIN F5
+// #define BACKLIGHT_LEVELS 6
+
+/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
+#define DEBOUNCING_DELAY 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
+
+/*
+ * Feature disable options
+ *  These options are also useful to firmware size reduction.
+ */
+
+/* disable debug print */
+//#define NO_DEBUG
+
+/* disable print */
+//#define NO_PRINT
+
+/* disable action features */
+//#define NO_ACTION_LAYER
+//#define NO_ACTION_TAPPING
+//#define NO_ACTION_ONESHOT
+//#define NO_ACTION_MACRO
+//#define NO_ACTION_FUNCTION
+
+// ws2812 options
+#define RGB_DI_PIN B7 // pin the DI on the ws2812 is hooked-up to
+#define RGBLIGHT_ANIMATIONS // run RGB animations
+#define RGBLED_NUM 14 // number of LEDs
+#define RGBLIGHT_HUE_STEP 12 // units to step when in/decreasing hue
+#define RGBLIGHT_SAT_STEP 25 // units to step when in/decresing saturation
+#define RGBLIGHT_VAL_STEP 12 // units to step when in/decreasing value (brightness)

keyboards/boardwalk/info.json

@@ -0,0 +1,359 @@
+{
+    "keyboard_name": "Boardwalk",
+    "url": "",
+    "maintainer": "qmk",
+    "width": 15,
+    "height": 5,
+    "layouts": {
+      "LAYOUT_ortho_5x14": {
+        "layout": [
+          {"label":"k00", "x":0, "y":0, "w":1.5},
+          {"label":"k01", "x":1.5, "y":0},
+          {"label":"k02", "x":2.5, "y":0},
+          {"label":"k03", "x":3.5, "y":0},
+          {"label":"k04", "x":4.5, "y":0},
+          {"label":"k05", "x":5.5, "y":0},
+          {"label":"k06", "x":6.5, "y":0},
+          {"label":"k07", "x":7.5, "y":0},
+          {"label":"k08", "x":8.5, "y":0},
+          {"label":"k09", "x":9.5, "y":0},
+          {"label":"k010", "x":10.5, "y":0},
+          {"label":"k011", "x":11.5, "y":0},
+          {"label":"k012", "x":12.5, "y":0},
+          {"label":"k013", "x":13.5, "y":0, "w":1.5},
+          {"label":"k10", "x":0, "y":1, "w":1.5},
+          {"label":"k11", "x":1.5, "y":1},
+          {"label":"k12", "x":2.5, "y":1},
+          {"label":"k13", "x":3.5, "y":1},
+          {"label":"k14", "x":4.5, "y":1},
+          {"label":"k15", "x":5.5, "y":1},
+          {"label":"k16", "x":6.5, "y":1},
+          {"label":"k17", "x":7.5, "y":1},
+          {"label":"k18", "x":8.5, "y":1},
+          {"label":"k19", "x":9.5, "y":1},
+          {"label":"k110", "x":10.5, "y":1},
+          {"label":"k111", "x":11.5, "y":1},
+          {"label":"k112", "x":12.5, "y":1},
+          {"label":"k113", "x":13.5, "y":1, "w":1.5},
+          {"label":"k20", "x":0, "y":2, "w":1.5},
+          {"label":"k21", "x":1.5, "y":2},
+          {"label":"k22", "x":2.5, "y":2},
+          {"label":"k23", "x":3.5, "y":2},
+          {"label":"k24", "x":4.5, "y":2},
+          {"label":"k25", "x":5.5, "y":2},
+          {"label":"k26", "x":6.5, "y":2},
+          {"label":"k27", "x":7.5, "y":2},
+          {"label":"k28", "x":8.5, "y":2},
+          {"label":"k29", "x":9.5, "y":2},
+          {"label":"k210", "x":10.5, "y":2},
+          {"label":"k211", "x":11.5, "y":2},
+          {"label":"k212", "x":12.5, "y":2},
+          {"label":"k213", "x":13.5, "y":2, "w":1.5},
+          {"label":"k30", "x":0, "y":3, "w":1.5},
+          {"label":"k31", "x":1.5, "y":3},
+          {"label":"k32", "x":2.5, "y":3},
+          {"label":"k33", "x":3.5, "y":3},
+          {"label":"k34", "x":4.5, "y":3},
+          {"label":"k35", "x":5.5, "y":3},
+          {"label":"k36", "x":6.5, "y":3},
+          {"label":"k37", "x":7.5, "y":3},
+          {"label":"k38", "x":8.5, "y":3},
+          {"label":"k39", "x":9.5, "y":3},
+          {"label":"k310", "x":10.5, "y":3},
+          {"label":"k311", "x":11.5, "y":3},
+          {"label":"k312", "x":12.5, "y":3},
+          {"label":"k313", "x":13.5, "y":3, "w":1.5},
+          {"label":"k40", "x":0, "y":4, "w":1.5},
+          {"label":"k41", "x":1.5, "y":4},
+          {"label":"k42", "x":2.5, "y":4},
+          {"label":"k43", "x":3.5, "y":4},
+          {"label":"k44", "x":4.5, "y":4},
+          {"label":"k45", "x":5.5, "y":4},
+          {"label":"k46", "x":6.5, "y":4},
+          {"label":"k47", "x":7.5, "y":4},
+          {"label":"k48", "x":8.5, "y":4},
+          {"label":"k49", "x":9.5, "y":4},
+          {"label":"k410", "x":10.5, "y":4},
+          {"label":"k411", "x":11.5, "y":4},
+          {"label":"k412", "x":12.5, "y":4},
+          {"label":"k413", "x":13.5, "y":4, "w":1.5}
+        ]
+      },
+      "LAYOUT_ortho_hhkb": {
+        "layout": [
+          {"label":"k00", "x":0, "y":0, "w":1.5},
+          {"label":"k01", "x":1.5, "y":0},
+          {"label":"k02", "x":2.5, "y":0},
+          {"label":"k03", "x":3.5, "y":0},
+          {"label":"k04", "x":4.5, "y":0},
+          {"label":"k05", "x":5.5, "y":0},
+          {"label":"k06", "x":6.5, "y":0},
+          {"label":"k07", "x":7.5, "y":0},
+          {"label":"k08", "x":8.5, "y":0},
+          {"label":"k09", "x":9.5, "y":0},
+          {"label":"k010", "x":10.5, "y":0},
+          {"label":"k011", "x":11.5, "y":0},
+          {"label":"k012", "x":12.5, "y":0},
+          {"label":"k013", "x":13.5, "y":0, "w":1.5},
+          {"label":"k10", "x":0, "y":1, "w":1.5},
+          {"label":"k11", "x":1.5, "y":1},
+          {"label":"k12", "x":2.5, "y":1},
+          {"label":"k13", "x":3.5, "y":1},
+          {"label":"k14", "x":4.5, "y":1},
+          {"label":"k15", "x":5.5, "y":1},
+          {"label":"k16", "x":6.5, "y":1},
+          {"label":"k17", "x":7.5, "y":1},
+          {"label":"k18", "x":8.5, "y":1},
+          {"label":"k19", "x":9.5, "y":1},
+          {"label":"k110", "x":10.5, "y":1},
+          {"label":"k111", "x":11.5, "y":1},
+          {"label":"k112", "x":12.5, "y":1},
+          {"label":"k113", "x":13.5, "y":1, "w":1.5},
+          {"label":"k20", "x":0, "y":2, "w":1.5},
+          {"label":"k21", "x":1.5, "y":2},
+          {"label":"k22", "x":2.5, "y":2},
+          {"label":"k23", "x":3.5, "y":2},
+          {"label":"k24", "x":4.5, "y":2},
+          {"label":"k25", "x":5.5, "y":2},
+          {"label":"k26", "x":6.5, "y":2},
+          {"label":"k27", "x":7.5, "y":2},
+          {"label":"k28", "x":8.5, "y":2},
+          {"label":"k29", "x":9.5, "y":2},
+          {"label":"k210", "x":10.5, "y":2},
+          {"label":"k211", "x":11.5, "y":2},
+          {"label":"k212", "x":12.5, "y":2},
+          {"label":"k213", "x":13.5, "y":2, "w":1.5},
+          {"label":"k30", "x":0, "y":3, "w":1.5},
+          {"label":"k31", "x":1.5, "y":3},
+          {"label":"k32", "x":2.5, "y":3},
+          {"label":"k33", "x":3.5, "y":3},
+          {"label":"k34", "x":4.5, "y":3},
+          {"label":"k35", "x":5.5, "y":3},
+          {"label":"k36", "x":6.5, "y":3},
+          {"label":"k37", "x":7.5, "y":3},
+          {"label":"k38", "x":8.5, "y":3},
+          {"label":"k39", "x":9.5, "y":3},
+          {"label":"k310", "x":10.5, "y":3},
+          {"label":"k311", "x":11.5, "y":3},
+          {"label":"k312", "x":12.5, "y":3},
+          {"label":"k313", "x":13.5, "y":3, "w":1.5},
+          {"label":"k41", "x":1.5, "y":4},
+          {"label":"k42", "x":2.5, "y":4},
+          {"label":"k43", "x":3.5, "y":4},
+          {"label":"k44", "x":4.5, "y":4},
+          {"label":"k45", "x":5.5, "y":4, "w":2},
+          {"label":"k47", "x":7.5, "y":4, "w":2},
+          {"label":"k49", "x":9.5, "y":4},
+          {"label":"k410", "x":10.5, "y":4},
+          {"label":"k411", "x":11.5, "y":4},
+          {"label":"k412", "x":12.5, "y":4}
+        ]
+      },
+      "LAYOUT_ortho_7u": {
+        "layout": [
+          {"label":"k00", "x":0, "y":0, "w":1.5},
+          {"label":"k01", "x":1.5, "y":0},
+          {"label":"k02", "x":2.5, "y":0},
+          {"label":"k03", "x":3.5, "y":0},
+          {"label":"k04", "x":4.5, "y":0},
+          {"label":"k05", "x":5.5, "y":0},
+          {"label":"k06", "x":6.5, "y":0},
+          {"label":"k07", "x":7.5, "y":0},
+          {"label":"k08", "x":8.5, "y":0},
+          {"label":"k09", "x":9.5, "y":0},
+          {"label":"k010", "x":10.5, "y":0},
+          {"label":"k011", "x":11.5, "y":0},
+          {"label":"k012", "x":12.5, "y":0},
+          {"label":"k013", "x":13.5, "y":0, "w":1.5},
+          {"label":"k10", "x":0, "y":1, "w":1.5},
+          {"label":"k11", "x":1.5, "y":1},
+          {"label":"k12", "x":2.5, "y":1},
+          {"label":"k13", "x":3.5, "y":1},
+          {"label":"k14", "x":4.5, "y":1},
+          {"label":"k15", "x":5.5, "y":1},
+          {"label":"k16", "x":6.5, "y":1},
+          {"label":"k17", "x":7.5, "y":1},
+          {"label":"k18", "x":8.5, "y":1},
+          {"label":"k19", "x":9.5, "y":1},
+          {"label":"k110", "x":10.5, "y":1},
+          {"label":"k111", "x":11.5, "y":1},
+          {"label":"k112", "x":12.5, "y":1},
+          {"label":"k113", "x":13.5, "y":1, "w":1.5},
+          {"label":"k20", "x":0, "y":2, "w":1.5},
+          {"label":"k21", "x":1.5, "y":2},
+          {"label":"k22", "x":2.5, "y":2},
+          {"label":"k23", "x":3.5, "y":2},
+          {"label":"k24", "x":4.5, "y":2},
+          {"label":"k25", "x":5.5, "y":2},
+          {"label":"k26", "x":6.5, "y":2},
+          {"label":"k27", "x":7.5, "y":2},
+          {"label":"k28", "x":8.5, "y":2},
+          {"label":"k29", "x":9.5, "y":2},
+          {"label":"k210", "x":10.5, "y":2},
+          {"label":"k211", "x":11.5, "y":2},
+          {"label":"k212", "x":12.5, "y":2},
+          {"label":"k213", "x":13.5, "y":2, "w":1.5},
+          {"label":"k30", "x":0, "y":3, "w":1.5},
+          {"label":"k31", "x":1.5, "y":3},
+          {"label":"k32", "x":2.5, "y":3},
+          {"label":"k33", "x":3.5, "y":3},
+          {"label":"k34", "x":4.5, "y":3},
+          {"label":"k35", "x":5.5, "y":3},
+          {"label":"k36", "x":6.5, "y":3},
+          {"label":"k37", "x":7.5, "y":3},
+          {"label":"k38", "x":8.5, "y":3},
+          {"label":"k39", "x":9.5, "y":3},
+          {"label":"k310", "x":10.5, "y":3},
+          {"label":"k311", "x":11.5, "y":3},
+          {"label":"k312", "x":12.5, "y":3},
+          {"label":"k313", "x":13.5, "y":3, "w":1.5},
+          {"label":"k41", "x":1.5, "y":4},
+          {"label":"k42", "x":2.5, "y":4, "w":1.5},
+          {"label":"k46", "x":4, "y":4, "w":7},
+          {"label":"k411", "x":11, "y":4, "w":1.5},
+          {"label":"k412", "x":12.5, "y":4}
+        ]
+      },
+      "LAYOUT_2u_arrow": {
+        "layout": [
+          {"label":"k00", "x":0, "y":0, "w":1.5},
+          {"label":"k01", "x":1.5, "y":0},
+          {"label":"k02", "x":2.5, "y":0},
+          {"label":"k03", "x":3.5, "y":0},
+          {"label":"k04", "x":4.5, "y":0},
+          {"label":"k05", "x":5.5, "y":0},
+          {"label":"k06", "x":6.5, "y":0},
+          {"label":"k07", "x":7.5, "y":0},
+          {"label":"k08", "x":8.5, "y":0},
+          {"label":"k09", "x":9.5, "y":0},
+          {"label":"k010", "x":10.5, "y":0},
+          {"label":"k011", "x":11.5, "y":0},
+          {"label":"k012", "x":12.5, "y":0},
+          {"label":"k013", "x":13.5, "y":0, "w":1.5},
+          {"label":"k10", "x":0, "y":1, "w":1.5},
+          {"label":"k11", "x":1.5, "y":1},
+          {"label":"k12", "x":2.5, "y":1},
+          {"label":"k13", "x":3.5, "y":1},
+          {"label":"k14", "x":4.5, "y":1},
+          {"label":"k15", "x":5.5, "y":1},
+          {"label":"k16", "x":6.5, "y":1},
+          {"label":"k17", "x":7.5, "y":1},
+          {"label":"k18", "x":8.5, "y":1},
+          {"label":"k19", "x":9.5, "y":1},
+          {"label":"k110", "x":10.5, "y":1},
+          {"label":"k111", "x":11.5, "y":1},
+          {"label":"k112", "x":12.5, "y":1},
+          {"label":"k113", "x":13.5, "y":1, "w":1.5},
+          {"label":"k20", "x":0, "y":2, "w":1.5},
+          {"label":"k21", "x":1.5, "y":2},
+          {"label":"k22", "x":2.5, "y":2},
+          {"label":"k23", "x":3.5, "y":2},
+          {"label":"k24", "x":4.5, "y":2},
+          {"label":"k25", "x":5.5, "y":2},
+          {"label":"k26", "x":6.5, "y":2},
+          {"label":"k27", "x":7.5, "y":2},
+          {"label":"k28", "x":8.5, "y":2},
+          {"label":"k29", "x":9.5, "y":2},
+          {"label":"k210", "x":10.5, "y":2},
+          {"label":"k211", "x":11.5, "y":2},
+          {"label":"k212", "x":12.5, "y":2, "w":1.5},
+          {"label":"k213", "x":14, "y":2},
+          {"label":"k30", "x":0, "y":3, "w":1.5},
+          {"label":"k31", "x":1.5, "y":3},
+          {"label":"k32", "x":2.5, "y":3},
+          {"label":"k33", "x":3.5, "y":3},
+          {"label":"k34", "x":4.5, "y":3},
+          {"label":"k35", "x":5.5, "y":3},
+          {"label":"k36", "x":6.5, "y":3},
+          {"label":"k37", "x":7.5, "y":3},
+          {"label":"k38", "x":8.5, "y":3},
+          {"label":"k39", "x":9.5, "y":3},
+          {"label":"k310", "x":10.5, "y":3},
+          {"label":"k311", "x":11.5, "y":3, "w":1.5},
+          {"label":"k312", "x":13, "y":3},
+          {"label":"k313", "x":14, "y":3},
+          {"label":"k40", "x":0, "y":4, "w":1.25},
+          {"label":"k41", "x":1.25, "y":4, "w":1.25},
+          {"label":"k42", "x":2.5, "y":4},
+          {"label":"k43", "x":3.5, "y":4},
+          {"label":"k44", "x":4.5, "y":4, "w":2},
+          {"label":"k46", "x":6.5, "y":4, "w":2},
+          {"label":"k48", "x":8.5, "y":4},
+          {"label":"k49", "x":9.5, "y":4, "w":1.25},
+          {"label":"k410", "x":10.75, "y":4, "w":1.25},
+          {"label":"k411", "x":12, "y":4},
+          {"label":"k412", "x":13, "y":4},
+          {"label":"k413", "x":14, "y":4}
+        ]
+      },
+      "LAYOUT_625u_arrow": {
+        "layout": [
+          {"label":"k00", "x":0, "y":0, "w":1.5},
+          {"label":"k01", "x":1.5, "y":0},
+          {"label":"k02", "x":2.5, "y":0},
+          {"label":"k03", "x":3.5, "y":0},
+          {"label":"k04", "x":4.5, "y":0},
+          {"label":"k05", "x":5.5, "y":0},
+          {"label":"k06", "x":6.5, "y":0},
+          {"label":"k07", "x":7.5, "y":0},
+          {"label":"k08", "x":8.5, "y":0},
+          {"label":"k09", "x":9.5, "y":0},
+          {"label":"k010", "x":10.5, "y":0},
+          {"label":"k011", "x":11.5, "y":0},
+          {"label":"k012", "x":12.5, "y":0},
+          {"label":"k013", "x":13.5, "y":0, "w":1.5},
+          {"label":"k10", "x":0, "y":1, "w":1.5},
+          {"label":"k11", "x":1.5, "y":1},
+          {"label":"k12", "x":2.5, "y":1},
+          {"label":"k13", "x":3.5, "y":1},
+          {"label":"k14", "x":4.5, "y":1},
+          {"label":"k15", "x":5.5, "y":1},
+          {"label":"k16", "x":6.5, "y":1},
+          {"label":"k17", "x":7.5, "y":1},
+          {"label":"k18", "x":8.5, "y":1},
+          {"label":"k19", "x":9.5, "y":1},
+          {"label":"k110", "x":10.5, "y":1},
+          {"label":"k111", "x":11.5, "y":1},
+          {"label":"k112", "x":12.5, "y":1},
+          {"label":"k113", "x":13.5, "y":1, "w":1.5},
+          {"label":"k20", "x":0, "y":2, "w":1.5},
+          {"label":"k21", "x":1.5, "y":2},
+          {"label":"k22", "x":2.5, "y":2},
+          {"label":"k23", "x":3.5, "y":2},
+          {"label":"k24", "x":4.5, "y":2},
+          {"label":"k25", "x":5.5, "y":2},
+          {"label":"k26", "x":6.5, "y":2},
+          {"label":"k27", "x":7.5, "y":2},
+          {"label":"k28", "x":8.5, "y":2},
+          {"label":"k29", "x":9.5, "y":2},
+          {"label":"k210", "x":10.5, "y":2},
+          {"label":"k211", "x":11.5, "y":2},
+          {"label":"k212", "x":12.5, "y":2, "w":1.5},
+          {"label":"k213", "x":14, "y":2},
+          {"label":"k30", "x":0, "y":3, "w":1.5},
+          {"label":"k31", "x":1.5, "y":3},
+          {"label":"k32", "x":2.5, "y":3},
+          {"label":"k33", "x":3.5, "y":3},
+          {"label":"k34", "x":4.5, "y":3},
+          {"label":"k35", "x":5.5, "y":3},
+          {"label":"k36", "x":6.5, "y":3},
+          {"label":"k37", "x":7.5, "y":3},
+          {"label":"k38", "x":8.5, "y":3},
+          {"label":"k39", "x":9.5, "y":3},
+          {"label":"k310", "x":10.5, "y":3},
+          {"label":"k311", "x":11.5, "y":3, "w":1.5},
+          {"label":"k312", "x":13, "y":3},
+          {"label":"k313", "x":14, "y":3},
+          {"label":"k40", "x":0, "y":4, "w":1.25},
+          {"label":"k41", "x":1.25, "y":4, "w":1.25},
+          {"label":"k42", "x":2.5, "y":4},
+          {"label":"k45", "x":3.5, "y":4, "w":6.25},
+          {"label":"k49", "x":9.75, "y":4},
+          {"label":"k410", "x":10.75, "y":4, "w":1.25},
+          {"label":"k411", "x":12, "y":4},
+          {"label":"k412", "x":13, "y":4},
+          {"label":"k413", "x":14, "y":4}
+        ]
+      }
+    }
+  }

keyboards/boardwalk/keymaps/default/config.h

@@ -0,0 +1,16 @@
+/*
+ * 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

keyboards/boardwalk/keymaps/default/keymap.c

@@ -0,0 +1,162 @@
+/*
+ * 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 {
+  _1U,
+  _FN,
+  _HHKB,
+  _7U,
+  _2UARROW,
+  _625UARROW,
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+/* 1uGrid
+ * .-----------------------------------------------------------------------------------------------------------------------------.
+ * | 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  | LGUI   | FN     | LALT   | SPACE  | SPACE  | SPACE  | SPACE  | SPACE  | SPACE  | RIGHT  | DOWN   | UP     | RIGHT  |
+ * '-----------------------------------------------------------------------------------------------------------------------------'
+ */
+
+ [_1U] = 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_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, \
+  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  \
+ ),
+
+ /* 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(
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
+ )
+};

keyboards/boardwalk/keymaps/default/readme.md

@@ -0,0 +1 @@
+# The default keymap for Boardwalk

keyboards/boardwalk/keymaps/mcallaster/keymap.c

@@ -0,0 +1,54 @@
+#include QMK_KEYBOARD_H
+
+// Layer shorthand
+enum layer {
+  _BASE,
+  _LOWER,
+  _RAISE,
+  _FN
+};
+
+#define LOWER MO(1)
+#define RAISE MO(2)
+#define FN    MO(3)
+
+// Mac sleep
+#define __SLEEP S(LCTL(KC_POWER))
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [_BASE] = LAYOUT_ortho_hhkb(
+  KC_ESC,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_SLCK, KC_PSCR, KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_GRV,  \
+  KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_HOME, KC_PGUP, 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_END,  KC_PGDN, 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_DEL,  KC_INS,  KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ENT,  \
+           KC_CAPS, KC_LALT, KC_LGUI, RAISE,        KC_SPC,           KC_SPC,      LOWER,   KC_RGUI, KC_RALT, KC_RCTL
+  ),
+
+  [_LOWER] = LAYOUT_ortho_hhkb(
+  _______, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_PAUS, KC_NLCK, KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  _______, \
+  _______, 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_LBRC, KC_RBRC, _______, \
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_GRV,  KC_BSLS, _______, _______, _______, \
+           _______, _______, _______, _______,       _______,       _______,       _______, _______, _______, _______
+  ),
+
+  [_RAISE] = LAYOUT_ortho_hhkb(
+  _______, KC_F11,  KC_F12,  _______, _______, _______, KC_PAUS, KC_NLCK, _______, _______, _______, _______, _______, _______, \
+  _______, KC_EXLM, KC_AT,   KC_HASH, KC_DLR,  KC_PERC, _______, _______, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, _______, \
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, _______, \
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_TILD, KC_PIPE, _______, _______, _______, \
+           _______, _______, _______, _______,       _______,       _______,       _______, _______, _______, _______
+  ),
+
+  [_FN] = LAYOUT_ortho_hhkb(
+  __SLEEP, _______, _______, _______, _______, _______, RGB_TOG, RGB_MOD, _______, _______, _______, _______, _______, _______, \
+  _______, RESET,   _______, KC_MPRV, KC_MNXT, _______, RGB_SAI, RGB_HUI, _______, _______, _______, _______, _______, _______, \
+  _______, KC_VOLD, KC_VOLU, KC_MUTE, KC_MPLY, _______, RGB_SAD, RGB_HUD, _______, KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT, _______, \
+  _______, _______, _______, _______, _______, _______, RGB_VAD, RGB_VAI, _______, _______, _______, _______, _______, _______, \
+           _______, _______, _______, _______,       _______,       _______,       _______, _______, _______, _______
+  )
+};
+
+uint32_t layer_state_set_user(uint32_t state) {
+  return update_tri_layer_state(state, _LOWER, _RAISE, _FN);
+}