Fixing incorrect usage of RGBLED_NUM in ws2812 driver when used with RGB Matrix (#5744)

* Add H87a keymap and info

* Create readme.md

* Add h87a .json for kbfirmware.com use

* Update readme.md

* Update readme.md

* Update h87a files

* Delete Makefile

* Update readme.md

* Delete desktop.ini

* update files to match new QMK framework

* Update files to match new QMK structure

* Update files to match new QMK structure

* add layout name information

* Add info.json

* update keymap to support layout_all

* update keymap to support layout_all

* update rules.mk to fix filesize

* Update readme.md

* Update config.h

* Update readme.md

* Update config.h

* Update config.h

Add "define CONFIG_H and include "config_common.h" back to file

* update config.h to include RGB turnoff when PC goes to sleep

* update info.json

* update info.json

* Update readme.md

Add project link

* Update readme.md

* refactor hineybush projects into single folder. update hineyg80 to modern code

* updated layout file to reflect new keymap changes

* actually updated all layout names this time, verified make

* Update keyboards/hineybush/h87a/h87a.h

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/keymaps/default/config.h

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/readme.md

Co-Authored-By: hineybush <josh@hinnebus.ch>

* edit based on PR edit requests

* update hiney80 files to avoid confusion

* update hineyg80.h to reflect matrix

* Update keyboards/hineybush/hineyg80/info.json

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/info.json

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/info.json

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/info.json

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/keymaps/default/config.h

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/keymaps/wkl/config.h

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/keymaps/default/config.h

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/readme.md

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/readme.md

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/readme.md

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/readme.md

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/keymaps/default/config.h

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/keymaps/wkl/config.h

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/keymaps/wkl/config.h

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/keymaps/default/config.h

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/keymaps/wkl/config.h

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/readme.md

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/keymaps/wkl/config.h

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/readme.md

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/hineyg80.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* update hineyg80 config.h

* Update keyboards/hineybush/h87a/keymaps/wkl/keymap.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/keymaps/wkl/keymap.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/keymaps/wkl/keymap.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/keymaps/wkl/keymap.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/hineyg80.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/hineyg80.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/hineyg80.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/keymaps/wkl/keymap.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/keymaps/wkl/keymap.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/keymaps/wkl/keymap.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/h87a/keymaps/wkl/keymap.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/hineyg80.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/hineyg80.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/hineyg80.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/hineyg80.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/hineyg80.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/hineyg80.c

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/config.h

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/config.h

Co-Authored-By: hineybush <josh@hinnebus.ch>

* Update keyboards/hineybush/hineyg80/config.h

Co-Authored-By: hineybush <josh@hinnebus.ch>

.clang-format

@@ -1,4 +1,4 @@
----
+---
 BasedOnStyle: Google
 AlignAfterOpenBracket: Align
 AlignConsecutiveAssignments: 'true'
@@ -20,7 +20,7 @@ SortIncludes: 'false'
 SpaceBeforeAssignmentOperators: 'true'
 SpaceBeforeParens: ControlStatements
 SpaceInEmptyParentheses: 'false'
-TabWidth: '2'
+TabWidth: '4'
 UseTab: Never
 
 ...

.editorconfig

@@ -5,7 +5,7 @@ root = true
 
 [*]
 indent_style = space
-indent_size = 2
+indent_size = 4
 
 # We recommend you to keep these unchanged
 charset = utf-8

.gitignore

@@ -54,6 +54,7 @@ util/Win_Check_Output.txt
 .vscode/tasks.json
 .vscode/last.sql
 .vscode/temp.sql
+.vscode/ipch/
 .stfolder
 .tags
 

.travis.yml

@@ -21,7 +21,7 @@ before_script:
   - avr-gcc --version
 script:
 - git rev-parse --short HEAD
-- make test:all
+- bash util/travis_test.sh
 - bash util/travis_build.sh
 - bash util/travis_docs.sh
 addons:

build_keyboard.mk

@@ -280,6 +280,23 @@ ifneq ("$(wildcard $(KEYBOARD_PATH_1)/config.h)","")
     CONFIG_H += $(KEYBOARD_PATH_1)/config.h
 endif
 
+POST_CONFIG_H :=
+ifneq ("$(wildcard $(KEYBOARD_PATH_1)/post_config.h)","")
+    POST_CONFIG_H += $(KEYBOARD_PATH_1)/post_config.h
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_2)/post_config.h)","")
+    POST_CONFIG_H += $(KEYBOARD_PATH_2)/post_config.h
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_3)/post_config.h)","")
+    POST_CONFIG_H += $(KEYBOARD_PATH_3)/post_config.h
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_4)/post_config.h)","")
+    POST_CONFIG_H += $(KEYBOARD_PATH_4)/post_config.h
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_5)/post_config.h)","")
+    POST_CONFIG_H += $(KEYBOARD_PATH_5)/post_config.h
+endif
+
 # Save the defines and includes here, so we don't include any keymap specific ones
 PROJECT_DEFS := $(OPT_DEFS)
 PROJECT_INC := $(VPATH) $(EXTRAINCDIRS) $(KEYBOARD_PATHS)
@@ -355,6 +372,7 @@ ifeq ($(strip $(VISUALIZER_ENABLE)), yes)
     include $(VISUALIZER_PATH)/visualizer.mk
 endif
 
+CONFIG_H += $(POST_CONFIG_H)
 ALL_CONFIGS := $(PROJECT_CONFIG) $(CONFIG_H)
 
 OUTPUTS := $(KEYMAP_OUTPUT) $(KEYBOARD_OUTPUT)

common_features.mk

@@ -103,6 +103,7 @@ ifeq ($(strip $(UNICODE_COMMON)), yes)
 endif
 
 ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
+    POST_CONFIG_H += $(QUANTUM_DIR)/rgblight_post_config.h
     OPT_DEFS += -DRGBLIGHT_ENABLE
     SRC += $(QUANTUM_DIR)/rgblight.c
     CIE1931_CURVE = yes
@@ -177,6 +178,14 @@ ifeq ($(strip $(RGB_MATRIX_ENABLE)), WS2812)
     SRC += ws2812.c
 endif
 
+ifeq ($(strip $(RGB_MATRIX_CUSTOM_KB)), yes)
+    OPT_DEFS += -DRGB_MATRIX_CUSTOM_KB
+endif
+
+ifeq ($(strip $(RGB_MATRIX_CUSTOM_USER)), yes)
+    OPT_DEFS += -DRGB_MATRIX_CUSTOM_USER
+endif
+
 ifeq ($(strip $(TAP_DANCE_ENABLE)), yes)
     OPT_DEFS += -DTAP_DANCE_ENABLE
     SRC += $(QUANTUM_DIR)/process_keycode/process_tap_dance.c
@@ -318,6 +327,7 @@ ifneq ($(strip $(DEBOUNCE_TYPE)), custom)
 endif
 
 ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
+    POST_CONFIG_H += $(QUANTUM_DIR)/split_common/post_config.h
     OPT_DEFS += -DSPLIT_KEYBOARD
 
     # Include files used by all split keyboards
@@ -334,3 +344,16 @@ ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
     endif
     COMMON_VPATH += $(QUANTUM_PATH)/split_common
 endif
+
+ifeq ($(strip $(OLED_DRIVER_ENABLE)), yes)
+    OPT_DEFS += -DOLED_DRIVER_ENABLE
+    COMMON_VPATH += $(DRIVER_PATH)/oled
+    QUANTUM_LIB_SRC += i2c_master.c
+    SRC += oled_driver.c
+endif
+
+SPACE_CADET_ENABLE ?= yes
+ifeq ($(strip $(SPACE_CADET_ENABLE)), yes)
+  SRC += $(QUANTUM_DIR)/process_keycode/process_space_cadet.c
+  OPT_DEFS += -DSPACE_CADET_ENABLE
+endif

docs/_summary.md

@@ -63,13 +63,13 @@
   * [LED Matrix](feature_led_matrix.md)
   * [Macros](feature_macros.md)
   * [Mouse Keys](feature_mouse_keys.md)
+  * [OLED Driver](feature_oled_driver)
   * [One Shot Keys](feature_advanced_keycodes.md#one-shot-keys)
   * [Pointing Device](feature_pointing_device.md)
   * [PS/2 Mouse](feature_ps2_mouse.md)
   * [RGB Lighting](feature_rgblight.md)
   * [RGB Matrix](feature_rgb_matrix.md)
-  * [Space Cadet Shift](feature_space_cadet_shift.md)
-  * [Space Cadet Shift Enter](feature_space_cadet_shift_enter.md)
+  * [Space Cadet](feature_space_cadet.md)
   * [Stenography](feature_stenography.md)
   * [Swap Hands](feature_swap_hands.md)
   * [Tap Dance](feature_tap_dance.md)

docs/config_options.md

@@ -180,10 +180,12 @@ If you define these options you will enable the associated feature, which may in
   * run RGB animations
 * `#define RGBLED_NUM 12`
   * number of LEDs
+* `#define RGBLIGHT_SPLIT`
+  * Needed if both halves of the board have RGB LEDs wired directly to the RGB output pin on the controllers instead of passing the output of the left half to the input of the right half
 * `#define RGBLED_SPLIT { 6, 6 }`
   * number of LEDs connected that are directly wired to `RGB_DI_PIN` on each half of a split keyboard
   * First value indicates number of LEDs for left half, second value is for the right half
-  * Needed if both halves of the board have RGB LEDs wired directly to the RGB output pin on the controllers instead of passing the output of the left half to the input of the right half
+  * When RGBLED_SPLIT is defined, RGBLIGHT_SPLIT is implicitly defined.
 * `#define RGBLIGHT_HUE_STEP 12`
   * units to step when in/decreasing hue
 * `#define RGBLIGHT_SAT_STEP 25`

docs/contributing.md

@@ -56,7 +56,7 @@ Never made an open source contribution before? Wondering how contributions work
 
 Most of our style is pretty easy to pick up on, but right now it's not entirely consistent. You should match the style of the code surrounding your change, but if that code is inconsistent or unclear use the following guidelines:
 
-* We indent using two spaces (soft tabs)
+* We indent using four (4) spaces (soft tabs)
 * We use a modified One True Brace Style
   * Opening Brace: At the end of the same line as the statement that opens the block
   * Closing Brace: Lined up with the first character of the statement that opens the block
@@ -71,6 +71,14 @@ Most of our style is pretty easy to pick up on, but right now it's not entirely
   * If you not sure if a comment is obvious, go ahead and include it.
 * In general we don't wrap lines, they can be as long as needed. If you do choose to wrap lines please do not wrap any wider than 76 columns.
 * We use `#pragma once` at the start of header files rather than old-style include guards (`#ifndef THIS_FILE_H`, `#define THIS_FILE_H`, ..., `#endif`)
+* We accept both forms of preprocessor if's: `#ifdef DEFINED` and `#if defined(DEFINED)`
+  * If you are not sure which to prefer use the `#if defined(DEFINED)` form.
+  * Do not change existing code from one style to the other, except when moving to a multiple condition `#if`.
+  * Do not put whitespace between `#` and `if`.
+  * When deciding how (or if) to indent directives keep these points in mind:
+    * Readability is more important than consistency.
+    * Follow the file's existing style. If the file is mixed follow the style that makes sense for the section you are modifying.
+    * When choosing to indent you can follow the indention level of the surrounding C code, or preprocessor directives can have their own indent level. Choose the style that best communicates the intent of your code.
 
 Here is an example for easy reference:
 

docs/feature_backlight.md

@@ -30,7 +30,31 @@ You should then be able to use the keycodes below to change the backlight level.
 
 This feature is distinct from both the [RGB underglow](feature_rgblight.md) and [RGB matrix](feature_rgb_matrix.md) features as it usually allows for only a single colour per switch, though you can obviously use multiple different coloured LEDs on a keyboard.
 
-Hardware PWM is only supported on certain pins of the MCU, so if the backlighting is not connected to one of them, a software implementation will be used, and backlight breathing will not be available. Currently the supported pins are `B5`, `B6`, `B7`, and `C6`.
+Hardware PWM is only supported on certain pins of the MCU, so if the backlighting is not connected to one of them, a software PWM implementation triggered by hardware timer interrupts will be used.
+
+Hardware PWM is supported according to the following table:
+
+| Backlight Pin | Hardware timer |
+|---------------|----------------|
+|`B5`           | Timer 1        |
+|`B6`           | Timer 1        |
+|`B7`           | Timer 1        |
+|`C6`           | Timer 3        |
+| other         | Software PWM   |
+
+The [audio feature](feature_audio.md) also uses hardware timers. Please refer to the following table to know what hardware timer the software PWM will use depending on the audio configuration:
+
+| Audio Pin(s) | Audio Timer | Software PWM Timer |
+|--------------|-------------|--------------------|
+| `C4`         | Timer 3     | Timer 1            |
+| `C5`         | Timer 3     | Timer 1            |
+| `C6`         | Timer 3     | Timer 1            |
+| `B5`         | Timer 1     | Timer 3            |
+| `B6`         | Timer 1     | Timer 3            |
+| `B7`         | Timer 1     | Timer 3            |
+| `Bx` & `Cx`  | Timer 1 & 3 | None               |
+
+When all timers are in use for [audio](feature_audio.md), the backlight software PWM will not use a hardware timer, but instead will be triggered during the matrix scan. In this case the backlight doesn't support breathing and might show lighting artifacts (for instance flickering), because the PWM computation might not be called with enough timing precision.
 
 ## Configuration
 
@@ -39,11 +63,26 @@ To change the behaviour of the backlighting, `#define` these in your `config.h`:
 |Define               |Default      |Description                                                                                                  |
 |---------------------|-------------|-------------------------------------------------------------------------------------------------------------|
 |`BACKLIGHT_PIN`      |`B7`         |The pin that controls the LEDs. Unless you are designing your own keyboard, you shouldn't need to change this|
+|`BACKLIGHT_PINS`     |*Not defined*|experimental: see below for more information|
 |`BACKLIGHT_LEVELS`   |`3`          |The number of brightness levels (maximum 15 excluding off)                                                   |
 |`BACKLIGHT_CAPS_LOCK`|*Not defined*|Enable Caps Lock indicator using backlight (for keyboards without dedicated LED)                             |
-|`BACKLIGHT_BREATHING`|*Not defined*|Enable backlight breathing, if hardware PWM is used                                                          |
+|`BACKLIGHT_BREATHING`|*Not defined*|Enable backlight breathing, if supported                                                          |
 |`BREATHING_PERIOD`   |`6`          |The length of one backlight "breath" in seconds                                                              |
 
+## Multiple backlight pins
+
+Most keyboards have only one backlight pin which control all backlight LEDs (especially if the backlight is connected to an hardware PWM pin).
+In software PWM, it is possible to define multiple backlight pins. All those pins will be turned on and off at the same time during the PWM duty cycle.
+This feature allows to set for instance the Caps Lock LED (or any other controllable LED) brightness at the same level as the other LEDs of the backlight. This is useful if you have mapped LCTRL in place of Caps Lock and you need the Caps Lock LED to be part of the backlight instead of being activated when Caps Lock is on.
+
+To activate multiple backlight pins, you need to add something like this to your user `config.h`:
+
+~~~c
+#define BACKLIGHT_LED_COUNT 2
+#undef BACKLIGHT_PIN
+#define BACKLIGHT_PINS { F5, B2 }
+~~~
+
 ## Hardware PWM Implementation
 
 When using the supported pins for backlighting, QMK will use a hardware timer configured to output a PWM signal. This timer will count up to `ICRx` (by default `0xFFFF`) before resetting to 0.
@@ -53,6 +92,15 @@ In this way `OCRxx` essentially controls the duty cycle of the LEDs, and thus th
 The breathing effect is achieved by registering an interrupt handler for `TIMER1_OVF_vect` that is called whenever the counter resets, roughly 244 times per second.
 In this handler, the value of an incrementing counter is mapped onto a precomputed brightness curve. To turn off breathing, the interrupt handler is simply disabled, and the brightness reset to the level stored in EEPROM.
 
+## Software PWM Implementation
+
+When `BACKLIGHT_PIN` is not set to a hardware backlight pin, QMK will use a hardware timer configured to trigger software interrupts. This time will count up to `ICRx` (by default `0xFFFF`) before resetting to 0.
+When resetting to 0, the CPU will fire an OVF (overflow) interrupt that will turn the LEDs on, starting the duty cycle.
+The desired brightness is calculated and stored in the `OCRxx` register. When the counter reaches this value, the CPU will fire a Compare Output match interrupt, which will turn the LEDs off.
+In this way `OCRxx` essentially controls the duty cycle of the LEDs, and thus the brightness, where `0x0000` is completely off and `0xFFFF` is completely on.
+
+The breathing effect is the same as in the hardware PWM implementation.
+
 ## Backlight Functions
 
 |Function  |Description                                                |

docs/feature_mouse_keys.md

@@ -1,114 +1,119 @@
-# Mousekeys
+# Mouse keys
 
+Mouse keys is a feature that allows you to emulate a mouse using your keyboard. You can move the pointer at different speeds, press 5 buttons and scroll in 8 directions.
 
-Mousekeys is a feature that allows you to emulate a mouse using your keyboard. You can move the pointer around, click up to 5 buttons, and even scroll in all 4 directions.
+## Adding mouse keys to your keyboard
 
-There are 2 ways to define how the mousekeys behave, using "[auto-accelerating](#configuring-the-behavior-of-mousekeys-with-auto-accelerated-movement)" or "[3-speed constant](#configuring-the-behavior-of-mousekeys-with-3-speed-constant-movement)" behavior.
+To use mouse keys, you must at least enable mouse keys support and map mouse actions to keys on your keyboard.
 
-In either case, you will need to enable mousekeys in your makefile,
-and add the relevant [keycodes](#mapping-mouse-actions-to-keyboard-keys) to your keymap.
+### Enabling mouse keys
 
-#### Enable Mousekeys
+To enable mouse keys, add the following line to your keymap’s `rules.mk`:
 
-To enable the mousekey functionality, add the following line to your keymap's `rules.mk`:
-
-```
+```c
 MOUSEKEY_ENABLE = yes
 ```
 
-#### Mapping Mouse Actions to Keyboard Keys
+### Mapping mouse actions
 
-You can use these keycodes within your keymap to map button presses to mouse actions:
+In your keymap you can use the following keycodes to map key presses to mouse actions:
 
-|Key             |Aliases  |Description                        |
-|----------------|---------|-----------------------------------|
-|`KC_MS_UP`      |`KC_MS_U`|Mouse Cursor Up                    |
-|`KC_MS_DOWN`    |`KC_MS_D`|Mouse Cursor Down                  |
-|`KC_MS_LEFT`    |`KC_MS_L`|Mouse Cursor Left                  |
-|`KC_MS_RIGHT`   |`KC_MS_R`|Mouse Cursor Right                 |
-|`KC_MS_BTN1`    |`KC_BTN1`|Mouse Button 1                     |
-|`KC_MS_BTN2`    |`KC_BTN2`|Mouse Button 2                     |
-|`KC_MS_BTN3`    |`KC_BTN3`|Mouse Button 3                     |
-|`KC_MS_BTN4`    |`KC_BTN4`|Mouse Button 4                     |
-|`KC_MS_BTN5`    |`KC_BTN5`|Mouse Button 5                     |
-|`KC_MS_WH_UP`   |`KC_WH_U`|Mouse Wheel Up                     |
-|`KC_MS_WH_DOWN` |`KC_WH_D`|Mouse Wheel Down                   |
-|`KC_MS_WH_LEFT` |`KC_WH_L`|Mouse Wheel Left                   |
-|`KC_MS_WH_RIGHT`|`KC_WH_R`|Mouse Wheel Right                  |
-|`KC_MS_ACCEL0`  |`KC_ACL0`|Set mouse acceleration to 0(slow)  |
-|`KC_MS_ACCEL1`  |`KC_ACL1`|Set mouse acceleration to 1(medium)|
-|`KC_MS_ACCEL2`  |`KC_ACL2`|Set mouse acceleration to 2(fast)  |
+|Key             |Aliases  |Description      |
+|----------------|---------|-----------------|
+|`KC_MS_UP`      |`KC_MS_U`|Move cursor up   |
+|`KC_MS_DOWN`    |`KC_MS_D`|Move cursor down |
+|`KC_MS_LEFT`    |`KC_MS_L`|Move cursor left |
+|`KC_MS_RIGHT`   |`KC_MS_R`|Move cursor right|
+|`KC_MS_BTN1`    |`KC_BTN1`|Press button 1   |
+|`KC_MS_BTN2`    |`KC_BTN2`|Press button 2   |
+|`KC_MS_BTN3`    |`KC_BTN3`|Press button 3   |
+|`KC_MS_BTN4`    |`KC_BTN4`|Press button 4   |
+|`KC_MS_BTN5`    |`KC_BTN5`|Press button 5   |
+|`KC_MS_WH_UP`   |`KC_WH_U`|Move wheel up    |
+|`KC_MS_WH_DOWN` |`KC_WH_D`|Move wheel down  |
+|`KC_MS_WH_LEFT` |`KC_WH_L`|Move wheel left  |
+|`KC_MS_WH_RIGHT`|`KC_WH_R`|Move wheel right |
+|`KC_MS_ACCEL0`  |`KC_ACL0`|Set speed to 0   |
+|`KC_MS_ACCEL1`  |`KC_ACL1`|Set speed to 1   |
+|`KC_MS_ACCEL2`  |`KC_ACL2`|Set speed to 2   |
 
+## Configuring mouse keys
 
-## Configuring the Behavior of Mousekeys with auto-accelerated movement
+Mouse keys supports two different modes to move the cursor:
 
-This behavior is intended to emulate the X Window System MouseKeysAccel feature. You can read more about it [on Wikipedia](https://en.wikipedia.org/wiki/Mouse_keys).
+* **Accelerated (default):** Holding movement keys accelerates the cursor until it reaches its maximum speed.
+* **Constant:** Holding movement keys moves the cursor at constant speeds.
 
-The default speed for controlling the mouse with the keyboard is intentionally slow. You can adjust these parameters by adding these settings to your keymap's `config.h` file. All times are specified in milliseconds (ms).
+The same principle applies to scrolling.
 
-```
-#define MOUSEKEY_DELAY             300
-#define MOUSEKEY_INTERVAL          50
-#define MOUSEKEY_MAX_SPEED         10
-#define MOUSEKEY_TIME_TO_MAX       20
-#define MOUSEKEY_WHEEL_MAX_SPEED   8
-#define MOUSEKEY_WHEEL_TIME_TO_MAX 40
-```
+Configuration options that are times, intervals or delays are given in milliseconds. Scroll speed is given as multiples of the default scroll step. For example, a scroll speed of 8 means that each scroll action covers 8 times the length of the default scroll step as defined by your operating system or application.
 
-#### `MOUSEKEY_DELAY`
+### Accelerated mode
 
-When one of the mouse movement buttons is pressed this setting is used to define the delay between that button press and the mouse cursor moving. Some people find that small movements are impossible if this setting is too low, while settings that are too high feel sluggish.
+This is the default mode. You can adjust the cursor and scrolling acceleration using the following settings in your keymap’s `config.h` file:
 
-#### `MOUSEKEY_INTERVAL`
+|Define                      |Default|Description                                              |
+|----------------------------|-------|---------------------------------------------------------|
+|`MOUSEKEY_DELAY`            |300    |Delay between pressing a movement key and cursor movement|
+|`MOUSEKEY_INTERVAL`         |50     |Time between cursor movements                            |
+|`MOUSEKEY_MAX_SPEED`        |10     |Maximum cursor speed at which acceleration stops         |
+|`MOUSEKEY_TIME_TO_MAX`      |20     |Time until maximum cursor speed is reached               |
+|`MOUSEKEY_WHEEL_MAX_SPEED`  |8      |Maximum number of scroll steps per scroll action         |
+|`MOUSEKEY_WHEEL_TIME_TO_MAX`|40     |Time until maximum scroll speed is reached               |
 
-When a movement key is held down this specifies how long to wait between each movement report. Lower settings will translate into an effectively higher mouse speed.
+Tips:
 
-#### `MOUSEKEY_MAX_SPEED`
+* Setting `MOUSEKEY_DELAY` too low makes the cursor unresponsive. Setting it too high makes small movements difficult.
+* For smoother cursor movements, lower the value of `MOUSEKEY_INTERVAL`. If the refresh rate of your display is 60Hz, you could set it to `16` (1/60). As this raises the cursor speed significantly, you may want to lower `MOUSEKEY_MAX_SPEED`.
+* Setting `MOUSEKEY_TIME_TO_MAX` or `MOUSEKEY_WHEEL_TIME_TO_MAX` to `0` will disable acceleration for the cursor or scrolling respectively. This way you can make one of them constant while keeping the other accelerated, which is not possible in constant speed mode.
 
-As a movement key is held down the speed of the mouse cursor will increase until it reaches `MOUSEKEY_MAX_SPEED`.
+Cursor acceleration uses the same algorithm as the X Window System MouseKeysAccel feature. You can read more about it [on Wikipedia](https://en.wikipedia.org/wiki/Mouse_keys).
 
-#### `MOUSEKEY_TIME_TO_MAX`
+### Constant mode
 
-How long you want to hold down a movement key for until `MOUSEKEY_MAX_SPEED` is reached. This controls how quickly your cursor will accelerate.
+In this mode you can define multiple different speeds for both the cursor and the mouse wheel. There is no acceleration. `KC_ACL0`, `KC_ACL1` and `KC_ACL2` change the cursor and scroll speed to their respective setting.
 
-#### `MOUSEKEY_WHEEL_MAX_SPEED`
+You can choose whether speed selection is momentary or tap-to-select:
 
-The top speed for scrolling movements.
+* **Momentary:** The chosen speed is only active while you hold the respective key. When the key is raised, mouse keys returns to the unmodified speed.
+* **Tap-to-select:** The chosen speed is activated when you press the respective key and remains active even after the key has been raised. The default speed is that of `KC_ACL1`. There is no unmodified speed.
 
-#### `MOUSEKEY_WHEEL_TIME_TO_MAX`
+The default speeds from slowest to fastest are as follows:
 
-How long you want to hold down a scroll key for until `MOUSEKEY_WHEEL_MAX_SPEED` is reached. This controls how quickly your scrolling will accelerate.
+* **Momentary:** `KC_ACL0` < `KC_ACL1` < *unmodified* < `KC_ACL2`
+* **Tap-to-select:** `KC_ACL0` < `KC_ACL1` < `KC_ACL2`
 
+To use constant speed mode, you must at least define `MK_3_SPEED` in your keymap’s `config.h` file:
 
-## Configuring the Behavior of Mousekeys with 3-speed constant movement
-
-In your keymap's `config.h`, you must add the line:
-```
+```c
 #define MK_3_SPEED
 ```
-Then you can precisely define 3 different speeds for both the cursor and the mouse wheel, and also whether speed selection is momentary or tap-to-select.
-For each speed, you can specify how many milliseconds you want between reports(interval), and how far you want to it to move per report(offset).
 
-For example:
+To enable momentary mode, also define `MK_MOMENTARY_ACCEL`:
 
-```
-#define MK_3_SPEED
-#define MK_MOMENTARY_ACCEL // comment this out for tap-to-select acceleration
-// cursor speeds:
-#define MK_C_OFFSET_SLOW     1 // pixels
-#define MK_C_INTERVAL_SLOW 100 // milliseconds
-#define MK_C_OFFSET_MED      4
-#define MK_C_INTERVAL_MED   16
-#define MK_C_OFFSET_FAST    12
-#define MK_C_INTERVAL_FAST  16
-// scroll wheel speeds:
-#define MK_W_OFFSET_SLOW     1 // wheel clicks
-#define MK_W_INTERVAL_SLOW 400 // milliseconds
-#define MK_W_OFFSET_MED      1
-#define MK_W_INTERVAL_MED  200
-#define MK_W_OFFSET_FAST     1
-#define MK_W_INTERVAL_FAST 100
+```c
+#define MK_MOMENTARY_ACCEL
 ```
 
-Medium values will be used as the default or unmodified speed.
-The speed at which both the cursor and scrolling move can be selected with KC_ACL0, KC_ACL1, KC_ACL2 for slow, medium, and fast. However, if you leave MK_MOMENTARY_ACCEL defined then there is no need to ever send KC_ACL1, since that will be the unmodified speed.
+Use the following settings if you want to adjust cursor movement or scrolling:
+
+|Define               |Default      |Description                                |
+|---------------------|-------------|-------------------------------------------|
+|`MK_3_SPEED`         |*Not defined*|Enable constant cursor speeds              |
+|`MK_MOMENTARY_ACCEL` |*Not defined*|Enable momentary speed selection           |
+|`MK_C_OFFSET_UNMOD`  |16           |Cursor offset per movement (unmodified)    |
+|`MK_C_INTERVAL_UNMOD`|16           |Time between cursor movements (unmodified) |
+|`MK_C_OFFSET_0`      |1            |Cursor offset per movement (`KC_ACL0`)     |
+|`MK_C_INTERVAL_0`    |32           |Time between cursor movements (`KC_ACL0`)  |
+|`MK_C_OFFSET_1`      |4            |Cursor offset per movement (`KC_ACL1`)     |
+|`MK_C_INTERVAL_1`    |16           |Time between cursor movements (`KC_ACL1`)  |
+|`MK_C_OFFSET_2`      |32           |Cursor offset per movement (`KC_ACL2`)     |
+|`MK_C_INTERVAL_2`    |16           |Time between cursor movements (`KC_ACL2`)  |
+|`MK_W_OFFSET_UNMOD`  |1            |Scroll steps per scroll action (unmodified)|
+|`MK_W_INTERVAL_UNMOD`|40           |Time between scroll steps (unmodified)     |
+|`MK_W_OFFSET_0`      |1            |Scroll steps per scroll action (`KC_ACL0`) |
+|`MK_W_INTERVAL_0`    |360          |Time between scroll steps (`KC_ACL0`)      |
+|`MK_W_OFFSET_1`      |1            |Scroll steps per scroll action (`KC_ACL1`) |
+|`MK_W_INTERVAL_1`    |120          |Time between scroll steps (`KC_ACL1`)      |
+|`MK_W_OFFSET_2`      |1            |Scroll steps per scroll action (`KC_ACL2`) |
+|`MK_W_INTERVAL_2`    |20           |Time between scroll steps (`KC_ACL2`)      |

docs/feature_oled_driver.md

@@ -0,0 +1,274 @@
+# OLED Driver
+
+## OLED Supported Hardware
+
+128x32 OLED modules using SSD1306 driver IC over I2C. Supported on AVR based keyboards. Possible but untested hardware includes ARM based keyboards and other sized OLED modules using SSD1306 over I2C, such as 128x64. 
+
+!> Warning: This OLED Driver currently uses the new i2c_master driver from split common code. If your split keyboard uses i2c to communication between sides this driver could cause an address conflict (serial is fine). Please contact your keyboard vendor and ask them to migrate to the latest split common code to fix this. 
+
+## Usage
+
+To enable the OLED feature, there are three steps. First, when compiling your keyboard, you'll need to set `OLED_DRIVER_ENABLE=yes` in `rules.mk`, e.g.:
+
+```
+OLED_DRIVER_ENABLE = yes
+```
+
+This enables the feature and the `OLED_DRIVER_ENABLE` define. Then in your `keymap.c` file, you will need to implement the user task call, e.g:
+
+```C++
+#ifdef OLED_DRIVER_ENABLE
+void oled_task_user(void) {
+  // Host Keyboard Layer Status
+  oled_write_P(PSTR("Layer: "), false);
+  switch (biton32(layer_state)) {
+    case _QWERTY:
+      oled_write_P(PSTR("Default\n"), false);
+      break;
+    case _FN:
+      oled_write_P(PSTR("FN\n"), false);
+      break;
+    case _ADJ:
+      oled_write_P(PSTR("ADJ\n"), false);
+      break;
+    default:
+      // Or use the write_ln shortcut over adding '\n' to the end of your string
+      oled_write_ln_P(PSTR("Undefined"), false);
+  }
+
+  // Host Keyboard LED Status
+  uint8_t led_usb_state = host_keyboard_leds();
+  oled_write_P(led_usb_state & (1<<USB_LED_NUM_LOCK) ? PSTR("NUMLCK ") : PSTR("       "), false);
+  oled_write_P(led_usb_state & (1<<USB_LED_CAPS_LOCK) ? PSTR("CAPLCK ") : PSTR("       "), false);
+  oled_write_P(led_usb_state & (1<<USB_LED_SCROLL_LOCK) ? PSTR("SCRLCK ") : PSTR("       "), false);
+}
+#endif
+```
+
+## Logo Example
+
+In the default font, ranges in the font file are reserved for a QMK Logo. To Render this logo to the oled screen, use the following code example:
+
+```C++
+static void render_logo(void) {
+  static const char PROGMEM qmk_logo[] = {
+    0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,
+    0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4,
+    0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0xd4,0};
+
+  oled_write_P(qmk_logo, false);
+}
+```
+
+## Other Examples
+
+In split keyboards, it is very common to have two OLED displays that each render different content and oriented flipped differently. You can do this by switching which content to render by using the return from `is_keyboard_master()` or `is_keyboard_left()` found in `split_util.h`, e.g:
+
+```C++
+#ifdef OLED_DRIVER_ENABLE
+oled_rotation_t oled_init_user(oled_rotation_t rotation) {
+  if (!is_keyboard_master())
+    return OLED_ROTATION_180;  // flips the display 180 degrees if offhand
+  return rotation;
+}
+
+void oled_task_user(void) {
+  if (is_keyboard_master()) {
+    render_status();     // Renders the current keyboard state (layer, lock, caps, scroll, etc)
+  } else {
+    render_logo();       // Renders a statuc logo
+    oled_scroll_left();  // Turns on scrolling
+  }
+}
+#endif
+```
+
+
+ ## Basic Configuration
+
+|Define                 |Default        |Description                                     |
+|-----------------------|---------------|------------------------------------------------|
+|`OLED_DISPLAY_ADDRESS` |`0x3C`         |The i2c address of the OLED Display             |
+|`OLED_FONT_H`          |`"glcdfont.c"` |The font code file to use for custom fonts      |
+|`OLED_FONT_START`      |`0`            |The starting characer index for custom fonts    |
+|`OLED_FONT_END`        |`224`          |The ending characer index for custom fonts      |
+|`OLED_FONT_WIDTH`      |`6`            |The font width                                  |
+|`OLED_FONT_HEIGHT`     |`8`            |The font height (untested)                      |
+|`OLED_DISABLE_TIMEOUT` |*Not defined*  |Disables the built in OLED timeout feature. Useful when implementing custom timeout rules.|
+
+
+
+ ## 128x64 & Custom sized OLED Displays
+
+ The default display size for this feature is 128x32 and all necessary defines are precalculated with that in mind. We have added a define, `OLED_DISPLAY_128X64`, to switch all the values to be used in a 128x64 display, as well as added a custom define, `OLED_DISPLAY_CUSTOM`, that allows you to provide the necessary values to the driver.
+
+|Define                 |Default        |Description                                                      |
+|-----------------------|---------------|-----------------------------------------------------------------|
+|`OLED_DISPLAY_128X64`  |*Not defined*  |Changes the display defines for use with 128x64 displays.        |
+|`OLED_DISPLAY_CUSTOM`  |*Not defined*  |Changes the display defines for use with custom displays.<br />Requires user to implement the below defines. |
+|`OLED_DISPLAY_WIDTH`   |`128`          |The width of the OLED display.                                   |
+|`OLED_DISPLAY_HEIGHT`  |`32`           |The height of the OLED display.                                  |
+|`OLED_MATRIX_SIZE`     |`512`          |The local buffer size to allocate.<br />`(OLED_DISPLAY_HEIGHT / 8 * OLED_DISPLAY_WIDTH)`|
+|`OLED_BLOCK_TYPE`      |`uint16_t`     |The unsigned integer type to use for dirty rendering.|
+|`OLED_BLOCK_COUNT`     |`16`           |The number of blocks the display is divided into for dirty rendering.<br />`(sizeof(OLED_BLOCK_TYPE) * 8)`|
+|`OLED_BLOCK_SIZE`      |`32`           |The size of each block for dirty rendering<br />`(OLED_MATRIX_SIZE / OLED_BLOCK_COUNT)`|
+|`OLED_SOURCE_MAP`      |`{ 0, ... N }` |Precalculated source array to use for mapping source buffer to target OLED memory in 90 degree rendering.         |
+|`OLED_TARGET_MAP`      |`{ 24, ... N }`|Precalculated target array to use for mapping source buffer to target OLED memory in 90 degree rendering.         |
+
+
+### 90 Degree Rotation - Technical Mumbo Jumbo 
+
+```C
+// OLED Rotation enum values are flags
+typedef enum {
+    OLED_ROTATION_0   = 0,
+    OLED_ROTATION_90  = 1,
+    OLED_ROTATION_180 = 2,
+    OLED_ROTATION_270 = 3, // OLED_ROTATION_90 | OLED_ROTATION_180
+} oled_rotation_t;
+```
+
+ OLED displays driven by SSD1306 drivers only natively support in hard ware 0 degree and 180 degree rendering. This feature is done in software and not free. Using this feature will increase the time to calculate what data to send over i2c to the OLED. If you are strapped for cycles, this can cause keycodes to not register. In testing however, the rendering time on an `atmega32u4` board only went from 2ms to 5ms and keycodes not registering was only noticed once we hit 15ms. 
+ 
+ 90 Degree Rotated Rendering is achieved by using bitwise operations to rotate each 8 block of memory and uses two precalculated arrays to remap buffer memory to OLED memory. The memory map defines are precalculated for remap performance and are calculated based on the OLED Height, Width, and Block Size. For example, in the 128x32 implementation with a `uint8_t` block type, we have a 64 byte block size. This gives us eight 8 byte blocks that need to be rotated and rendered. The OLED renders horizontally two 8 byte blocks before moving down a page, e.g:
+
+|   |   |   |   |   |   |
+|---|---|---|---|---|---|
+| 0 | 1 |   |   |   |   |
+| 2 | 3 |   |   |   |   |
+| 4 | 5 |   |   |   |   |
+| 6 | 7 |   |   |   |   |
+
+However the local buffer is stored as if it was Height x Width display instead of Width x Height, e.g:
+
+|   |   |   |   |   |   |
+|---|---|---|---|---|---|
+| 3 | 7 |   |   |   |   |
+| 2 | 6 |   |   |   |   |
+| 1 | 5 |   |   |   |   |
+| 0 | 4 |   |   |   |   |
+
+So those precalculated arrays just index the memory offsets in the order in which each one iterates its data.
+
+## OLED API
+
+```C++
+// OLED Rotation enum values are flags
+typedef enum {
+    OLED_ROTATION_0   = 0,
+    OLED_ROTATION_90  = 1,
+    OLED_ROTATION_180 = 2,
+    OLED_ROTATION_270 = 3, // OLED_ROTATION_90 | OLED_ROTATION_180
+} oled_rotation_t;
+
+// Initialize the OLED display, rotating the rendered output based on the define passed in.
+// Returns true if the OLED was initialized successfully
+bool oled_init(oled_rotation_t rotation);
+
+// Called at the start of oled_init, weak function overridable by the user
+// rotation - the value passed into oled_init
+// Return new oled_rotation_t if you want to override default rotation
+oled_rotation_t oled_init_user(oled_rotation_t rotation);
+
+// Clears the display buffer, resets cursor position to 0, and sets the buffer to dirty for rendering
+void oled_clear(void);
+
+// Renders the dirty chunks of the buffer to OLED display
+void oled_render(void);
+
+// Moves cursor to character position indicated by column and line, wraps if out of bounds
+// Max column denoted by 'oled_max_chars()' and max lines by 'oled_max_lines()' functions
+void oled_set_cursor(uint8_t col, uint8_t line);
+
+// Advances the cursor to the next page, writing ' ' if true
+// Wraps to the begining when out of bounds
+void oled_advance_page(bool clearPageRemainder);
+
+// Moves the cursor forward 1 character length
+// Advance page if there is not enough room for the next character
+// Wraps to the begining when out of bounds
+void oled_advance_char(void);
+
+// Writes a single character to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+// Main handler that writes character data to the display buffer
+void oled_write_char(const char data, bool invert);
+
+// Writes a string to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+void oled_write(const char *data, bool invert);
+
+// Writes a string to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+// Advances the cursor to the next page, wiring ' ' to the remainder of the current page
+void oled_write_ln(const char *data, bool invert);
+
+// Writes a PROGMEM string to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+// Remapped to call 'void oled_write(const char *data, bool invert);' on ARM
+void oled_write_P(const char *data, bool invert);
+
+// Writes a PROGMEM string to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+// Advances the cursor to the next page, wiring ' ' to the remainder of the current page
+// Remapped to call 'void oled_write_ln(const char *data, bool invert);' on ARM
+void oled_write_ln_P(const char *data, bool invert);
+
+// Can be used to manually turn on the screen if it is off
+// Returns true if the screen was on or turns on
+bool oled_on(void);
+
+// Can be used to manually turn off the screen if it is on
+// Returns true if the screen was off or turns off
+bool oled_off(void);
+
+// Basically it's oled_render, but with timeout management and oled_task_user calling!
+void oled_task(void);
+
+// Called at the start of oled_task, weak function overridable by the user
+void oled_task_user(void);
+
+// Scrolls the entire display right
+// Returns true if the screen was scrolling or starts scrolling
+// NOTE: display contents cannot be changed while scrolling
+bool oled_scroll_right(void);
+
+// Scrolls the entire display left
+// Returns true if the screen was scrolling or starts scrolling
+// NOTE: display contents cannot be changed while scrolling
+bool oled_scroll_left(void);
+
+// Turns off display scrolling
+// Returns true if the screen was not scrolling or stops scrolling
+bool oled_scroll_off(void);
+
+// Returns the maximum number of characters that will fit on a line
+uint8_t oled_max_chars(void);
+
+// Returns the maximum number of lines that will fit on the OLED
+uint8_t oled_max_lines(void);
+```
+
+## SSD1306.h driver conversion guide
+
+|Old API                    |Recommended New API                |
+|---------------------------|-----------------------------------|
+|`struct CharacterMatrix`   |*removed - delete all references*  |
+|`iota_gfx_init`            |`oled_init`                        |
+|`iota_gfx_on`              |`oled_on`                          |
+|`iota_gfx_off`             |`oled_off`                         |
+|`iota_gfx_flush`           |`oled_render`                      |
+|`iota_gfx_write_char`      |`oled_write_char`                  |
+|`iota_gfx_write`           |`oled_write`                       |
+|`iota_gfx_write_P`         |`oled_write_P`                     |
+|`iota_gfx_clear_screen`    |`oled_clear`                       |
+|`matrix_clear`             |*removed - delete all references*  |
+|`matrix_write_char_inner`  |`oled_write_char`                  |
+|`matrix_write_char`        |`oled_write_char`                  |
+|`matrix_write`             |`oled_write`                       |
+|`matrix_write_ln`          |`oled_write_ln`                    |
+|`matrix_write_P`           |`oled_write_P`                     |
+|`matrix_write_ln_P`        |`oled_write_ln_P`                  |
+|`matrix_render`            |`oled_render`                      |
+|`iota_gfx_task`            |`oled_task`                        |
+|`iota_gfx_task_user`       |`oled_task_user`                   |

docs/feature_rgb_matrix.md

@@ -124,30 +124,42 @@ Configure the hardware via your `config.h`:
 
 ---
 
-From this point forward the configuration is the same for all the drivers. 
+From this point forward the configuration is the same for all the drivers. The struct rgb_led array tells the system for each led, what key electrical matrix it represents, what the physical position is on the board, and if the led is for a modifier key or not. Here is a brief example:
 
 ```C
-const rgb_led g_rgb_leds[DRIVER_LED_TOTAL] = {
+rgb_led g_rgb_leds[DRIVER_LED_TOTAL] = {
 /*  {row | col << 4}
     *    |         {x=0..224, y=0..64}
-    *    |            |              modifier
+    *    |            |              flags
     *    |            |                | */
     {{0|(0<<4)},   {20.36*0, 21.33*0}, 1},
-    {{0|(1<<4)},   {20.36*1, 21.33*0}, 1},
+    {{0|(1<<4)},   {20.36*1, 21.33*0}, 4},
     ....
 }
 ```
 
-The format for the matrix position used in this array is `{row | (col << 4)}`. The `x` is between (inclusive) 0-224, and `y` is between (inclusive) 0-64. The easiest way to calculate these positions is:
+The first part, `{row | col << 4}`, tells the system what key this LED represents by using the key's electrical matrix row & col. The second part, `{x=0..224, y=0..64}` represents the LED's physical position on the keyboard. The `x` is between (inclusive) 0-224, and `y` is between (inclusive) 0-64 as the effects are based on this range. The easiest way to calculate these positions is imagine your keyboard is a grid, and the top left of the keyboard represents x, y coordinate 0, 0 and the bottom right of your keyboard represents 224, 64. Using this as a basis, you can use the following formula to calculate the physical position:
 
 ```C
-x = 224 / ( NUMBER_OF_COLS - 1 ) * ROW_POSITION
-y = 64 / (NUMBER_OF_ROWS - 1 ) * COL_POSITION
+x = 224 / (NUMBER_OF_COLS - 1) * COL_POSITION
+y =  64 / (NUMBER_OF_ROWS - 1) * ROW_POSITION
 ```
 
-Where all variables are decimels/floats.
+Where NUMBER_OF_COLS, NUMBER_OF_ROWS, COL_POSITION, & ROW_POSITION are all based on the physical layout of your keyboard, not the electrical layout.
 
-`modifier` is a boolean, whether or not a certain key is considered a modifier (used in some effects).
+`flags` is a bitmask, whether or not a certain LEDs is of a certain type. It is recommended that LEDs are set to only 1 type.
+
+## Flags
+
+|Define                              |Description                                |
+|------------------------------------|-------------------------------------------|
+|`#define HAS_FLAGS(bits, flags)`    |Returns true if `bits` has all `flags` set.|
+|`#define HAS_ANY_FLAGS(bits, flags)`|Returns true if `bits` has any `flags` set.|
+|`#define LED_FLAG_NONE      0x00`   |If thes LED has no flags.                  |
+|`#define LED_FLAG_ALL       0xFF`   |If thes LED has all flags.                 |
+|`#define LED_FLAG_MODIFIER  0x01`   |If the Key for this LED is a modifier.     |
+|`#define LED_FLAG_UNDERGLOW 0x02`   |If the LED is for underglow.               |
+|`#define LED_FLAG_KEYLIGHT  0x04`   |If the LED is for key backlight.           |
 
 ## Keycodes
 
@@ -177,7 +189,7 @@ enum rgb_matrix_effects {
     RGB_MATRIX_GRADIENT_UP_DOWN,    // Static gradient top to bottom, speed controls how much gradient changes
     RGB_MATRIX_BREATHING,           // Single hue brightness cycling animation
     RGB_MATRIX_CYCLE_ALL,           // Full keyboard solid hue cycling through full gradient
-    RGB_MATRIX_CYCLE_LEFT_RIGHT,    // Full gradient scrolling left to right 
+    RGB_MATRIX_CYCLE_LEFT_RIGHT,    // Full gradient scrolling left to right
     RGB_MATRIX_CYCLE_UP_DOWN,       // Full gradient scrolling top to bottom
     RGB_MATRIX_RAINBOW_MOVING_CHEVRON,  // Full gradent Chevron shapped scrolling left to right
     RGB_MATRIX_DUAL_BEACON,         // Full gradient spinning around center of keyboard
@@ -189,6 +201,12 @@ enum rgb_matrix_effects {
 #if defined(RGB_MATRIX_KEYPRESSES) || defined(RGB_MATRIX_KEYRELEASES)
     RGB_MATRIX_SOLID_REACTIVE_SIMPLE,   // Pulses keys hit to hue & value then fades value out
     RGB_MATRIX_SOLID_REACTIVE,      // Static single hue, pulses keys hit to shifted hue then fades to current hue
+    RGB_MATRIX_SOLID_REACTIVE_WIDE       // Hue & value pulse near a single key hit then fades value out
+    RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE  // Hue & value pulse near multiple key hits then fades value out
+    RGB_MATRIX_SOLID_REACTIVE_CROSS      // Hue & value pulse the same column and row of a single key hit then fades value out
+    RGB_MATRIX_SOLID_REACTIVE_MULTICROSS // Hue & value pulse the same column and row of multiple key hits then fades value out
+    RGB_MATRIX_SOLID_REACTIVE_NEXUS      // Hue & value pulse away on the same column and row of a single key hit then fades value out
+    RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS // Hue & value pulse away on the same column and row of multiple key hits then fades value out
     RGB_MATRIX_SPLASH,              // Full gradient & value pulse away from a single key hit then fades value out
     RGB_MATRIX_MULTISPLASH,         // Full gradient & value pulse away from multiple key hits then fades value out
     RGB_MATRIX_SOLID_SPLASH,        // Hue & value pulse away from a single key hit then fades value out
@@ -197,44 +215,122 @@ enum rgb_matrix_effects {
     RGB_MATRIX_EFFECT_MAX
 };
 ```
-    
+
 You can disable a single effect by defining `DISABLE_[EFFECT_NAME]` in your `config.h`:
 
 
-|Define                                             |Description                                 |
-|---------------------------------------------------|--------------------------------------------|
-|`#define DISABLE_RGB_MATRIX_ALPHAS_MODS`           |Disables `RGB_MATRIX_ALPHAS_MODS`           |
-|`#define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN`      |Disables `RGB_MATRIX_GRADIENT_UP_DOWN`      |
-|`#define DISABLE_RGB_MATRIX_BREATHING`             |Disables `RGB_MATRIX_BREATHING`             |
-|`#define DISABLE_RGB_MATRIX_CYCLE_ALL`             |Disables `RGB_MATRIX_CYCLE_ALL`             |
-|`#define DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT`      |Disables `RGB_MATRIX_CYCLE_LEFT_RIGHT`      |
-|`#define DISABLE_RGB_MATRIX_CYCLE_UP_DOWN`         |Disables `RGB_MATRIX_CYCLE_UP_DOWN`         |
-|`#define DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON`|Disables `RGB_MATRIX_RAINBOW_MOVING_CHEVRON`|
-|`#define DISABLE_RGB_MATRIX_DUAL_BEACON`           |Disables `RGB_MATRIX_DUAL_BEACON`           |
-|`#define DISABLE_RGB_MATRIX_RAINBOW_BEACON`        |Disables `RGB_MATRIX_RAINBOW_BEACON`        |
-|`#define DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS`     |Disables `RGB_MATRIX_RAINBOW_PINWHEELS`     |
-|`#define DISABLE_RGB_MATRIX_RAINDROPS`             |Disables `RGB_MATRIX_RAINDROPS`             |
-|`#define DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS`   |Disables `RGB_MATRIX_JELLYBEAN_RAINDROPS`   |
-|`#define DISABLE_RGB_MATRIX_DIGITAL_RAIN`          |Disables `RGB_MATRIX_DIGITAL_RAIN`          |
-|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE`        |Disables `RGB_MATRIX_SOLID_REACTIVE`        |
-|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE` |Disables `RGB_MATRIX_SOLID_REACTIVE_SIMPLEE`|
-|`#define DISABLE_RGB_MATRIX_SPLASH`                |Disables `RGB_MATRIX_SPLASH`                |
-|`#define DISABLE_RGB_MATRIX_MULTISPLASH`           |Disables `RGB_MATRIX_MULTISPLASH`           |
-|`#define DISABLE_RGB_MATRIX_SOLID_SPLASH`          |Disables `RGB_MATRIX_SOLID_SPLASH`          |
-|`#define DISABLE_RGB_MATRIX_SOLID_MULTISPLASH`     |Disables `RGB_MATRIX_SOLID_MULTISPLASH`     |
+|Define                                                 |Description                                    |
+|-------------------------------------------------------|-----------------------------------------------|
+|`#define DISABLE_RGB_MATRIX_ALPHAS_MODS`               |Disables `RGB_MATRIX_ALPHAS_MODS`              |
+|`#define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN`          |Disables `RGB_MATRIX_GRADIENT_UP_DOWN`         |
+|`#define DISABLE_RGB_MATRIX_BREATHING`                 |Disables `RGB_MATRIX_BREATHING`                |
+|`#define DISABLE_RGB_MATRIX_CYCLE_ALL`                 |Disables `RGB_MATRIX_CYCLE_ALL`                |
+|`#define DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT`          |Disables `RGB_MATRIX_CYCLE_LEFT_RIGHT`         |
+|`#define DISABLE_RGB_MATRIX_CYCLE_UP_DOWN`             |Disables `RGB_MATRIX_CYCLE_UP_DOWN`            |
+|`#define DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON`    |Disables `RGB_MATRIX_RAINBOW_MOVING_CHEVRON`   |
+|`#define DISABLE_RGB_MATRIX_DUAL_BEACON`               |Disables `RGB_MATRIX_DUAL_BEACON`              |
+|`#define DISABLE_RGB_MATRIX_RAINBOW_BEACON`            |Disables `RGB_MATRIX_RAINBOW_BEACON`           |
+|`#define DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS`         |Disables `RGB_MATRIX_RAINBOW_PINWHEELS`        |
+|`#define DISABLE_RGB_MATRIX_RAINDROPS`                 |Disables `RGB_MATRIX_RAINDROPS`                |
+|`#define DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS`       |Disables `RGB_MATRIX_JELLYBEAN_RAINDROPS`      |
+|`#define DISABLE_RGB_MATRIX_DIGITAL_RAIN`              |Disables `RGB_MATRIX_DIGITAL_RAIN`             |
+|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE`            |Disables `RGB_MATRIX_SOLID_REACTIVE`           |
+|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE`     |Disables `RGB_MATRIX_SOLID_REACTIVE_SIMPLE`    |
+|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE`       |Disables `RGB_MATRIX_SOLID_REACTIVE_WIDE`      |
+|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE`  |Disables `RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE` |
+|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS`      |Disables `RGB_MATRIX_SOLID_REACTIVE_CROSS`     |
+|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS` |Disables `RGB_MATRIX_SOLID_REACTIVE_MULTICROSS`|
+|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS`      |Disables `RGB_MATRIX_SOLID_REACTIVE_NEXUS`     |
+|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS` |Disables `RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS`|
+|`#define DISABLE_RGB_MATRIX_SPLASH`                    |Disables `RGB_MATRIX_SPLASH`                   |
+|`#define DISABLE_RGB_MATRIX_MULTISPLASH`               |Disables `RGB_MATRIX_MULTISPLASH`              |
+|`#define DISABLE_RGB_MATRIX_SOLID_SPLASH`              |Disables `RGB_MATRIX_SOLID_SPLASH`             |
+|`#define DISABLE_RGB_MATRIX_SOLID_MULTISPLASH`         |Disables `RGB_MATRIX_SOLID_MULTISPLASH`        |
 
 
-## Custom layer effects
+## Custom RGB Matrix Effects
 
-Custom layer effects can be done by defining this in your `<keyboard>.c`:
+By setting `RGB_MATRIX_CUSTOM_USER` (and/or `RGB_MATRIX_CUSTOM_KB`) in `rule.mk`, new effects can be defined directly from userspace, without having to edit any QMK core files.
+
+To declare new effects, create a new `rgb_matrix_user/kb.inc` that looks something like this:
+
+`rgb_matrix_user.inc` should go in the root of the keymap directory.
+`rgb_matrix_kb.inc` should go in the root of the keyboard directory.
 
 ```C
-void rgb_matrix_indicators_kb(void) {
-    rgb_matrix_set_color(index, red, green, blue);
+// !!! DO NOT ADD #pragma once !!! //
+
+// Step 1.
+// Declare custom effects using the RGB_MATRIX_EFFECT macro
+// (note the lack of semicolon after the macro!)
+RGB_MATRIX_EFFECT(my_cool_effect)
+RGB_MATRIX_EFFECT(my_cool_effect2)
+
+// Step 2.
+// Define effects inside the `RGB_MATRIX_CUSTOM_EFFECT_IMPLS` ifdef block
+#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS
+
+// e.g: A simple effect, self-contained within a single method
+static bool my_cool_effect(effect_params_t* params) {
+  RGB_MATRIX_USE_LIMITS(led_min, led_max);
+  for (uint8_t i = led_min; i < led_max; i++) {
+    rgb_matrix_set_color(i, 0xff, 0xff, 0x00);
+  }
+  return led_max < DRIVER_LED_TOTAL;
 }
+
+// e.g: A more complex effect, relying on external methods and state, with
+// dedicated init and run methods
+static uint8_t some_global_state;
+static void my_cool_effect2_complex_init(effect_params_t* params) {
+  some_global_state = 1;
+}
+static bool my_cool_effect2_complex_run(effect_params_t* params) {
+  RGB_MATRIX_USE_LIMITS(led_min, led_max);
+  for (uint8_t i = led_min; i < led_max; i++) {
+    rgb_matrix_set_color(i, 0xff, some_global_state++, 0xff);
+  }
+
+  return led_max < DRIVER_LED_TOTAL;
+}
+static bool my_cool_effect2(effect_params_t* params) {
+  if (params->init) my_cool_effect2_complex_init(params);
+  return my_cool_effect2_complex_run(params);
+}
+
+#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS
 ```
 
-A similar function works in the keymap as `rgb_matrix_indicators_user`.
+For inspiration and examples, check out the built-in effects under `quantum/rgb_matrix_animation/`
+
+
+## Colors
+
+These are shorthands to popular colors. The `RGB` ones can be passed to the `setrgb` functions, while the `HSV` ones to the `sethsv` functions.
+
+|RGB                |HSV                |
+|-------------------|-------------------|
+|`RGB_WHITE`        |`HSV_WHITE`        |
+|`RGB_RED`          |`HSV_RED`          |
+|`RGB_CORAL`        |`HSV_CORAL`        |
+|`RGB_ORANGE`       |`HSV_ORANGE`       |
+|`RGB_GOLDENROD`    |`HSV_GOLDENROD`    |
+|`RGB_GOLD`         |`HSV_GOLD`         |
+|`RGB_YELLOW`       |`HSV_YELLOW`       |
+|`RGB_CHARTREUSE`   |`HSV_CHARTREUSE`   |
+|`RGB_GREEN`        |`HSV_GREEN`        |
+|`RGB_SPRINGGREEN`  |`HSV_SPRINGGREEN`  |
+|`RGB_TURQUOISE`    |`HSV_TURQUOISE`    |
+|`RGB_TEAL`         |`HSV_TEAL`         |
+|`RGB_CYAN`         |`HSV_CYAN`         |
+|`RGB_AZURE`        |`HSV_AZURE`        |
+|`RGB_BLUE`         |`HSV_BLUE`         |
+|`RGB_PURPLE`       |`HSV_PURPLE`       |
+|`RGB_MAGENTA`      |`HSV_MAGENTA`      |
+|`RGB_PINK`         |`HSV_PINK`         |
+
+These are defined in [`rgblight_list.h`](https://github.com/qmk/qmk_firmware/blob/master/quantum/rgblight_list.h). Feel free to add to this list!
+
 
 ## Additional `config.h` Options
 
@@ -253,10 +349,10 @@ A similar function works in the keymap as `rgb_matrix_indicators_user`.
 The EEPROM for it is currently shared with the RGBLIGHT system (it's generally assumed only one RGB would be used at a time), but could be configured to use its own 32bit address with:
 
 ```C
-#define EECONFIG_RGB_MATRIX (uint32_t *)16
+#define EECONFIG_RGB_MATRIX (uint32_t *)28
 ```
 
-Where `16` is an unused index from `eeconfig.h`.
+Where `28` is an unused index from `eeconfig.h`.
 
 ## Suspended state
 

docs/feature_rgblight.md

@@ -75,6 +75,7 @@ Your RGB lighting can be configured by placing these `#define`s in your `config.
 |`RGBLIGHT_VAL_STEP`  |`17`         |The number of steps to increment the brightness by                           |
 |`RGBLIGHT_LIMIT_VAL` |`255`        |The maximum brightness level                                                 |
 |`RGBLIGHT_SLEEP`     |*Not defined*|If defined, the RGB lighting will be switched off when the host goes to sleep|
+|`RGBLIGHT_SPLIT`     |*Not defined*|If defined, synchronization functionality for split keyboards is added|
 
 ## Animations
 
@@ -190,7 +191,40 @@ If you need to change your RGB lighting in code, for example in a macro to chang
 |`rgblight_decrease_val_noeeprom()`          |Decrease the value for all LEDs. This wraps around at minimum value (not written to EEPROM)                                                                   |
 |`rgblight_set_clipping_range(pos, num)`     |Set clipping Range                                                                                                                                            |
 
-Additionally, [`rgblight_list.h`](https://github.com/qmk/qmk_firmware/blob/master/quantum/rgblight_list.h) defines several predefined shortcuts for various colors. Feel free to add to this list!
+## Colors
+
+These are shorthands to popular colors. The `RGB` ones can be passed to the `setrgb` functions, while the `HSV` ones to the `sethsv` functions.
+
+|RGB                |HSV                |
+|-------------------|-------------------|
+|`RGB_WHITE`        |`HSV_WHITE`        |
+|`RGB_RED`          |`HSV_RED`          |
+|`RGB_CORAL`        |`HSV_CORAL`        |
+|`RGB_ORANGE`       |`HSV_ORANGE`       |
+|`RGB_GOLDENROD`    |`HSV_GOLDENROD`    |
+|`RGB_GOLD`         |`HSV_GOLD`         |
+|`RGB_YELLOW`       |`HSV_YELLOW`       |
+|`RGB_CHARTREUSE`   |`HSV_CHARTREUSE`   |
+|`RGB_GREEN`        |`HSV_GREEN`        |
+|`RGB_SPRINGGREEN`  |`HSV_SPRINGGREEN`  |
+|`RGB_TURQUOISE`    |`HSV_TURQUOISE`    |
+|`RGB_TEAL`         |`HSV_TEAL`         |
+|`RGB_CYAN`         |`HSV_CYAN`         |
+|`RGB_AZURE`        |`HSV_AZURE`        |
+|`RGB_BLUE`         |`HSV_BLUE`         |
+|`RGB_PURPLE`       |`HSV_PURPLE`       |
+|`RGB_MAGENTA`      |`HSV_MAGENTA`      |
+|`RGB_PINK`         |`HSV_PINK`         |
+
+```c
+rgblight_setrgb(RGB_ORANGE);
+rgblight_sethsv_noeeprom(HSV_GREEN);
+rgblight_setrgb_at(RGB_GOLD, 3);
+rgblight_sethsv_range(HSV_WHITE, 0, 6);
+```
+
+These are defined in [`rgblight_list.h`](https://github.com/qmk/qmk_firmware/blob/master/quantum/rgblight_list.h). Feel free to add to this list!
+
 
 ## Changing the order of the LEDs
 

docs/feature_space_cadet.md

@@ -0,0 +1,59 @@
+# Space Cadet: The Future, Built In
+
+Steve Losh described the [Space Cadet Shift](http://stevelosh.com/blog/2012/10/a-modern-space-cadet/) quite well. Essentially, when you tap Left Shift on its own, you get an opening parenthesis; tap Right Shift on its own and you get the closing one. When held, the Shift keys function as normal. Yes, it's as cool as it sounds, and now even cooler supporting Control and Alt as well!
+
+## Usage
+
+Firstly, in your keymap, do one of the following:
+- Replace the Left Shift key with `KC_LSPO` (Left Shift, Parenthesis Open), and Right Shift with `KC_RSPC` (Right Shift, Parenthesis Close).
+- Replace the Left Control key with `KC_LCPO` (Left Control, Parenthesis Open), and Right Control with `KC_RCPC` (Right Control, Parenthesis Close).
+- Replace the Left Alt key with `KC_LAPO` (Left Alt, Parenthesis Open), and Right Alt with `KC_RAPC` (Right Alt, Parenthesis Close).
+- Replace any Shift key in your keymap with `KC_SFTENT` (Right Shift, Enter).
+
+## Keycodes
+
+|Keycode    |Description                                |
+|-----------|-------------------------------------------|
+|`KC_LSPO`  |Left Shift when held, `(` when tapped      |
+|`KC_RSPC`  |Right Shift when held, `)` when tapped     |
+|`KC_LCPO`  |Left Control when held, `(` when tapped    |
+|`KC_RCPC`  |Right Control when held, `)` when tapped   |
+|`KC_LAPO`  |Left Alt when held, `(` when tapped        |
+|`KC_RAPC`  |Right Alt when held, `)` when tapped       |
+|`KC_SFTENT`|Right Shift when held, `Enter` when tapped |
+
+## Caveats
+
+Space Cadet's functionality can conflict with the default Command functionality when both Shift keys are held at the same time. See the [Command feature](feature_command.md) for info on how to change it, or make sure that Command is disabled in your `rules.mk` with:
+
+```make
+COMMAND_ENABLE = no
+```
+
+## Configuration
+
+By default Space Cadet assumes a US ANSI layout, but if your layout uses different keys for parentheses, you can redefine them in your `config.h`. In addition, you can redefine the modifier to send on tap, or even send no modifier at all. The new configuration defines bundle all options up into a single define of 3 key codes in this order: the `Modifier` when held or when used with other keys, the `Tap Modifer` sent when tapped (no modifier if `KC_TRNS`), finally the `Keycode` sent when tapped. Now keep in mind, mods from other keys will still apply to the `Keycode` if say `KC_RSFT` is held while tapping `KC_LSPO` key with `KC_TRNS` as the `Tap Modifer`.
+
+|Define          |Default                        |Description                                                                      |
+|----------------|-------------------------------|---------------------------------------------------------------------------------|
+|`LSPO_KEYS`     |`KC_LSFT, LSPO_MOD, LSPO_KEY`  |Send `KC_LSFT` when held, the mod and  key defined by `LSPO_MOD` and `LSPO_KEY`. |
+|`RSPC_KEYS`     |`KC_RSFT, RSPC_MOD, RSPC_KEY`  |Send `KC_RSFT` when held, the mod and  key defined by `RSPC_MOD` and `RSPC_KEY`. |
+|`LCPO_KEYS`     |`KC_LCTL, KC_LCTL, KC_9`       |Send `KC_LCTL` when held, the mod `KC_LCTL` with the key `KC_9` when tapped.     |
+|`RCPO_KEYS`     |`KC_RCTL, KC_RCTL, KC_0`       |Send `KC_RCTL` when held, the mod `KC_RCTL` with the key `KC_0` when tapped.     |
+|`LAPO_KEYS`     |`KC_LALT, KC_LALT, KC_9`       |Send `KC_LALT` when held, the mod `KC_LALT` with the key `KC_9` when tapped.     |
+|`RAPO_KEYS`     |`KC_RALT, KC_RALT, KC_0`       |Send `KC_RALT` when held, the mod `KC_RALT` with the key `KC_0` when tapped.     |
+|`SFTENT_KEYS`   |`KC_RSFT, KC_TRNS, SFTENT_KEY` |Send `KC_RSFT` when held, no mod with the key `SFTENT_KEY` when tapped.          |
+
+
+## Obsolete Configuration
+
+These defines are used in the above defines internally to support backwards compatibility, so you may continue to use them, however the above defines open up a larger range of flexibility than before. As an example, say you want to not send any modifier when you tap just `KC_LSPO`, with the old defines you had an all or nothing choice of using the `DISABLE_SPACE_CADET_MODIFIER` define. Now you can define that key as: `#define KC_LSPO_KEYS KC_LSFT, KC_TRNS, KC_9`. This tells the system to set Left Shift if held or used with other keys, then on tap send no modifier (transparent) with the `KC_9`
+
+|Define                        |Default      |Description                                                       |
+|------------------------------|-------------|------------------------------------------------------------------|
+|`LSPO_KEY`                    |`KC_9`       |The keycode to send when Left Shift is tapped                     |
+|`RSPC_KEY`                    |`KC_0`       |The keycode to send when Right Shift is tapped                    |
+|`LSPO_MOD`                    |`KC_LSFT`    |The modifier to apply to `LSPO_KEY`                               |
+|`RSPC_MOD`                    |`KC_RSFT`    |The modifier to apply to `RSPC_KEY`                               |
+|`SFTENT_KEY`                  |`KC_ENT`     |The keycode to send when the Shift key is tapped                  |
+|`DISABLE_SPACE_CADET_MODIFIER`|*Not defined*|If defined, prevent the Space Cadet from applying a modifier      |

docs/feature_space_cadet_shift.md

@@ -1,37 +0,0 @@
-# Space Cadet Shift: The Future, Built In
-
-Steve Losh described the [Space Cadet Shift](http://stevelosh.com/blog/2012/10/a-modern-space-cadet/) quite well. Essentially, when you tap Left Shift on its own, you get an opening parenthesis; tap Right Shift on its own and you get the closing one. When held, the Shift keys function as normal. Yes, it's as cool as it sounds.
-
-## Usage
-
-Replace the Left Shift key in your keymap with `KC_LSPO` (Left Shift, Parenthesis Open), and Right Shift with `KC_RSPC` (Right Shift, Parenthesis Close).
-
-## Keycodes
-
-|Keycode  |Description                           |
-|---------|--------------------------------------|
-|`KC_LSPO`|Left Shift when held, `(` when tapped |
-|`KC_RSPC`|Right Shift when held, `)` when tapped|
-
-## Caveats
-
-Space Cadet's functionality can conflict with the default Command functionality when both Shift keys are held at the same time. Make sure that Command is disabled in your `rules.mk` with:
-
-```make
-COMMAND_ENABLE = no
-```
-
-## Configuration
-
-By default Space Cadet assumes a US ANSI layout, but if your layout uses different keys for parentheses, you can redefine them in your `config.h`.
-You can also disable the rollover, allowing you to use the opposite Shift key to cancel the Space Cadet state in the event of an erroneous press, instead of emitting a pair of parentheses when the keys are released.
-Also, by default, the Space Cadet applies modifiers LSPO_MOD and RSPC_MOD to keys defined by LSPO_KEY and RSPC_KEY. You can override this behavior by redefining those variables in your `config.h`. You can also prevent the Space Cadet to apply a modifier by defining DISABLE_SPACE_CADET_MODIFIER in your `config.h`.
-
-|Define                        |Default      |Description                                                                     |
-|------------------------------|-------------|--------------------------------------------------------------------------------|
-|`LSPO_KEY`                    |`KC_9`       |The keycode to send when Left Shift is tapped                                   |
-|`RSPC_KEY`                    |`KC_0`       |The keycode to send when Right Shift is tapped                                  |
-|`LSPO_MOD`                    |`KC_LSFT`    |The keycode to send when Left Shift is tapped                                   |
-|`RSPC_MOD`                    |`KC_RSFT`    |The keycode to send when Right Shift is tapped                                  |
-|`DISABLE_SPACE_CADET_ROLLOVER`|*Not defined*|If defined, use the opposite Shift key to cancel Space Cadet                    |
-|`DISABLE_SPACE_CADET_MODIFIER`|*Not defined*|If defined, prevent the Space Cadet to apply a modifier to LSPO_KEY and RSPC_KEY|

docs/feature_space_cadet_shift_enter.md

@@ -1,31 +0,0 @@
-# Space Cadet Shift Enter
-
-Based on the [Space Cadet Shift](feature_space_cadet_shift.md) feature. Tap the Shift key on its own, and it behaves like Enter. When held, the Shift functions as normal.
-
-## Usage
-
-Replace any Shift key in your keymap with `KC_SFTENT` (Shift, Enter), and you're done.
-
-## Keycodes
-
-|Keycode    |Description                             |
-|-----------|----------------------------------------|
-|`KC_SFTENT`|Right Shift when held, Enter when tapped|
-
-## Caveats
-
-As with Space Cadet Shift, this feature may conflict with Command, so it should be disabled in your `rules.mk` with:
-
-```make
-COMMAND_ENABLE = no
-```
-
-This feature also uses the same timers as Space Cadet Shift, so using them in tandem may produce strange results.
-
-## Configuration
-
-By default Space Cadet assumes a US ANSI layout, but if you'd like to use a different key for Enter, you can redefine it in your `config.h`:
-
-|Define      |Default |Description                                     |
-|------------|--------|------------------------------------------------|
-|`SFTENT_KEY`|`KC_ENT`|The keycode to send when the Shift key is tapped|

docs/hand_wire.md

@@ -198,15 +198,17 @@ From here, you should have a working keyboard once you program a firmware. Befor
 
 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:
+The first thing we're going to do is create a new keyboard. In your terminal, run this command, which will ask you some questions and generate a basic keyboard project:
 
 ```
-    util/new_project.sh <project_name>
+./util/new_keyboard.sh
 ```
 
 You'll want to navigate to the `keyboards/<project_name>/` folder by typing, like the print-out from the script specifies:
 
-    cd keyboards/<project_name>
+```
+cd keyboards/<project_name>
+```
 
 ### `config.h`
 
@@ -326,7 +328,7 @@ Carefully flip your keyboard over, open up a new text document, and try typing -
 2. Check the solder joints on the diode - if the diode is loose, part of your row may register, while the other may not.
 3. Check the solder joints on the columns - if your column wiring is loose, part or all of the column may not work.
 4. Check the solder joints on both sides of the wires going to/from the Teensy - the wires need to be fully soldered and connect to both sides.
-5. Check the <project_name>.h file for errors and incorrectly placed `KC_NO`s - if you're unsure where they should be, instead duplicate a k*xy* variable.
+5. Check the `<project_name>.h` file for errors and incorrectly placed `KC_NO`s - if you're unsure where they should be, instead duplicate a k*xy* variable.
 6. Check to make sure you actually compiled the firmware and flashed the Teensy correctly. Unless you got error messages in the terminal, or a pop-up during flashing, you probably did everything correctly.
 
 If you've done all of these things, keep in mind that sometimes you might have had multiple things affecting the keyswitch, so it doesn't hurt to test the keyswitch by shorting it out at the end.
@@ -335,4 +337,4 @@ If you've done all of these things, keep in mind that sometimes you might have h
 
 Now that you have a working board, it's time to get things in their permanent positions. I've often used liberal amounts of hot glue to secure and insulate things, so if that's your style, start spreading that stuff like butter. Otherwise, double-sided tape is always an elegant solution, and electrical tape is a distant second. Due to the nature of these builds, a lot of this part is up to you and how you planned (or didn't plan) things out.
 
-There are a lot of possibilities inside the firmware - explore [docs.qmk.fm](http://docs.qmk.fm) for a full feature list, and dive into the different project (Planck, Clueboard, Ergodox EZ, etc) to see how people use all of them. You can always stop by [the OLKB subreddit for help!](http://reddit.com/r/olkb)
+There are a lot of possibilities inside the firmware - explore [docs.qmk.fm](http://docs.qmk.fm) for a full feature list, and dive into the different keyboards (Planck, Clueboard, Ergodox EZ, etc) to see how people use all of them. You can always stop by [the OLKB subreddit for help!](http://reddit.com/r/olkb)

docs/hardware_avr.md

@@ -6,14 +6,26 @@ If you have not yet you should read the [Keyboard Guidelines](hardware_keyboard_
 
 ## Adding Your AVR Keyboard to QMK
 
-QMK has a number of features to simplify working with AVR keyboards. For most keyboards you don't have to write a single line of code. To get started run the `util/new_project.sh` script:
+QMK has a number of features to simplify working with AVR keyboards. For most keyboards you don't have to write a single line of code. To get started, run the `util/new_keyboard.sh` script:
 
-```bash
-$ util/new_project.sh my_awesome_keyboard
-######################################################
-# /keyboards/my_awesome_keyboard project created. To start
-# working on things, cd into keyboards/my_awesome_keyboard
-######################################################
+```
+$ ./util/new_keyboard.sh
+Generating a new QMK keyboard directory
+
+Keyboard Name: mycoolkb
+Keyboard Type [avr]: 
+Your Name [John Smith]: 
+
+Copying base template files... done
+Copying avr template files... done
+Renaming keyboard files... done
+Replacing %KEYBOARD% with mycoolkb... done
+Replacing %YOUR_NAME% with John Smith... done
+
+Created a new keyboard called mycoolkb.
+
+To start working on things, cd into keyboards/mycoolkb,
+or open the directory in your favourite text editor.
 ```
 
 This will create all the files needed to support your new keyboard, and populate the settings with default values. Now you just need to customize it for your keyboard.

docs/hardware_drivers.md

@@ -14,9 +14,9 @@ QMK is used on a lot of different hardware. While support for the most common MC
 
 Support for addressing pins on the ProMicro by their Arduino name rather than their AVR name. This needs to be better documented, if you are trying to do this and reading the code doesn't help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) and we can help you through the process.
 
-## SSD1306 (AVR Only)
+## SSD1306 OLED Driver
 
-Support for SSD1306 based OLED displays. This needs to be better documented, if you are trying to do this and reading the code doesn't help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) and we can help you through the process.
+Support for SSD1306 based OLED displays. For more information see the [OLED Driver Feature](feature_oled_driver.md) page.
 
 ## uGFX
 
@@ -32,4 +32,4 @@ Support for up to 2 drivers. Each driver impliments 2 charlieplex matrices to in
 
 ## IS31FL3733
 
-Support for up to a single driver with room for expansion. Each driver can control 192 individual LEDs or 64 RGB LEDs. For more information on how to setup the driver see the [RGB Matrix](feature_rgb_matrix.md) page.
+Support for up to a single driver with room for expansion. Each driver can control 192 individual LEDs or 64 RGB LEDs. For more information on how to setup the driver see the [RGB Matrix](feature_rgb_matrix.md) page.

docs/porting_your_keyboard_to_qmk_(arm_and_other_chibios_cpus).md

@@ -1,15 +1,25 @@
-Setting up your ARM based PCB is a little more involved than an Atmel MCU, but is easy enough. Start by using `util/new_project.sh <keyboard>` to create a new project:
+Setting up your ARM based PCB is a little more involved than an Atmel MCU, but is easy enough. Start by running `util/new_keyboard.sh`:
 
 ```
-$ util/new_project.sh simontester
-######################################################
-# /keyboards/simontester project created. To start
-# working on things, cd into keyboards/simontester
-######################################################
+$ ./util/new_keyboard.sh
+Generating a new QMK keyboard directory
+
+Keyboard Name: mycoolkb
+Keyboard Type [avr]: 
+Your Name [John Smith]: 
+
+Copying base template files... done
+Copying avr template files... done
+Renaming keyboard files... done
+Replacing %KEYBOARD% with mycoolkb... done
+Replacing %YOUR_NAME% with John Smith... done
+
+Created a new keyboard called mycoolkb.
+
+To start working on things, cd into keyboards/mycoolkb,
+or open the directory in your favourite text editor.
 ```
 
-
-
 # END OF NEW ARM DOC, OLD ATMEL DOC FOLLOWS
 
 ## `/keyboards/<keyboard>/config.h`

docs/zh-cn/README.md

@@ -0,0 +1,32 @@
+# QMK机械键盘固件
+
+[![当前版本](https://img.shields.io/github/tag/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/tags)
+[![开发状态](https://travis-ci.org/qmk/qmk_firmware.svg?branch=master)](https://travis-ci.org/qmk/qmk_firmware)
+[![异议](https://img.shields.io/discord/440868230475677696.svg)](https://discord.gg/Uq7gcHh)
+[![文档状态](https://img.shields.io/badge/docs-ready-orange.svg)](https://docs.qmk.fm)
+[![GitHub贡献者](https://img.shields.io/github/contributors/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/pulse/monthly)
+[![GitHub分支](https://img.shields.io/github/forks/qmk/qmk_firmware.svg?style=social&label=Fork)](https://github.com/qmk/qmk_firmware/)
+
+## 什么是 QMK 固件?
+
+QMK (*Quantum Mechanical Keyboard*) 是一个社区维护的开源软件，包括 QMK 固件, QMK 工具箱, qmk.fm网站, 和这些文档。QMK 固件是一个基于[tmk\_keyboard](http://github.com/tmk/tmk_keyboard)的键盘固件，它在爱特梅尔AVR微控制器实现一些有用的功能,确切地说, 是在 [OLKB product line](http://olkb.com), 在 [ErgoDox EZ](http://www.ergodox-ez.com) 键盘, 和 [Clueboard product line](http://clueboard.co/). 上。它被移植到使用ChibiOS的ARM芯片上. 它可以在飞线键盘或定制PCB键盘中发挥功能.
+
+## 如何得到它
+
+如果你打算贡献布局, 键盘, 或者其他QMK特性, 一下是最简单的方法：[从Github获得repo分支](https://github.com/qmk/qmk_firmware#fork-destination-box), 并克隆你的repo到本地进行编辑，推送，然后从你的分支打开 [Pull Request](https://github.com/qmk/qmk_firmware/pulls).
+
+此外, 你也可以直接下载 ([zip](https://github.com/qmk/qmk_firmware/zipball/master), [tar](https://github.com/qmk/qmk_firmware/tarball/master)), 或者从git克隆 (`git@github.com:qmk/qmk_firmware.git`), 或 https (`https://github.com/qmk/qmk_firmware.git`).
+
+## 如何编译
+
+在你能编译之前, 你需要[部署环境](getting_started_build_tools.md) 用于 AVR or/and ARM 开发。完成后, 你可以使用 `make` 命令来编译一个键盘和布局使用以下命令:
+
+    make planck/rev4:default
+
+这将建立 `planck`的`rev4` 修订版本并使用 `default`布局。并非所有键盘都有修订版本 (也叫做子项目或文件夹)，在此情况下，修订版本可以省略，如下:
+
+    make preonic:default
+
+## 如何定制
+
+QMK 有许多 [特性](features.md)来探索，也有很多 [参考文档](http://docs.qmk.fm) 供您发掘。你可以通过修改 [布局](keymap.md)和[键码](keycodes.md)来利用许多特性。

docs/zh-cn/_summary.md

@@ -0,0 +1,106 @@
+* [完全菜鸟指南](newbs.md)
+  * [入门](newbs_getting_started.md)
+  * [构建你的第一个固件](newbs_building_firmware.md)
+  * [刷新固件](newbs_flashing.md)
+  * [测试和调试](newbs_testing_debugging.md)
+  * [Git最佳实践](newbs_best_practices.md)
+  * [学习资源](newbs_learn_more_resources.md)
+
+* [QMK基础](README.md)
+  * [QMK 简介](getting_started_introduction.md)
+  * [贡献 QMK](contributing.md)
+  * [如何使用Github](getting_started_github.md)
+  * [获得帮助](getting_started_getting_help.md)
+
+* [问题解答](faq.md)
+  * [一般问题](faq_general.md)
+  * [构建/编译QMK](faq_build.md)
+  * [调试/故障排除 QMK](faq_debug.md)
+  * [键盘布局](faq_keymap.md)
+
+* 详细指南
+  * [安装构建工具](getting_started_build_tools.md)
+  * [流浪者指南](getting_started_vagrant.md)
+  * [构建/编译指令](getting_started_make_guide.md)
+  * [刷新固件](flashing.md)
+  * [定制功能](custom_quantum_functions.md)
+  * [布局概述](keymap.md)
+
+* [硬件](hardware.md)
+  * [AVR 处理器](hardware_avr.md)
+  * [驱动](hardware_drivers.md)
+
+* 参考
+  * [键盘指南](hardware_keyboard_guidelines.md)
+  * [配置选项](config_options.md)
+  * [键码](keycodes.md)
+  * [记录最佳实践](documentation_best_practices.md)
+  * [文档指南](documentation_templates.md)
+  * [词汇表](reference_glossary.md)
+  * [单元测试](unit_testing.md)
+  * [有用的功能](ref_functions.md)
+  * [配置器支持](reference_configurator_support.md)
+  * [info.json 格式](reference_info_json.md)
+
+* [特性](features.md)
+  * [基本键码](keycodes_basic.md)
+  * [US ANSI 控制键](keycodes_us_ansi_shifted.md)
+  * [量子键码](quantum_keycodes.md)
+  * [高级键码](feature_advanced_keycodes.md)
+  * [音频](feature_audio.md)
+  * [自动控制](feature_auto_shift.md)
+  * [背光](feature_backlight.md)
+  * [蓝牙](feature_bluetooth.md)
+  * [Bootmagic](feature_bootmagic.md)
+  * [组合](feature_combo)
+  * [命令](feature_command.md)
+  * [动态宏指令](feature_dynamic_macros.md)
+  * [编码器](feature_encoders.md)
+  * [Grave Escape](feature_grave_esc.md)
+  * [键锁](feature_key_lock.md)
+  * [层](feature_layouts.md)
+  * [引导键](feature_leader_key.md)
+  * [LED 阵列](feature_led_matrix.md)
+  * [宏指令](feature_macros.md)
+  * [鼠标键](feature_mouse_keys.md)
+  * [一键功能](feature_advanced_keycodes.md#one-shot-keys)
+  * [指针设备](feature_pointing_device.md)
+  * [PS/2 鼠标](feature_ps2_mouse.md)
+  * [RGB 光](feature_rgblight.md)
+  * [RGB 矩阵](feature_rgb_matrix.md)
+  * [空格候补换挡](feature_space_cadet_shift.md)
+  * [空格候补换挡回车](feature_space_cadet_shift_enter.md)
+  * [速录机](feature_stenography.md)
+  * [换手](feature_swap_hands.md)
+  * [踢踏舞](feature_tap_dance.md)
+  * [终端](feature_terminal.md)
+  * [热敏打印机](feature_thermal_printer.md)
+  * [Unicode](feature_unicode.md)
+  * [用户空间](feature_userspace.md)
+  * [速度键](feature_velocikey.md)
+
+* 针对制造者和定制者
+  * [飞线指南](hand_wire.md)
+  * [ISP 刷新指南](isp_flashing_guide.md)
+  * [ARM 调试指南](arm_debugging.md)
+  * [I2C 驱动](i2c_driver.md)
+  * [GPIO 控制器](internals_gpio_control.md)
+  * [Proton C 转换](proton_c_conversion.md)
+
+* 深入了解
+  * [键盘如何工作](how_keyboards_work.md)
+  * [理解 QMK](understanding_qmk.md)
+
+* 其他话题
+  * [使用Eclipse开发QMK](other_eclipse.md)
+  * [使用VSCode开发QMK](other_vscode.md)
+  * [支持](support.md)
+
+* QMK 内构 (正在编写)
+  * [定义](internals_defines.md)
+  * [输入回调寄存器](internals_input_callback_reg.md)
+  * [Midi 设备](internals_midi_device.md)
+  * [Midi 设备设置过程](internals_midi_device_setup_process.md)
+  * [Midi 工具库](internals_midi_util.md)
+  * [发送函数](internals_send_functions.md)
+  * [Sysex 工具](internals_sysex_tools.md)

drivers/arm/i2c_master.c

@@ -42,6 +42,18 @@ static const I2CConfig i2cconfig = {
   0
 };
 
+static i2c_status_t chibios_to_qmk(const msg_t* status) {
+  switch (*status) {
+    case I2C_NO_ERROR:
+      return I2C_STATUS_SUCCESS;
+    case I2C_TIMEOUT:
+      return I2C_STATUS_TIMEOUT;
+    // I2C_BUS_ERROR, I2C_ARBITRATION_LOST, I2C_ACK_FAILURE, I2C_OVERRUN, I2C_PEC_ERROR, I2C_SMB_ALERT
+    default:
+      return I2C_STATUS_ERROR;
+  }
+}
+
 __attribute__ ((weak))
 void i2c_init(void)
 {
@@ -57,29 +69,30 @@ void i2c_init(void)
   //i2cInit(); //This is invoked by halInit() so no need to redo it.
 }
 
-// This is usually not needed
-uint8_t i2c_start(uint8_t address)
+i2c_status_t i2c_start(uint8_t address)
 {
   i2c_address = address;
   i2cStart(&I2C_DRIVER, &i2cconfig);
-  return 0;
+  return I2C_STATUS_SUCCESS;
 }
 
-uint8_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout)
+i2c_status_t i2c_transmit(uint8_t address, const uint8_t* data, uint16_t length, uint16_t timeout)
 {
   i2c_address = address;
   i2cStart(&I2C_DRIVER, &i2cconfig);
-  return i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), data, length, 0, 0, MS2ST(timeout));
+  msg_t status = i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), data, length, 0, 0, MS2ST(timeout));
+  return chibios_to_qmk(&status);
 }
 
-uint8_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_address = address;
   i2cStart(&I2C_DRIVER, &i2cconfig);
-  return i2cMasterReceiveTimeout(&I2C_DRIVER, (i2c_address >> 1), data, length, MS2ST(timeout));
+  msg_t status = i2cMasterReceiveTimeout(&I2C_DRIVER, (i2c_address >> 1), data, length, MS2ST(timeout));
+  return chibios_to_qmk(&status);
 }
 
-uint8_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, const uint8_t* data, uint16_t length, uint16_t timeout)
 {
   i2c_address = devaddr;
   i2cStart(&I2C_DRIVER, &i2cconfig);
@@ -91,18 +104,19 @@ uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t l
   }
   complete_packet[0] = regaddr;
 
-  return i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), complete_packet, length + 1, 0, 0, MS2ST(timeout));
+  msg_t status = i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), complete_packet, length + 1, 0, 0, MS2ST(timeout));
+  return chibios_to_qmk(&status);
 }
 
-uint8_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_address = devaddr;
   i2cStart(&I2C_DRIVER, &i2cconfig);
-  return i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), regaddr, 1, data, length, MS2ST(timeout));
+  msg_t status = i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), regaddr, 1, data, length, MS2ST(timeout));
+  return chibios_to_qmk(&status);
 }
 
-uint8_t i2c_stop(void)
+void i2c_stop(void)
 {
   i2cStop(&I2C_DRIVER);
-  return 0;
 }

drivers/arm/i2c_master.h

@@ -40,11 +40,17 @@
   #define I2C_DRIVER I2CD1
 #endif
 
+typedef int16_t i2c_status_t;
+
+#define I2C_STATUS_SUCCESS (0)
+#define I2C_STATUS_ERROR   (-1)
+#define I2C_STATUS_TIMEOUT (-2)
+
 void i2c_init(void);
-uint8_t i2c_start(uint8_t address);
-uint8_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);
-uint8_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);
-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(void);
+i2c_status_t i2c_start(uint8_t address);
+i2c_status_t i2c_transmit(uint8_t address, const 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 i2c_transmit_receive(uint8_t address, uint8_t * tx_body, uint16_t tx_length, uint8_t * rx_body, uint16_t rx_length);
+i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, const 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);
+void i2c_stop(void);

drivers/avr/i2c_master.c

@@ -121,7 +121,7 @@ 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, const uint8_t* data, uint16_t length, uint16_t timeout) {
   i2c_status_t status = i2c_start(address | I2C_WRITE, timeout);
 
   for (uint16_t i = 0; i < length && status >= 0; i++) {
@@ -155,7 +155,7 @@ i2c_status_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16
   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, const uint8_t* data, uint16_t length, uint16_t timeout) {
   i2c_status_t status = i2c_start(devaddr | 0x00, timeout);
   if (status >= 0) {
     status = i2c_write(regaddr, timeout);

drivers/avr/i2c_master.h

@@ -22,10 +22,10 @@ i2c_status_t i2c_start(uint8_t address, uint16_t timeout);
 i2c_status_t i2c_write(uint8_t data, uint16_t timeout);
 int16_t i2c_read_ack(uint16_t timeout);
 int16_t i2c_read_nack(uint16_t timeout);
-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, const 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 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, const 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);
 void i2c_stop(void);
 
-#endif // I2C_MASTER_H
+#endif // I2C_MASTER_H

drivers/avr/ws2812.c

@@ -158,7 +158,7 @@ void inline ws2812_setled(int i, uint8_t r, uint8_t g, uint8_t b)
 
 void ws2812_setled_all  (uint8_t r, uint8_t g, uint8_t b)
 {
-  for (int i = 0; i < RGBLED_NUM; i++) {
+  for (int i = 0; i < sizeof(led)/sizeof(led[0]); i++) {
     led[i].r = r;
     led[i].g = g;
     led[i].b = b;

drivers/oled/glcdfont.c

@@ -0,0 +1,240 @@
+#pragma once
+
+#ifdef __AVR__
+ #include <avr/io.h>
+ #include <avr/pgmspace.h>
+#elif defined(ESP8266)
+ #include <pgmspace.h>
+#else
+ #define PROGMEM
+#endif
+
+// Helidox 8x6 font with QMK Firmware Logo
+// Online editor: http://teripom.x0.com/
+
+static const unsigned char font[] PROGMEM = {
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x3E, 0x5B, 0x4F, 0x5B, 0x3E, 0x00,
+  0x3E, 0x6B, 0x4F, 0x6B, 0x3E, 0x00,
+  0x1C, 0x3E, 0x7C, 0x3E, 0x1C, 0x00,
+  0x18, 0x3C, 0x7E, 0x3C, 0x18, 0x00,
+  0x1C, 0x57, 0x7D, 0x57, 0x1C, 0x00,
+  0x1C, 0x5E, 0x7F, 0x5E, 0x1C, 0x00,
+  0x00, 0x18, 0x3C, 0x18, 0x00, 0x00,
+  0xFF, 0xE7, 0xC3, 0xE7, 0xFF, 0x00,
+  0x00, 0x18, 0x24, 0x18, 0x00, 0x00,
+  0xFF, 0xE7, 0xDB, 0xE7, 0xFF, 0x00,
+  0x30, 0x48, 0x3A, 0x06, 0x0E, 0x00,
+  0x26, 0x29, 0x79, 0x29, 0x26, 0x00,
+  0x40, 0x7F, 0x05, 0x05, 0x07, 0x00,
+  0x40, 0x7F, 0x05, 0x25, 0x3F, 0x00,
+  0x5A, 0x3C, 0xE7, 0x3C, 0x5A, 0x00,
+  0x7F, 0x3E, 0x1C, 0x1C, 0x08, 0x00,
+  0x08, 0x1C, 0x1C, 0x3E, 0x7F, 0x00,
+  0x14, 0x22, 0x7F, 0x22, 0x14, 0x00,
+  0x5F, 0x5F, 0x00, 0x5F, 0x5F, 0x00,
+  0x06, 0x09, 0x7F, 0x01, 0x7F, 0x00,
+  0x00, 0x66, 0x89, 0x95, 0x6A, 0x00,
+  0x60, 0x60, 0x60, 0x60, 0x60, 0x00,
+  0x94, 0xA2, 0xFF, 0xA2, 0x94, 0x00,
+  0x08, 0x04, 0x7E, 0x04, 0x08, 0x00,
+  0x10, 0x20, 0x7E, 0x20, 0x10, 0x00,
+  0x08, 0x08, 0x2A, 0x1C, 0x08, 0x00,
+  0x08, 0x1C, 0x2A, 0x08, 0x08, 0x00,
+  0x1E, 0x10, 0x10, 0x10, 0x10, 0x00,
+  0x0C, 0x1E, 0x0C, 0x1E, 0x0C, 0x00,
+  0x30, 0x38, 0x3E, 0x38, 0x30, 0x00,
+  0x06, 0x0E, 0x3E, 0x0E, 0x06, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x5F, 0x00, 0x00, 0x00,
+  0x00, 0x07, 0x00, 0x07, 0x00, 0x00,
+  0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00,
+  0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x00,
+  0x23, 0x13, 0x08, 0x64, 0x62, 0x00,
+  0x36, 0x49, 0x56, 0x20, 0x50, 0x00,
+  0x00, 0x08, 0x07, 0x03, 0x00, 0x00,
+  0x00, 0x1C, 0x22, 0x41, 0x00, 0x00,
+  0x00, 0x41, 0x22, 0x1C, 0x00, 0x00,
+  0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 0x00,
+  0x08, 0x08, 0x3E, 0x08, 0x08, 0x00,
+  0x00, 0x80, 0x70, 0x30, 0x00, 0x00,
+  0x08, 0x08, 0x08, 0x08, 0x08, 0x00,
+  0x00, 0x00, 0x60, 0x60, 0x00, 0x00,
+  0x20, 0x10, 0x08, 0x04, 0x02, 0x00,
+  0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00,
+  0x00, 0x42, 0x7F, 0x40, 0x00, 0x00,
+  0x72, 0x49, 0x49, 0x49, 0x46, 0x00,
+  0x21, 0x41, 0x49, 0x4D, 0x33, 0x00,
+  0x18, 0x14, 0x12, 0x7F, 0x10, 0x00,
+  0x27, 0x45, 0x45, 0x45, 0x39, 0x00,
+  0x3C, 0x4A, 0x49, 0x49, 0x31, 0x00,
+  0x41, 0x21, 0x11, 0x09, 0x07, 0x00,
+  0x36, 0x49, 0x49, 0x49, 0x36, 0x00,
+  0x46, 0x49, 0x49, 0x29, 0x1E, 0x00,
+  0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+  0x00, 0x40, 0x34, 0x00, 0x00, 0x00,
+  0x00, 0x08, 0x14, 0x22, 0x41, 0x00,
+  0x14, 0x14, 0x14, 0x14, 0x14, 0x00,
+  0x00, 0x41, 0x22, 0x14, 0x08, 0x00,
+  0x02, 0x01, 0x59, 0x09, 0x06, 0x00,
+  0x3E, 0x41, 0x5D, 0x59, 0x4E, 0x00,
+  0x7C, 0x12, 0x11, 0x12, 0x7C, 0x00,
+  0x7F, 0x49, 0x49, 0x49, 0x36, 0x00,
+  0x3E, 0x41, 0x41, 0x41, 0x22, 0x00,
+  0x7F, 0x41, 0x41, 0x41, 0x3E, 0x00,
+  0x7F, 0x49, 0x49, 0x49, 0x41, 0x00,
+  0x7F, 0x09, 0x09, 0x09, 0x01, 0x00,
+  0x3E, 0x41, 0x41, 0x51, 0x73, 0x00,
+  0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00,
+  0x00, 0x41, 0x7F, 0x41, 0x00, 0x00,
+  0x20, 0x40, 0x41, 0x3F, 0x01, 0x00,
+  0x7F, 0x08, 0x14, 0x22, 0x41, 0x00,
+  0x7F, 0x40, 0x40, 0x40, 0x40, 0x00,
+  0x7F, 0x02, 0x1C, 0x02, 0x7F, 0x00,
+  0x7F, 0x04, 0x08, 0x10, 0x7F, 0x00,
+  0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00,
+  0x7F, 0x09, 0x09, 0x09, 0x06, 0x00,
+  0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00,
+  0x7F, 0x09, 0x19, 0x29, 0x46, 0x00,
+  0x26, 0x49, 0x49, 0x49, 0x32, 0x00,
+  0x03, 0x01, 0x7F, 0x01, 0x03, 0x00,
+  0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00,
+  0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00,
+  0x3F, 0x40, 0x38, 0x40, 0x3F, 0x00,
+  0x63, 0x14, 0x08, 0x14, 0x63, 0x00,
+  0x03, 0x04, 0x78, 0x04, 0x03, 0x00,
+  0x61, 0x59, 0x49, 0x4D, 0x43, 0x00,
+  0x00, 0x7F, 0x41, 0x41, 0x41, 0x00,
+  0x02, 0x04, 0x08, 0x10, 0x20, 0x00,
+  0x00, 0x41, 0x41, 0x41, 0x7F, 0x00,
+  0x04, 0x02, 0x01, 0x02, 0x04, 0x00,
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x00,
+  0x00, 0x03, 0x07, 0x08, 0x00, 0x00,
+  0x20, 0x54, 0x54, 0x78, 0x40, 0x00,
+  0x7F, 0x28, 0x44, 0x44, 0x38, 0x00,
+  0x38, 0x44, 0x44, 0x44, 0x28, 0x00,
+  0x38, 0x44, 0x44, 0x28, 0x7F, 0x00,
+  0x38, 0x54, 0x54, 0x54, 0x18, 0x00,
+  0x00, 0x08, 0x7E, 0x09, 0x02, 0x00,
+  0x18, 0xA4, 0xA4, 0x9C, 0x78, 0x00,
+  0x7F, 0x08, 0x04, 0x04, 0x78, 0x00,
+  0x00, 0x44, 0x7D, 0x40, 0x00, 0x00,
+  0x20, 0x40, 0x40, 0x3D, 0x00, 0x00,
+  0x7F, 0x10, 0x28, 0x44, 0x00, 0x00,
+  0x00, 0x41, 0x7F, 0x40, 0x00, 0x00,
+  0x7C, 0x04, 0x78, 0x04, 0x78, 0x00,
+  0x7C, 0x08, 0x04, 0x04, 0x78, 0x00,
+  0x38, 0x44, 0x44, 0x44, 0x38, 0x00,
+  0xFC, 0x18, 0x24, 0x24, 0x18, 0x00,
+  0x18, 0x24, 0x24, 0x18, 0xFC, 0x00,
+  0x7C, 0x08, 0x04, 0x04, 0x08, 0x00,
+  0x48, 0x54, 0x54, 0x54, 0x24, 0x00,
+  0x04, 0x04, 0x3F, 0x44, 0x24, 0x00,
+  0x3C, 0x40, 0x40, 0x20, 0x7C, 0x00,
+  0x1C, 0x20, 0x40, 0x20, 0x1C, 0x00,
+  0x3C, 0x40, 0x30, 0x40, 0x3C, 0x00,
+  0x44, 0x28, 0x10, 0x28, 0x44, 0x00,
+  0x4C, 0x90, 0x90, 0x90, 0x7C, 0x00,
+  0x44, 0x64, 0x54, 0x4C, 0x44, 0x00,
+  0x00, 0x08, 0x36, 0x41, 0x00, 0x00,
+  0x00, 0x00, 0x77, 0x00, 0x00, 0x00,
+  0x00, 0x41, 0x36, 0x08, 0x00, 0x00,
+  0x02, 0x01, 0x02, 0x04, 0x02, 0x00,
+  0x3C, 0x26, 0x23, 0x26, 0x3C, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x40, 0x40, 0x40, 0xF0, 0xF8, 0xF8,
+  0xFF, 0x38, 0xFF, 0xF8, 0xF8, 0x3F,
+  0xF8, 0xF8, 0xFF, 0x38, 0xFF, 0xF8,
+  0xF8, 0xF0, 0x40, 0x40, 0x40, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+  0xC0, 0xC0, 0xC0, 0x80, 0x00, 0x00,
+  0xC0, 0xC0, 0x80, 0x00, 0x00, 0x00,
+  0x80, 0xC0, 0xC0, 0x00, 0xC0, 0xC0,
+  0x00, 0x00, 0x80, 0xC0, 0xC0, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0,
+  0xC0, 0xC0, 0xC0, 0x00, 0xC0, 0xC0,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xC0, 0xF0, 0xF8, 0xFC, 0x3E,
+  0x1E, 0x06, 0x01, 0x00, 0x00, 0x00,
+  0x7F, 0x41, 0x41, 0x41, 0x7F, 0x00,
+  0x7F, 0x41, 0x41, 0x41, 0x7F, 0x00,
+  0x00, 0x80, 0xC0, 0xE0, 0x7E, 0x5B,
+  0x4F, 0x5B, 0xFE, 0xC0, 0x00, 0x00,
+  0xC0, 0x00, 0xDC, 0xD7, 0xDE, 0xDE,
+  0xDE, 0xD7, 0xDC, 0x00, 0xC0, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x49, 0x49, 0x49, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xE0, 0xDF, 0xBF, 0xBF, 0x00,
+  0xBF, 0xBF, 0xDF, 0xE0, 0xFF, 0xFF,
+  0xFF, 0xFF, 0x49, 0x49, 0x49, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x1F, 0x3F,
+  0x60, 0x60, 0xE0, 0xBF, 0x1F, 0x00,
+  0x7F, 0x7F, 0x07, 0x1E, 0x38, 0x1E,
+  0x07, 0x7F, 0x7F, 0x00, 0x7F, 0x7F,
+  0x0E, 0x1F, 0x3B, 0x71, 0x60, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x7F, 0x7F,
+  0x0C, 0x0C, 0x0C, 0x00, 0x7E, 0x7E,
+  0x00, 0x7F, 0x7E, 0x03, 0x03, 0x00,
+  0x7F, 0x7E, 0x03, 0x03, 0x7E, 0x7E,
+  0x03, 0x03, 0x7F, 0x7E, 0x00, 0x0F,
+  0x3E, 0x70, 0x3C, 0x06, 0x3C, 0x70,
+  0x3E, 0x0F, 0x00, 0x32, 0x7B, 0x49,
+  0x49, 0x3F, 0x7E, 0x00, 0x7F, 0x7E,
+  0x03, 0x03, 0x00, 0x1E, 0x3F, 0x69,
+  0x69, 0x6F, 0x26, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x03, 0x0F, 0x1F, 0x3F, 0x3C,
+  0x78, 0x70, 0x60, 0x00, 0x00, 0x00,
+  0x7F, 0x41, 0x41, 0x41, 0x7F, 0x00,
+  0x7F, 0x41, 0x41, 0x41, 0x7F, 0x00,
+  0x30, 0x7B, 0x7F, 0x78, 0x30, 0x20,
+  0x20, 0x30, 0x78, 0x7F, 0x3B, 0x00,
+  0x03, 0x00, 0x0F, 0x7F, 0x0F, 0x0F,
+  0x0F, 0x7F, 0x0F, 0x00, 0x03, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x01, 0x01, 0x07, 0x0F, 0x0F,
+  0x7F, 0x0F, 0x7F, 0x0F, 0x0F, 0x7E,
+  0x0F, 0x0F, 0x7F, 0x0F, 0x7F, 0x0F,
+  0x0F, 0x07, 0x01, 0x01, 0x01, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x01, 0x01, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};

drivers/oled/licenses.txt

@@ -0,0 +1,45 @@
+The Android robot is reproduced or modified from work created and shared by Google and used according to terms described in the Creative Commons 3.0 Attribution License.
+
+
+This is the Linux-penguin again...
+
+Originally drewn by Larry Ewing (http://www.isc.tamu.edu/~lewing/)
+(with the GIMP) the Linux Logo has been vectorized by me (Simon Budig,
+http://www.home.unix-ag.org/simon/).
+
+This happened quite some time ago with Corel Draw 4. But luckily
+meanwhile there are tools available to handle vector graphics with
+Linux. Bernhard Herzog (bernhard@users.sourceforge.net) deserves kudos
+for creating Sketch (http://sketch.sourceforge.net), a powerful free
+tool for creating vector graphics. He converted the Corel Draw file to
+the Sketch native format. Since I am unable to maintain the Corel Draw
+file any longer, the Sketch version now is the "official" one.
+
+Anja Gerwinski (anja@gerwinski.de) has created an alternate version of
+the penguin (penguin-variant.sk) with a thinner mouth line and slightly
+altered gradients. It also features a nifty drop shadow.
+
+The third bird (penguin-flat.sk) is a version reduced to three colors
+(black/white/yellow) for e.g. silk screen printing. I made this version
+for a mug, available at the friendly folks at
+http://www.kernelconcepts.de/ - they do good stuff, mail Petra
+(pinguin@kernelconcepts.de) if you need something special or don't
+understand the german  :-)
+
+These drawings are copyrighted by Larry Ewing and Simon Budig
+(penguin-variant.sk also by Anja Gerwinski), redistribution is free but
+has to include this README/Copyright notice.
+
+The use of these drawings is free. However I am happy about a sample of
+your mug/t-shirt/whatever with this penguin on it...
+
+Have fun
+    Simon Budig
+
+
+Simon.Budig@unix-ag.org
+http://www.home.unix-ag.org/simon/
+
+Simon Budig
+Am Hardtkoeppel 2
+D-61279 Graevenwiesbach

drivers/oled/oled_driver.c

@@ -0,0 +1,531 @@
+/*
+Copyright 2019 Ryan Caltabiano <https://github.com/XScorpion2>
+
+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 "i2c_master.h"
+#include "oled_driver.h"
+#include OLED_FONT_H
+#include "timer.h"
+#include "print.h"
+
+#include <string.h>
+
+#if defined(__AVR__)
+  #include <avr/io.h>
+  #include <avr/pgmspace.h>
+#elif defined(ESP8266)
+  #include <pgmspace.h>
+#else // defined(ESP8266)
+  #define PROGMEM
+  #define memcpy_P(des, src, len) memcpy(des, src, len)
+#endif // defined(__AVR__)
+
+// Used commands from spec sheet: https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf
+// Fundamental Commands
+#define CONTRAST                0x81
+#define DISPLAY_ALL_ON          0xA5
+#define DISPLAY_ALL_ON_RESUME   0xA4
+#define NORMAL_DISPLAY          0xA6
+#define DISPLAY_ON              0xAF
+#define DISPLAY_OFF             0xAE
+
+// Scrolling Commands
+#define ACTIVATE_SCROLL         0x2F
+#define DEACTIVATE_SCROLL       0x2E
+#define SCROLL_RIGHT            0x26
+#define SCROLL_LEFT             0x27
+#define SCROLL_RIGHT_UP         0x29
+#define SCROLL_LEFT_UP          0x2A
+
+// Addressing Setting Commands
+#define MEMORY_MODE             0x20
+#define COLUMN_ADDR             0x21
+#define PAGE_ADDR               0x22
+
+// Hardware Configuration Commands
+#define DISPLAY_START_LINE      0x40
+#define SEGMENT_REMAP           0xA0
+#define SEGMENT_REMAP_INV       0xA1
+#define MULTIPLEX_RATIO         0xA8
+#define COM_SCAN_INC            0xC0
+#define COM_SCAN_DEC            0xC8
+#define DISPLAY_OFFSET          0xD3
+#define COM_PINS                0xDA
+
+// Timing & Driving Commands
+#define DISPLAY_CLOCK           0xD5
+#define PRE_CHARGE_PERIOD       0xD9
+#define VCOM_DETECT             0xDB
+
+// Charge Pump Commands
+#define CHARGE_PUMP             0x8D
+
+// Misc defines
+#define OLED_TIMEOUT 60000
+#define OLED_BLOCK_COUNT (sizeof(OLED_BLOCK_TYPE) * 8)
+#define OLED_BLOCK_SIZE (OLED_MATRIX_SIZE / OLED_BLOCK_COUNT)
+
+// i2c defines
+#define I2C_CMD 0x00
+#define I2C_DATA 0x40
+#if defined(__AVR__)
+  // already defined on ARM
+  #define I2C_TIMEOUT 100
+  #define I2C_TRANSMIT_P(data) i2c_transmit_P((OLED_DISPLAY_ADDRESS << 1), &data[0], sizeof(data), I2C_TIMEOUT)
+#else // defined(__AVR__)
+  #define I2C_TRANSMIT_P(data) i2c_transmit((OLED_DISPLAY_ADDRESS << 1), &data[0], sizeof(data), I2C_TIMEOUT)
+#endif // defined(__AVR__)
+#define I2C_TRANSMIT(data) i2c_transmit((OLED_DISPLAY_ADDRESS << 1), &data[0], sizeof(data), I2C_TIMEOUT)
+#define I2C_WRITE_REG(mode, data, size) i2c_writeReg((OLED_DISPLAY_ADDRESS << 1), mode, data, size, I2C_TIMEOUT)
+
+#define HAS_FLAGS(bits, flags) ((bits & flags) == flags)
+
+// Display buffer's is the same as the OLED memory layout
+// this is so we don't end up with rounding errors with
+// parts of the display unusable or don't get cleared correctly
+// and also allows for drawing & inverting
+uint8_t          oled_buffer[OLED_MATRIX_SIZE];
+uint8_t*         oled_cursor;
+OLED_BLOCK_TYPE  oled_dirty = 0;
+bool             oled_initialized = false;
+bool             oled_active = false;
+bool             oled_scrolling = false;
+uint8_t          oled_rotation = 0;
+uint8_t          oled_rotation_width = 0;
+#if !defined(OLED_DISABLE_TIMEOUT)
+  uint16_t         oled_last_activity;
+#endif
+
+// Internal variables to reduce math instructions
+
+#if defined(__AVR__)
+// identical to i2c_transmit, but for PROGMEM since all initialization is in PROGMEM arrays currently
+// probably should move this into i2c_master...
+static i2c_status_t i2c_transmit_P(uint8_t address, const uint8_t* data, uint16_t length, uint16_t timeout) {
+  i2c_status_t status = i2c_start(address | I2C_WRITE, timeout);
+
+  for (uint16_t i = 0; i < length && status >= 0; i++) {
+    status = i2c_write(pgm_read_byte((const char*)data++), timeout);
+    if (status) break;
+  }
+
+  i2c_stop();
+
+  return status;
+}
+#endif
+
+// Flips the rendering bits for a character at the current cursor position
+static void InvertCharacter(uint8_t *cursor)
+{
+  const uint8_t *end = cursor + OLED_FONT_WIDTH;
+  while (cursor < end) {
+    *cursor = ~(*cursor);
+    cursor++;
+  }
+}
+
+bool oled_init(uint8_t rotation) {
+  oled_rotation = oled_init_user(rotation);
+  if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_90)) {
+    oled_rotation_width = OLED_DISPLAY_WIDTH;
+  } else {
+    oled_rotation_width = OLED_DISPLAY_HEIGHT;
+  }
+  i2c_init();
+
+  static const uint8_t PROGMEM display_setup1[] = {
+    I2C_CMD,
+    DISPLAY_OFF,
+    DISPLAY_CLOCK, 0x80,
+    MULTIPLEX_RATIO, OLED_DISPLAY_HEIGHT - 1,
+    DISPLAY_OFFSET, 0x00,
+    DISPLAY_START_LINE | 0x00,
+    CHARGE_PUMP, 0x14,
+    MEMORY_MODE, 0x00, }; // Horizontal addressing mode
+  if (I2C_TRANSMIT_P(display_setup1) != I2C_STATUS_SUCCESS) {
+    print("oled_init cmd set 1 failed\n");
+    return false;
+  }
+
+  if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_180)) {
+    static const uint8_t PROGMEM display_normal[] = {
+      I2C_CMD,
+      SEGMENT_REMAP_INV,
+      COM_SCAN_DEC };
+    if (I2C_TRANSMIT_P(display_normal) != I2C_STATUS_SUCCESS) {
+      print("oled_init cmd normal rotation failed\n");
+      return false;
+    }
+  } else {
+    static const uint8_t PROGMEM display_flipped[] = {
+      I2C_CMD,
+      SEGMENT_REMAP,
+      COM_SCAN_INC };
+    if (I2C_TRANSMIT_P(display_flipped) != I2C_STATUS_SUCCESS) {
+      print("display_flipped failed\n");
+      return false;
+    }
+  }
+
+  static const uint8_t PROGMEM display_setup2[] = {
+    I2C_CMD,
+    COM_PINS, 0x02,
+    CONTRAST, 0x8F,
+    PRE_CHARGE_PERIOD, 0xF1,
+    VCOM_DETECT, 0x40,
+    DISPLAY_ALL_ON_RESUME,
+    NORMAL_DISPLAY,
+    DEACTIVATE_SCROLL,
+    DISPLAY_ON };
+  if (I2C_TRANSMIT_P(display_setup2) != I2C_STATUS_SUCCESS) {
+    print("display_setup2 failed\n");
+    return false;
+  }
+
+  oled_clear();
+  oled_initialized = true;
+  oled_active = true;
+  oled_scrolling = false;
+  return true;
+}
+
+__attribute__((weak))
+oled_rotation_t oled_init_user(oled_rotation_t rotation) {
+  return rotation;
+}
+
+void oled_clear(void) {
+  memset(oled_buffer, 0, sizeof(oled_buffer));
+  oled_cursor = &oled_buffer[0];
+  oled_dirty = -1; // -1 will be max value as long as display_dirty is unsigned type
+}
+
+static void calc_bounds(uint8_t update_start, uint8_t* cmd_array)
+{
+  cmd_array[1] = OLED_BLOCK_SIZE * update_start % OLED_DISPLAY_WIDTH;
+  cmd_array[4] = OLED_BLOCK_SIZE * update_start / OLED_DISPLAY_WIDTH;
+  cmd_array[2] = (OLED_BLOCK_SIZE + OLED_DISPLAY_WIDTH - 1) % OLED_DISPLAY_WIDTH + cmd_array[1];
+  cmd_array[5] = (OLED_BLOCK_SIZE + OLED_DISPLAY_WIDTH - 1) / OLED_DISPLAY_WIDTH - 1;
+}
+
+static void calc_bounds_90(uint8_t update_start, uint8_t* cmd_array)
+{
+  cmd_array[1] = OLED_BLOCK_SIZE * update_start / OLED_DISPLAY_HEIGHT * 8;
+  cmd_array[4] = OLED_BLOCK_SIZE * update_start % OLED_DISPLAY_HEIGHT;
+  cmd_array[2] = (OLED_BLOCK_SIZE + OLED_DISPLAY_HEIGHT - 1) / OLED_DISPLAY_HEIGHT * 8 - 1 + cmd_array[1];;
+  cmd_array[5] = (OLED_BLOCK_SIZE + OLED_DISPLAY_HEIGHT - 1) % OLED_DISPLAY_HEIGHT / 8;
+}
+
+uint8_t crot(uint8_t a, int8_t n)
+{
+  const uint8_t mask = 0x7;
+  n &= mask;
+  return a << n | a >> (-n & mask);
+}
+
+static void rotate_90(const uint8_t* src, uint8_t* dest)
+{
+  for (uint8_t i = 0, shift = 7; i < 8; ++i, --shift) {
+    uint8_t selector = (1 << i);
+    for (uint8_t j = 0; j < 8; ++j) {
+      dest[i] |= crot(src[j] & selector, shift - (int8_t)j);
+    }
+  }
+}
+
+void oled_render(void) {
+  // Do we have work to do?
+  if (!oled_dirty || oled_scrolling) {
+    return;
+  }
+
+  // Find first dirty block
+  uint8_t update_start = 0;
+  while (!(oled_dirty & (1 << update_start))) { ++update_start; }
+
+  // Set column & page position
+  static uint8_t display_start[] = {
+    I2C_CMD,
+    COLUMN_ADDR, 0, OLED_DISPLAY_WIDTH - 1,
+    PAGE_ADDR, 0, OLED_DISPLAY_HEIGHT / 8 - 1 };
+  if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_90)) {
+    calc_bounds(update_start, &display_start[1]); // Offset from I2C_CMD byte at the start
+  } else {
+    calc_bounds_90(update_start, &display_start[1]); // Offset from I2C_CMD byte at the start
+  }
+
+  // Send column & page position
+  if (I2C_TRANSMIT(display_start) != I2C_STATUS_SUCCESS) {
+    print("oled_render offset command failed\n");
+    return;
+  }
+
+  if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_90)) {
+    // Send render data chunk as is
+    if (I2C_WRITE_REG(I2C_DATA, &oled_buffer[OLED_BLOCK_SIZE * update_start], OLED_BLOCK_SIZE) != I2C_STATUS_SUCCESS) {
+      print("oled_render data failed\n");
+      return;
+    }
+  } else {
+    // Rotate the render chunks
+    const static uint8_t source_map[] = OLED_SOURCE_MAP;
+    const static uint8_t target_map[] = OLED_TARGET_MAP;
+
+    static uint8_t temp_buffer[OLED_BLOCK_SIZE];
+    memset(temp_buffer, 0, sizeof(temp_buffer));
+    for(uint8_t i = 0; i < sizeof(source_map); ++i) {
+      rotate_90(&oled_buffer[OLED_BLOCK_SIZE * update_start + source_map[i]], &temp_buffer[target_map[i]]);
+    }
+
+    // Send render data chunk after rotating
+    if (I2C_WRITE_REG(I2C_DATA, &temp_buffer[0], OLED_BLOCK_SIZE) != I2C_STATUS_SUCCESS) {
+      print("oled_render data failed\n");
+      return;
+    }
+  }
+
+  // Turn on display if it is off
+  oled_on();
+
+  // Clear dirty flag
+  oled_dirty &= ~(1 << update_start);
+}
+
+void oled_set_cursor(uint8_t col, uint8_t line) {
+  uint16_t index = line * oled_rotation_width + col * OLED_FONT_WIDTH;
+
+  // Out of bounds?
+  if (index >= OLED_MATRIX_SIZE) {
+    index = 0;
+  }
+
+  oled_cursor = &oled_buffer[index];
+}
+
+void oled_advance_page(bool clearPageRemainder) {
+  uint16_t index = oled_cursor - &oled_buffer[0];
+  uint8_t remaining = oled_rotation_width - (index % oled_rotation_width);
+
+  if (clearPageRemainder) {
+    // Remaining Char count
+    remaining = remaining / OLED_FONT_WIDTH;
+
+    // Write empty character until next line
+    while (remaining--)
+      oled_write_char(' ', false);
+  } else {
+    // Next page index out of bounds?
+    if (index + remaining >= OLED_MATRIX_SIZE) {
+      index = 0;
+      remaining = 0;
+    }
+
+    oled_cursor = &oled_buffer[index + remaining];
+  }
+}
+
+void oled_advance_char(void) {
+  uint16_t nextIndex = oled_cursor - &oled_buffer[0] + OLED_FONT_WIDTH;
+  uint8_t remainingSpace = oled_rotation_width - (nextIndex % oled_rotation_width);
+
+  // Do we have enough space on the current line for the next character
+  if (remainingSpace < OLED_FONT_WIDTH) {
+    nextIndex += remainingSpace;
+  }
+
+  // Did we go out of bounds
+  if (nextIndex >= OLED_MATRIX_SIZE) {
+    nextIndex = 0;
+  }
+
+  // Update cursor position
+  oled_cursor = &oled_buffer[nextIndex];
+}
+
+// Main handler that writes character data to the display buffer
+void oled_write_char(const char data, bool invert) {
+  // Advance to the next line if newline
+  if (data == '\n') {
+    // Old source wrote ' ' until end of line...
+    oled_advance_page(true);
+    return;
+  }
+
+  // copy the current render buffer to check for dirty after
+  static uint8_t oled_temp_buffer[OLED_FONT_WIDTH];
+  memcpy(&oled_temp_buffer, oled_cursor, OLED_FONT_WIDTH);
+
+  // set the reder buffer data
+  uint8_t cast_data = (uint8_t)data; // font based on unsigned type for index
+  if (cast_data < OLED_FONT_START || cast_data > OLED_FONT_END) {
+    memset(oled_cursor, 0x00, OLED_FONT_WIDTH);
+  } else {
+    const uint8_t *glyph = &font[(cast_data - OLED_FONT_START) * OLED_FONT_WIDTH];
+    memcpy_P(oled_cursor, glyph, OLED_FONT_WIDTH);
+  }
+
+  // Invert if needed
+  if (invert) {
+    InvertCharacter(oled_cursor);
+  }
+
+  // Dirty check
+  if (memcmp(&oled_temp_buffer, oled_cursor, OLED_FONT_WIDTH)) {
+    uint16_t index = oled_cursor - &oled_buffer[0];
+    oled_dirty |= (1 << (index / OLED_BLOCK_SIZE));
+    // Edgecase check if the written data spans the 2 chunks
+    oled_dirty |= (1 << ((index + OLED_FONT_WIDTH) / OLED_BLOCK_SIZE));
+  }
+
+  // Finally move to the next char
+  oled_advance_char();
+}
+
+void oled_write(const char *data, bool invert) {
+  const char *end = data + strlen(data);
+  while (data < end) {
+    oled_write_char(*data, invert);
+    data++;
+  }
+}
+
+void oled_write_ln(const char *data, bool invert) {
+  oled_write(data, invert);
+  oled_advance_page(true);
+}
+
+#if defined(__AVR__)
+void oled_write_P(const char *data, bool invert) {
+  uint8_t c = pgm_read_byte(data);
+  while (c != 0) {
+    oled_write_char(c, invert);
+    c = pgm_read_byte(++data);
+  }
+}
+
+void oled_write_ln_P(const char *data, bool invert) {
+  oled_write_P(data, invert);
+  oled_advance_page(true);
+}
+#endif // defined(__AVR__)
+
+bool oled_on(void) {
+#if !defined(OLED_DISABLE_TIMEOUT)
+  oled_last_activity = timer_read();
+#endif
+
+  static const uint8_t PROGMEM display_on[] = { I2C_CMD, DISPLAY_ON };
+  if (!oled_active) {
+    if (I2C_TRANSMIT_P(display_on) != I2C_STATUS_SUCCESS) {
+      print("oled_on cmd failed\n");
+      return oled_active;
+    }
+    oled_active = true;
+  }
+  return oled_active;
+}
+
+bool oled_off(void) {
+  static const uint8_t PROGMEM display_off[] = { I2C_CMD, DISPLAY_OFF };
+  if (oled_active) {
+    if (I2C_TRANSMIT_P(display_off) != I2C_STATUS_SUCCESS) {
+      print("oled_off cmd failed\n");
+      return oled_active;
+    }
+    oled_active = false;
+  }
+  return !oled_active;
+}
+
+bool oled_scroll_right(void) {
+  // Dont enable scrolling if we need to update the display
+  // This prevents scrolling of bad data from starting the scroll too early after init
+  if (!oled_dirty && !oled_scrolling) {
+    static const uint8_t PROGMEM display_scroll_right[] = {
+      I2C_CMD, SCROLL_RIGHT, 0x00, 0x00, 0x00, 0x0F, 0x00, 0xFF, ACTIVATE_SCROLL };
+    if (I2C_TRANSMIT_P(display_scroll_right) != I2C_STATUS_SUCCESS) {
+      print("oled_scroll_right cmd failed\n");
+      return oled_scrolling;
+    }
+    oled_scrolling = true;
+  }
+  return oled_scrolling;
+}
+
+bool oled_scroll_left(void) {
+  // Dont enable scrolling if we need to update the display
+  // This prevents scrolling of bad data from starting the scroll too early after init
+  if (!oled_dirty && !oled_scrolling) {
+    static const uint8_t PROGMEM display_scroll_left[] = {
+      I2C_CMD, SCROLL_LEFT, 0x00, 0x00, 0x00, 0x0F, 0x00, 0xFF, ACTIVATE_SCROLL };
+    if (I2C_TRANSMIT_P(display_scroll_left) != I2C_STATUS_SUCCESS) {
+      print("oled_scroll_left cmd failed\n");
+      return oled_scrolling;
+    }
+    oled_scrolling = true;
+  }
+  return oled_scrolling;
+}
+
+bool oled_scroll_off(void) {
+  if (oled_scrolling) {
+    static const uint8_t PROGMEM display_scroll_off[] = { I2C_CMD, DEACTIVATE_SCROLL };
+    if (I2C_TRANSMIT_P(display_scroll_off) != I2C_STATUS_SUCCESS) {
+      print("oled_scroll_off cmd failed\n");
+      return oled_scrolling;
+    }
+    oled_scrolling = false;
+  }
+  return !oled_scrolling;
+}
+
+uint8_t oled_max_chars(void) {
+  if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_90)) {
+    return OLED_DISPLAY_WIDTH / OLED_FONT_WIDTH;
+  }
+  return OLED_DISPLAY_HEIGHT / OLED_FONT_WIDTH;
+}
+
+uint8_t oled_max_lines(void) {
+  if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_90)) {
+    return OLED_DISPLAY_HEIGHT / OLED_FONT_HEIGHT;
+  }
+  return OLED_DISPLAY_WIDTH / OLED_FONT_HEIGHT;
+}
+
+void oled_task(void) {
+  if (!oled_initialized) {
+    return;
+  }
+
+  oled_set_cursor(0, 0);
+
+  oled_task_user();
+
+  // Smart render system, no need to check for dirty
+  oled_render();
+
+  // Display timeout check
+#if !defined(OLED_DISABLE_TIMEOUT)
+  if (oled_active && timer_elapsed(oled_last_activity) > OLED_TIMEOUT) {
+    oled_off();
+  }
+#endif
+}
+
+__attribute__((weak))
+void oled_task_user(void) {
+}

drivers/oled/oled_driver.h

@@ -0,0 +1,192 @@
+/*
+Copyright 2019 Ryan Caltabiano <https://github.com/XScorpion2>
+
+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 <stdint.h>
+#include <stdbool.h>
+
+
+#if defined(OLED_DISPLAY_CUSTOM)
+  // Expected user to implement the necessary defines
+#elif defined(OLED_DISPLAY_128X64)
+  // Double height 128x64
+  #define OLED_DISPLAY_WIDTH 128
+  #define OLED_DISPLAY_HEIGHT 64
+  #define OLED_MATRIX_SIZE (OLED_DISPLAY_HEIGHT / 8 * OLED_DISPLAY_WIDTH) // 1024 (compile time mathed)
+  #define OLED_BLOCK_TYPE uint32_t
+  #define OLED_BLOCK_COUNT (sizeof(OLED_BLOCK_TYPE) * 8) // 32 (compile time mathed)
+  #define OLED_BLOCK_SIZE (OLED_MATRIX_SIZE / OLED_BLOCK_COUNT) // 32 (compile time mathed)
+
+  // For 90 degree rotation, we map our internal matrix to oled matrix using fixed arrays
+  // The OLED writes to it's memory horizontally, starting top left, but our memory starts bottom left in this mode
+  #define OLED_SOURCE_MAP { 32, 40, 48, 56 }
+  #define OLED_TARGET_MAP { 24, 16, 8, 0 }
+  // If OLED_BLOCK_TYPE is uint16_t, these tables would look like:
+  // #define OLED_SOURCE_MAP { 0, 8, 16, 24, 32, 40, 48, 56 }
+  // #define OLED_TARGET_MAP { 56, 48, 40, 32, 24, 16, 8, 0 }
+  // If OLED_BLOCK_TYPE is uint8_t, these tables would look like:
+  // #define OLED_SOURCE_MAP { 0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120 }
+  // #define OLED_TARGET_MAP { 56, 120, 48, 112, 40, 104, 32, 96, 24, 88, 16, 80, 8, 72, 0, 64 }
+#else // defined(OLED_DISPLAY_128X64)
+  // Default 128x32
+  #define OLED_DISPLAY_WIDTH 128
+  #define OLED_DISPLAY_HEIGHT 32
+  #define OLED_MATRIX_SIZE (OLED_DISPLAY_HEIGHT / 8 * OLED_DISPLAY_WIDTH) // 512 (compile time mathed)
+  #define OLED_BLOCK_TYPE uint16_t // Type to use for segmenting the oled display for smart rendering, use unsigned types only
+  #define OLED_BLOCK_COUNT (sizeof(OLED_BLOCK_TYPE) * 8) // 16 (compile time mathed)
+  #define OLED_BLOCK_SIZE (OLED_MATRIX_SIZE / OLED_BLOCK_COUNT) // 32 (compile time mathed)
+
+  // For 90 degree rotation, we map our internal matrix to oled matrix using fixed arrays
+  // The OLED writes to it's memory horizontally, starting top left, but our memory starts bottom left in this mode
+  #define OLED_SOURCE_MAP { 0, 8, 16, 24 }
+  #define OLED_TARGET_MAP { 24, 16, 8, 0 }
+  // If OLED_BLOCK_TYPE is uint8_t, these tables would look like:
+  // #define OLED_SOURCE_MAP { 0, 8, 16, 24, 32, 40, 48, 56 }
+  // #define OLED_TARGET_MAP { 48, 32, 16, 0, 56, 40, 24, 8 }
+#endif // defined(OLED_DISPLAY_CUSTOM)
+
+// Address to use for tthe i2d oled communication
+#if !defined(OLED_DISPLAY_ADDRESS)
+  #define OLED_DISPLAY_ADDRESS 0x3C
+#endif
+
+// Custom font file to use
+#if !defined(OLED_FONT_H)
+  #define OLED_FONT_H "glcdfont.c"
+#endif
+// unsigned char value of the first character in the font file
+#if !defined(OLED_FONT_START)
+  #define OLED_FONT_START 0
+#endif
+// unsigned char value of the last character in the font file
+#if !defined(OLED_FONT_END)
+  #define OLED_FONT_END 224
+#endif
+// Font render width
+#if !defined(OLED_FONT_WIDTH)
+  #define OLED_FONT_WIDTH 6
+#endif
+// Font render height
+#if !defined(OLED_FONT_HEIGHT)
+  #define OLED_FONT_HEIGHT 8
+#endif
+
+// OLED Rotation enum values are flags
+typedef enum {
+    OLED_ROTATION_0   = 0,
+    OLED_ROTATION_90  = 1,
+    OLED_ROTATION_180 = 2,
+    OLED_ROTATION_270 = 3, // OLED_ROTATION_90 | OLED_ROTATION_180
+} oled_rotation_t;
+
+// Initialize the oled display, rotating the rendered output based on the define passed in.
+// Returns true if the OLED was initialized successfully
+bool oled_init(oled_rotation_t rotation);
+
+// Called at the start of oled_init, weak function overridable by the user
+// rotation - the value passed into oled_init
+// Return new oled_rotation_t if you want to override default rotation
+oled_rotation_t oled_init_user(oled_rotation_t rotation);
+
+// Clears the display buffer, resets cursor position to 0, and sets the buffer to dirty for rendering
+void oled_clear(void);
+
+// Renders the dirty chunks of the buffer to oled display
+void oled_render(void);
+
+// Moves cursor to character position indicated by column and line, wraps if out of bounds
+// Max column denoted by 'oled_max_chars()' and max lines by 'oled_max_lines()' functions
+void oled_set_cursor(uint8_t col, uint8_t line);
+
+// Advances the cursor to the next page, writing ' ' if true
+// Wraps to the begining when out of bounds
+void oled_advance_page(bool clearPageRemainder);
+
+// Moves the cursor forward 1 character length
+// Advance page if there is not enough room for the next character
+// Wraps to the begining when out of bounds
+void oled_advance_char(void);
+
+// Writes a single character to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+// Main handler that writes character data to the display buffer
+void oled_write_char(const char data, bool invert);
+
+// Writes a string to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+void oled_write(const char *data, bool invert);
+
+// Writes a string to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+// Advances the cursor to the next page, wiring ' ' to the remainder of the current page
+void oled_write_ln(const char *data, bool invert);
+
+#if defined(__AVR__)
+// Writes a PROGMEM string to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+// Remapped to call 'void oled_write(const char *data, bool invert);' on ARM
+void oled_write_P(const char *data, bool invert);
+
+// Writes a PROGMEM string to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+// Advances the cursor to the next page, wiring ' ' to the remainder of the current page
+// Remapped to call 'void oled_write_ln(const char *data, bool invert);' on ARM
+void oled_write_ln_P(const char *data, bool invert);
+#else
+  // Writes a string to the buffer at current cursor position
+  // Advances the cursor while writing, inverts the pixels if true
+  #define oled_write_P(data, invert) oled_write(data, invert)
+
+  // Writes a string to the buffer at current cursor position
+  // Advances the cursor while writing, inverts the pixels if true
+  // Advances the cursor to the next page, wiring ' ' to the remainder of the current page
+  #define oled_write_ln_P(data, invert) oled_write(data, invert)
+#endif // defined(__AVR__)
+
+// Can be used to manually turn on the screen if it is off
+// Returns true if the screen was on or turns on
+bool oled_on(void);
+
+// Can be used to manually turn off the screen if it is on
+// Returns true if the screen was off or turns off
+bool oled_off(void);
+
+// Basically it's oled_render, but with timeout management and oled_task_user calling!
+void oled_task(void);
+
+// Called at the start of oled_task, weak function overridable by the user
+void oled_task_user(void);
+
+// Scrolls the entire display right
+// Returns true if the screen was scrolling or starts scrolling
+// NOTE: display contents cannot be changed while scrolling
+bool oled_scroll_right(void);
+
+// Scrolls the entire display left
+// Returns true if the screen was scrolling or starts scrolling
+// NOTE: display contents cannot be changed while scrolling
+bool oled_scroll_left(void);
+
+// Turns off display scrolling
+// Returns true if the screen was not scrolling or stops scrolling
+bool oled_scroll_off(void);
+
+// Returns the maximum number of characters that will fit on a line
+uint8_t oled_max_chars(void);
+
+// Returns the maximum number of lines that will fit on the oled
+uint8_t oled_max_lines(void);

keyboards/1upkeyboards/super16/config.h

@@ -21,7 +21,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 /* USB Device descriptor parameter */
 #define VENDOR_ID       0xFEED
-#define PRODUCT_ID      0x0000
+#define PRODUCT_ID      0x2010
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    1upkeyboards
 #define PRODUCT         super16
@@ -65,9 +65,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
   #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 ==*/
+  /*== all animations enable ==*/
+  #define RGBLIGHT_ANIMATIONS
+  /*== or choose animations ==*/
 //   #define RGBLIGHT_EFFECT_BREATHING
 //   #define RGBLIGHT_EFFECT_RAINBOW_MOOD
 //   #define RGBLIGHT_EFFECT_RAINBOW_SWIRL
@@ -85,10 +85,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* 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
 
@@ -242,3 +241,5 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* Bootmagic Lite key configuration */
 // #define BOOTMAGIC_LITE_ROW 0
 // #define BOOTMAGIC_LITE_COLUMN 0
+
+/* prevent stuck modifiers */

keyboards/1upkeyboards/super16/info.json

@@ -1,12 +1,15 @@
 {
-    "keyboard_name": "super16", 
-    "url": "", 
-    "maintainer": "qmk", 
-    "width": 4, 
-    "height": 4, 
-    "layouts": {
-        "LAYOUT_ortho_4x4": {
-            "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}]
-        }
+  "keyboard_name": "super16",
+  "url": "",
+  "maintainer": "qmk",
+  "width": 4,
+  "height": 4,
+  "layouts": {
+    "LAYOUT_ortho_4x4": {
+      "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}]
+    },
+    "LAYOUT_numpad_4x4": {
+      "layout": [{"x":0, "y":0}, {"x":1, "y":0}, {"x":2, "y":0}, {"x":3, "y":0, "h":2}, {"x":0, "y":1}, {"x":1, "y":1}, {"x":2, "y":1}, {"x":0, "y":2}, {"x":1, "y":2}, {"x":2, "y":2}, {"x":3, "y":2, "h":2}, {"x":0, "y":3, "w":2}, {"x":2, "y":3}]
     }
-}
+  }
+}

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

@@ -15,40 +15,16 @@
  */
 #include QMK_KEYBOARD_H
 
-// 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] = {
   [0] = LAYOUT_ortho_4x4( /* Base */
-    KC_A,  KC_1,  KC_2, KC_4, \
-    KC_A,  KC_1,  KC_2, KC_4, \
-    KC_A,  KC_1,  KC_2, KC_4, \
-    KC_A,  KC_1,  KC_2, KC_4 \
+    RGB_TOG,    KC_1,    KC_U,    KC_P,
+    RGB_MOD,    KC_1,    KC_U,    KC_P,
+    RGB_TOG,    KC_1,    KC_U,    KC_P,
+    RGB_MOD,    KC_1,    KC_U,    KC_P
   ),
 };
 
 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/1upkeyboards/super16/rules.mk

@@ -1,5 +1,4 @@
 # MCU name
-#MCU = at90usb1286
 MCU = atmega32u4
 
 # Processor frequency.
@@ -15,7 +14,6 @@ MCU = atmega32u4
 #     software delays.
 F_CPU = 16000000
 
-
 #
 # LUFA specific
 #
@@ -48,7 +46,6 @@ OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
 #   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
@@ -58,26 +55,27 @@ BOOTLOADER = caterina
 #   USBaspLoader        2048
 # OPT_DEFS += -DBOOTLOADER_SIZE=4096
 
+#EXTRAFLAGS += -flto
 
 # Build Options
 #   change yes to no to disable
 #
-BOOTMAGIC_ENABLE = lite      # Virtual DIP switch configuration(+1000)
+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 = 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 = no       # Enable keyboard backlight functionality on B7 by default
-RGBLIGHT_ENABLE = yes        # Enable keyboard RGB underglow
+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)
+HD44780_ENABLE = no         # Enable support for HD44780 based LCDs (+400)
 
-LAYOUTS = ortho_4x4
+LAYOUTS = ortho_4x4 numpad_4x4

keyboards/1upkeyboards/super16/super16.c

@@ -16,28 +16,28 @@
 #include "super16.h"
 
 void matrix_init_kb(void) {
-	// put your keyboard start-up code here
-	// runs once when the firmware starts up
+  // put your keyboard start-up code here
+  // runs once when the firmware starts up
 
-	matrix_init_user();
+  matrix_init_user();
 }
 
 void matrix_scan_kb(void) {
-	// put your looping keyboard code here
-	// runs every cycle (a lot)
+  // put your looping keyboard code here
+  // runs every cycle (a lot)
 
-	matrix_scan_user();
+  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
+  // put your per-action keyboard code here
+  // runs for every action, just before processing by the firmware
 
-	return process_record_user(keycode, record);
+  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
+  // put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
 
-	led_set_user(usb_led);
+  led_set_user(usb_led);
 }

keyboards/1upkeyboards/super16/super16.h

@@ -25,15 +25,27 @@
  * The second converts the arguments into a two-dimensional array which
  * represents the switch matrix.
  */
+
 #define LAYOUT_ortho_4x4( \
-    k00, k01, k02, k03, \
-    k10, k11, k12, k13, \
-    k20, k21, k22, k23, \
-    k30, k31, k32, k33  \
-) \
-{ \
-    { k00, k01, k02, k03 }, \
-    { k10, k11, k12, k13 }, \
-    { k20, k21, k22, k23 }, \
-    { k30, k31, k32, k33 }, \
+  K00, K01, K02, K03, \
+  K10, K11, K12, K13, \
+  K20, K21, K22, K23, \
+  K30, K31, K32, K33  \
+) { \
+  { K00, K01, K02, K03 }, \
+  { K10, K11, K12, K13 }, \
+  { K20, K21, K22, K23 }, \
+  { K30, K31, K32, K33 }  \
+}
+
+#define LAYOUT_numpad_4x4( \
+  K00, K01, K02, K03, \
+  K10, K11, K12,      \
+  K20, K21, K22, K23, \
+     K31,   K32      \
+) { \
+    { K00,   K01, K02, K03 }, \
+    { K10,   K11, K12, KC_NO }, \
+    { K20,   K21, K22, K23 }, \
+    { KC_NO, K31, K32, KC_NO }  \
 }

keyboards/adkb96/adkb96.c

@@ -0,0 +1,19 @@
+#include "adkb96.h"
+
+#ifdef SWAP_HANDS_ENABLE
+__attribute__ ((weak))
+const keypos_t hand_swap_config[MATRIX_ROWS][MATRIX_COLS] = {
+  {{0, 6}, {1, 6}, {2, 6}, {3, 6}, {4, 6}, {5, 6}, {6, 6}, {7, 6}},
+  {{0, 7}, {1, 7}, {2, 7}, {3, 7}, {4, 7}, {5, 7}, {6, 7}, {7, 7}},
+  {{0, 8}, {1, 8}, {2, 8}, {3, 8}, {4, 8}, {5, 8}, {6, 8}, {7, 8}},
+  {{0, 9}, {1, 9}, {2, 9}, {3, 9}, {4, 9}, {5, 9}, {6, 9}, {7, 9}},
+  {{0,10}, {1,10}, {2,10}, {3,10}, {4,10}, {5,10}, {6,10}, {7,10}},
+  {{0,11}, {1,11}, {2,11}, {3,11}, {4,11}, {5,11}, {6,11}, {7,11}},
+  {{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}, {5, 0}, {6, 0}, {7, 0}},
+  {{0, 1}, {1, 1}, {2, 1}, {3, 1}, {4, 1}, {5, 1}, {6, 1}, {7, 1}},
+  {{0, 2}, {1, 2}, {2, 2}, {3, 2}, {4, 2}, {5, 2}, {6, 2}, {7, 2}},
+  {{0, 3}, {1, 3}, {2, 3}, {3, 3}, {4, 3}, {5, 3}, {6, 3}, {7, 3}},
+  {{0, 4}, {1, 4}, {2, 4}, {3, 4}, {4, 4}, {5, 4}, {6, 4}, {7, 4}},
+  {{0, 5}, {1, 5}, {2, 5}, {3, 5}, {4, 5}, {5, 5}, {6, 5}, {7, 5}}
+};
+#endif

keyboards/adkb96/adkb96.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "quantum.h"
+
+#ifdef KEYBOARD_adkb96_rev1
+    #include "rev1.h"
+#endif
+
+
+// Used to create a keymap using only KC_ prefixed keys
+#define LAYOUT_kc_ortho_6x16( \
+    L00, L01, L02, L03, L04, L05, L06, L07, R00, R01, R02, R03, R04, R05, R06, R07, \
+    L10, L11, L12, L13, L14, L15, L16, L17, R10, R11, R12, R13, R14, R15, R16, R17, \
+    L20, L21, L22, L23, L24, L25, L26, L27, R20, R21, R22, R23, R24, R25, R26, R27, \
+    L30, L31, L32, L33, L34, L35, L36, L37, R30, R31, R32, R33, R34, R35, R36, R37, \
+    L40, L41, L42, L43, L44, L45, L46, L47, R40, R41, R42, R43, R44, R45, R46, R47, \
+    L50, L51, L52, L53, L54, L55, L56, L57, R50, R51, R52, R53, R54, R55, R56, R57 \
+    ) \
+    LAYOUT( \
+        KC_##L00, KC_##L01, KC_##L02, KC_##L03, KC_##L04, KC_##L05, KC_##L06, KC_##L07, KC_##R00, KC_##R01, KC_##R02, KC_##R03, KC_##R04, KC_##R05, KC_##R06, KC_##R07, \
+        KC_##L10, KC_##L11, KC_##L12, KC_##L13, KC_##L14, KC_##L15, KC_##L16, KC_##L17, KC_##R10, KC_##R11, KC_##R12, KC_##R13, KC_##R14, KC_##R15, KC_##R16, KC_##R17, \
+        KC_##L20, KC_##L21, KC_##L22, KC_##L23, KC_##L24, KC_##L25, KC_##L26, KC_##L27, KC_##R20, KC_##R21, KC_##R22, KC_##R23, KC_##R24, KC_##R25, KC_##R26, KC_##R27, \
+        KC_##L30, KC_##L31, KC_##L32, KC_##L33, KC_##L34, KC_##L35, KC_##L36, KC_##L37, KC_##R30, KC_##R31, KC_##R32, KC_##R33, KC_##R34, KC_##R35, KC_##R36, KC_##R37, \
+        KC_##L40, KC_##L41, KC_##L42, KC_##L43, KC_##L44, KC_##L45, KC_##L46, KC_##L47, KC_##R40, KC_##R41, KC_##R42, KC_##R43, KC_##R44, KC_##R45, KC_##R46, KC_##R47, \
+        KC_##L50, KC_##L51, KC_##L52, KC_##L53, KC_##L54, KC_##L55, KC_##L56, KC_##L57, KC_##R50, KC_##R51, KC_##R52, KC_##R53, KC_##R54, KC_##R55, KC_##R56 ,KC_##R57 \
+    )
+
+#define LAYOUT_kc LAYOUT_kc_ortho_6x16

keyboards/adkb96/config.h

@@ -0,0 +1,22 @@
+/*
+Copyright 2012 Jun Wako <wakojun@gmail.com>
+Copyright 2015 Jack Humbert
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include "config_common.h"
+

keyboards/adkb96/info.json

@@ -0,0 +1,494 @@
+{
+	"keyboard_name": "adkb96",
+	"url": "",
+	"maintainer": "qmk",
+	"width": 16,
+	"height": 6,
+	"layouts": {
+		"LAYOUT_ortho_6x16": {
+			"key_count": 96,
+			"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": "L07",
+					"x": 7,
+					"y": 0
+				},
+				{
+					"label": "R00",
+					"x": 8,
+					"y": 0
+				},
+				{
+					"label": "R01",
+					"x": 9,
+					"y": 0
+				},
+				{
+					"label": "R02",
+					"x": 10,
+					"y": 0
+				},
+				{
+					"label": "R03",
+					"x": 11,
+					"y": 0
+				},
+				{
+					"label": "R04",
+					"x": 12,
+					"y": 0
+				},
+				{
+					"label": "R05",
+					"x": 13,
+					"y": 0
+				},
+				{
+					"label": "R06",
+					"x": 14,
+					"y": 0
+				},
+				{
+					"label": "R07",
+					"x": 15,
+					"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": "L17",
+					"x": 7,
+					"y": 1
+				},
+				{
+					"label": "R10",
+					"x": 8,
+					"y": 1
+				},
+				{
+					"label": "R11",
+					"x": 9,
+					"y": 1
+				},
+				{
+					"label": "R12",
+					"x": 10,
+					"y": 1
+				},
+				{
+					"label": "R13",
+					"x": 11,
+					"y": 1
+				},
+				{
+					"label": "R14",
+					"x": 12,
+					"y": 1
+				},
+				{
+					"label": "R15",
+					"x": 13,
+					"y": 1
+				},
+				{
+					"label": "R16",
+					"x": 14,
+					"y": 1
+				},
+				{
+					"label": "R17",
+					"x": 15,
+					"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": "L27",
+					"x": 7,
+					"y": 2
+				},
+				{
+					"label": "R20",
+					"x": 8,
+					"y": 2
+				},
+				{
+					"label": "R21",
+					"x": 9,
+					"y": 2
+				},
+				{
+					"label": "R22",
+					"x": 10,
+					"y": 2
+				},
+				{
+					"label": "R23",
+					"x": 11,
+					"y": 2
+				},
+				{
+					"label": "R24",
+					"x": 12,
+					"y": 2
+				},
+				{
+					"label": "R25",
+					"x": 13,
+					"y": 2
+				},
+				{
+					"label": "R26",
+					"x": 14,
+					"y": 2
+				},
+				{
+					"label": "R27",
+					"x": 15,
+					"y": 2
+				},
+				{
+					"label": "L30",
+					"x": 0,
+					"y": 3
+				},
+				{
+					"label": "L31",
+					"x": 1,
+					"y": 3
+				},
+				{
+					"label": "L32",
+					"x": 2,
+					"y": 3
+				},
+				{
+					"label": "L33",
+					"x": 3,
+					"y": 3
+				},
+				{
+					"label": "L34",
+					"x": 4,
+					"y": 3
+				},
+				{
+					"label": "L35",
+					"x": 5,
+					"y": 3
+				},
+				{
+					"label": "L36",
+					"x": 6,
+					"y": 3
+				},
+				{
+					"label": "L37",
+					"x": 7,
+					"y": 3
+				},
+				{
+					"label": "R30",
+					"x": 8,
+					"y": 3
+				},
+				{
+					"label": "R31",
+					"x": 9,
+					"y": 3
+				},
+				{
+					"label": "R32",
+					"x": 10,
+					"y": 3
+				},
+				{
+					"label": "R33",
+					"x": 11,
+					"y": 3
+				},
+				{
+					"label": "R34",
+					"x": 12,
+					"y": 3
+				},
+				{
+					"label": "R35",
+					"x": 13,
+					"y": 3
+				},
+				{
+					"label": "R36",
+					"x": 14,
+					"y": 3
+				},
+				{
+					"label": "R37",
+					"x": 15,
+					"y": 3
+				},
+				{
+					"label": "L40",
+					"x": 0,
+					"y": 4
+				},
+				{
+					"label": "L41",
+					"x": 1,
+					"y": 4
+				},
+				{
+					"label": "L42",
+					"x": 2,
+					"y": 4
+				},
+				{
+					"label": "L43",
+					"x": 3,
+					"y": 4
+				},
+				{
+					"label": "L44",
+					"x": 4,
+					"y": 4
+				},
+				{
+					"label": "L45",
+					"x": 5,
+					"y": 4
+				},
+				{
+					"label": "L46",
+					"x": 6,
+					"y": 4
+				},
+				{
+					"label": "L47",
+					"x": 7,
+					"y": 4
+				},
+				{
+					"label": "R40",
+					"x": 8,
+					"y": 4
+				},
+				{
+					"label": "R41",
+					"x": 9,
+					"y": 4
+				},
+				{
+					"label": "R42",
+					"x": 10,
+					"y": 4
+				},
+				{
+					"label": "R43",
+					"x": 11,
+					"y": 4
+				},
+				{
+					"label": "R44",
+					"x": 12,
+					"y": 4
+				},
+				{
+					"label": "R45",
+					"x": 13,
+					"y": 4
+				},
+				{
+					"label": "R46",
+					"x": 14,
+					"y": 4
+				},
+				{
+					"label": "R47",
+					"x": 15,
+					"y": 4
+				},
+				{
+					"label": "L50",
+					"x": 0,
+					"y": 5
+				},
+				{
+					"label": "L51",
+					"x": 1,
+					"y": 5
+				},
+				{
+					"label": "L52",
+					"x": 2,
+					"y": 5
+				},
+				{
+					"label": "L53",
+					"x": 3,
+					"y": 5
+				},
+				{
+					"label": "L54",
+					"x": 4,
+					"y": 5
+				},
+				{
+					"label": "L55",
+					"x": 5,
+					"y": 5
+				},
+				{
+					"label": "L56",
+					"x": 6,
+					"y": 5
+				},
+				{
+					"label": "L57",
+					"x": 7,
+					"y": 5
+				},
+				{
+					"label": "R50",
+					"x": 8,
+					"y": 5
+				},
+				{
+					"label": "R51",
+					"x": 9,
+					"y": 5
+				},
+				{
+					"label": "R52",
+					"x": 10,
+					"y": 5
+				},
+				{
+					"label": "R53",
+					"x": 11,
+					"y": 5
+				},
+				{
+					"label": "R54",
+					"x": 12,
+					"y": 5
+				},
+				{
+					"label": "R55",
+					"x": 13,
+					"y": 5
+				},
+				{
+					"label": "R56",
+					"x": 14,
+					"y": 5
+				},
+				{
+					"label": "R57",
+					"x": 15,
+					"y": 5
+				}
+			]
+		}
+	}
+}

keyboards/adkb96/keymaps/default/config.h

@@ -0,0 +1,34 @@
+/*
+This is the c configuration file for the keymap
+
+Copyright 2012 Jun Wako <wakojun@gmail.com>
+Copyright 2015 Jack Humbert
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+/* Use I2C or Serial, not both */
+
+#define USE_SERIAL
+//#define USE_I2C
+
+/* Select hand configuration */
+
+#define MASTER_LEFT
+// #define MASTER_RIGHT
+// #define EE_HANDS
+
+#define FORCE_NKRO

keyboards/adkb96/keymaps/default/keymap.c

@@ -0,0 +1,15 @@
+#include QMK_KEYBOARD_H
+
+extern keymap_config_t keymap_config;
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+  [0] = LAYOUT( 
+	KC_ESC,	XXXXXXX,KC_F1,	KC_F2,	KC_F3,	KC_F4,	KC_F5,	KC_F6,	KC_F7,	KC_F8,	KC_F9,	KC_F10,	KC_F11,	KC_F12,	KC_INS,	KC_DELT,
+	KC_ZKHK,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_JYEN,KC_BSPC,KC_BSPC,
+	KC_TAB,	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_ENT,	KC_ENT,
+	KC_CAPS,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_BSLS,KC_ENT,	KC_ENT,
+	KC_LSFT,KC_LSFT,KC_Z,	KC_X,	KC_C,	KC_V,	KC_B,	KC_N,	KC_M,	KC_COMM,KC_DOT,	KC_SLSH,KC_RO,	KC_UP,	KC_RSFT,KC_RSFT, 
+	KC_LCTL,KC_LALT,KC_LGUI,KC_MHEN,KC_SPC,	KC_SPC,	KC_SPC,	KC_SPC,	KC_HENK,KC_KANA,KC_RALT,KC_RCTL,KC_LEFT,KC_DOWN,KC_RGHT,XXXXXXX
+  )
+};

keyboards/adkb96/readme.md

@@ -0,0 +1,17 @@
+# ADKB96
+
+![ADKB96](http://btoshop.jp/wp-content/uploads/sites/3/2019/04/ADKB96_ALL.png)  
+
+A 16x6 ortholinear keyboard kit made and sold by Bit Trade One Ltd. [More info on Web](http://bit-trade-one.co.jp/selfmadekb/adkb96/)  
+
+Keyboard Maintainer: [Bit Trade One Ltd.](http://bit-trade-one.co.jp/)  
+Hardware Supported: ADKB96 PCB, Pro Micro  
+Hardware Availability: [PCB & case Data](https://github.com/bit-trade-one/ADKB96-hardware), [BTOS Shop](http://btoshop.jp/2019/04/11/4562469772424/)  
+
+Make example for this keyboard (after setting up your build environment):  
+
+```sh
+  make adkb96/rev1: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/adkb96/rev1/config.h

@@ -0,0 +1,78 @@
+/*
+Copyright 2012 Jun Wako <wakojun@gmail.com>
+Copyright 2015 Jack Humbert
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0x00a5
+#define PRODUCT_ID      0xad96
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    Bit Trade One
+#define PRODUCT         ADKB96
+#define DESCRIPTION     
+
+/* key matrix size */
+// Rows are doubled-up
+#define MATRIX_ROWS 12
+#define MATRIX_COLS 8
+
+// wiring of each half
+#define MATRIX_ROW_PINS { D4, C6, D7, E6, B4, B5 }
+#define MATRIX_COL_PINS { B6, B2, B3, B1, F7, F6, F5, F4 }
+
+#define SOFT_SERIAL_PIN D0
+
+/* define tapping term */
+#define TAPPING_TERM 100
+
+/* define if matrix has ghost */
+//#define MATRIX_HAS_GHOST
+
+/* number of backlight levels */
+// #define BACKLIGHT_LEVELS 3
+
+/* Set 0 if debouncing isn't 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
+
+/* ws2812 RGB LED */
+/*
+#define RGB_DI_PIN D3
+
+#define RGBLED_NUM 12    // Number of LEDs
+*/
+/*
+ * 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
+

keyboards/adkb96/rev1/rev1.c

@@ -0,0 +1,15 @@
+#include "adkb96.h"
+
+void matrix_init_kb(void) {
+
+    // // green led on
+    // DDRD |= (1<<5);
+    // PORTD &= ~(1<<5);
+
+    // // orange led on
+    // DDRB |= (1<<0);
+    // PORTB &= ~(1<<0);
+
+	matrix_init_user();
+};
+

keyboards/adkb96/rev1/rev1.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "adkb96.h"
+
+//void promicro_bootloader_jmp(bool program);
+
+#ifdef USE_I2C
+#include <stddef.h>
+#ifdef __AVR__
+	#include <avr/io.h>
+	#include <avr/interrupt.h>
+#endif
+#endif
+
+//void promicro_bootloader_jmp(bool program);
+
+
+// Keymap with right side flipped
+// (TRRS jack on both halves are to the right)
+#define LAYOUT_ortho_6x16( \
+	L00, L01, L02, L03, L04, L05, L06, L07, R00, R01, R02, R03, R04, R05, R06, R07, \
+	L10, L11, L12, L13, L14, L15, L16, L17, R10, R11, R12, R13, R14, R15, R16, R17, \
+	L20, L21, L22, L23, L24, L25, L26, L27, R20, R21, R22, R23, R24, R25, R26, R27, \
+	L30, L31, L32, L33, L34, L35, L36, L37, R30, R31, R32, R33, R34, R35, R36, R37, \
+	L40, L41, L42, L43, L44, L45, L46, L47, R40, R41, R42, R43, R44, R45, R46, R47, \
+	L50, L51, L52, L53, L54, L55, L56, L57, R50, R51, R52, R53, R54, R55, R56, R57 \
+	) \
+	{ \
+		{ L00, L01, L02, L03, L04, L05, L06, L07 }, \
+		{ L10, L11, L12, L13, L14, L15, L16, L17 }, \
+		{ L20, L21, L22, L23, L24, L25, L26, L27 }, \
+		{ L30, L31, L32, L33, L34, L35, L36, L37 }, \
+		{ L40, L41, L42, L43, L44, L45, L46, L47 }, \
+		{ L50, L51, L52, L53, L54, L55, L56, L57 }, \
+		{ R00, R01, R02, R03, R04, R05, R06, R07 }, \
+		{ R10, R11, R12, R13, R14, R15, R16, R17 }, \
+		{ R20, R21, R22, R23, R24, R25, R26, R27 }, \
+		{ R30, R31, R32, R33, R34, R35, R36, R37 }, \
+		{ R40, R41, R42, R43, R44, R45, R46, R47 }, \
+		{ R50, R51, R52, R53, R54, R55, R56, R57 } \
+	}
+
+#define LAYOUT LAYOUT_ortho_6x16
+

keyboards/adkb96/rules.mk

@@ -1,5 +1,3 @@
-
-
 # MCU name
 #MCU = at90usb1287
 MCU = atmega32u4
@@ -36,41 +34,45 @@ ARCH = AVR8
 #     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
 F_USB = $(F_CPU)
 
-# Bootloader
-#     This definition is optional, and if your keyboard supports multiple bootloaders of
-#     different sizes, comment this out, and the correct address will be loaded 
-#     automatically (+60). See bootloader.mk for all options.
-ifeq ($(strip $(KEYBOARD)), preonic/rev1)
-    BOOTLOADER = atmel-dfu
-endif
-ifeq ($(strip $(KEYBOARD)), preonic/rev2)
-    BOOTLOADER = qmk-dfu
-endif
-
 # 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
+
+# Boot Section Size in *bytes*
+#   Teensy halfKay   512
+#   Teensy++ halfKay 1024
+#   Atmel DFU loader 4096
+#   LUFA bootloader  4096
+#   USBaspLoader     2048
+# OPT_DEFS += -DBOOTLOADER_SIZE=4096
+
 # Build Options
-#   change to "no" to disable the options, or define them in the Makefile in 
+#   change to "no" to disable the options, or define them in the Makefile in
 #   the appropriate keymap folder that will get included automatically
 #
 BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration(+1000)
 MOUSEKEY_ENABLE = no       # Mouse keys(+4700)
 EXTRAKEY_ENABLE = yes       # Audio control and System control(+450)
-CONSOLE_ENABLE = yes         # Console for debug(+400)
-COMMAND_ENABLE = no        # Commands for debug and configuration
-NKRO_ENABLE = no            # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
-BACKLIGHT_ENABLE = yes      # Enable keyboard backlight functionality
+CONSOLE_ENABLE = no         # Console for debug(+400)
+COMMAND_ENABLE = yes        # Commands for debug and configuration
+NKRO_ENABLE = yes            # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+BACKLIGHT_ENABLE = no      # Enable keyboard backlight functionality
 MIDI_ENABLE = no            # MIDI controls
-AUDIO_ENABLE = yes           # Audio output on port C6
+AUDIO_ENABLE = no           # Audio output on port C6
 UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
-RGBLIGHT_ENABLE = no        # Enable WS2812 RGB underlight.
-API_SYSEX_ENABLE = no
-
+RGBLIGHT_ENABLE = no       # Enable WS2812 RGB underlight. 
 # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
 SLEEP_LED_ENABLE = no    # Breathing sleep LED during USB suspend
 
-LAYOUTS = ortho_5x12
+SPLIT_KEYBOARD = yes
 
-DEFAULT_FOLDER = preonic/rev2
+DEFAULT_FOLDER = adkb96/rev1

keyboards/alpha/keymaps/default/keymap.c

@@ -6,7 +6,7 @@
 #define OTHER 3
 
 enum custom_keycodes {
-	MACRO1
+	MACRO1 = SAFE_RANGE
 };
 
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {

keyboards/atreus/readme.md

@@ -1,21 +1,24 @@
 Atreus
-===
+======
 
 A small mechanical keyboard that is based around the shape of the human hand.
 
-These configuration files are specifically for the Atreus keyboards created by Phil Hagelberg (@technomancy). This keyboard is available in two variants: one powered by a Teensy 2, (usually hand-wired) one powered by an A-Star. (usually using a PCB) This repository currently assumes that you have an A-Star powered Atreus. If you are using a Teensy2, specify that by adding `TEENSY2=yes` to your `make` commands.
-
 Keyboard Maintainer: [Phil Hagelberg](https://github.com/technomancy)  
 Hardware Supported: Atreus, PCB-based or hand-wired  
 Hardware Availability: https://atreus.technomancy.us
 
-Make example for this keyboard (after setting up your build environment):
+These configuration files are specifically for the Atreus keyboards created by Phil Hagelberg (@technomancy). This keyboard is available in two variants: one powered by a Teensy 2 (usually hand-wired), one powered by an A-Star (usually using a PCB). You will need to use different `make` commands depending on the variant you have; see examples below.
 
-    make atreus:default:avrdude
+A-Star:\
+`make atreus:default:avrdude`
 
-Unlike the TMK firmware, this command should be run from the root of
-the repository, not the directory containing this readme.
+Teensy:\
+`make TEENSY2=yes atreus:default:teensy`
+ 
+If your keyboard layout is a mirror image of what you expected (i.e. you do not get QWERTY on the left but YTREWQ on the right), then you have an A-Star powered Atreus (older than March 2016) with PCB labels facing *down* instead of up. Specify that by adding `PCBDOWN=yes` to your `make` commands, e.g.
 
-If your keyboard layout is a mirror image of what you expected (i.e. you do not get QWERTY on the left but YTREWQ on the right), then you have an A-Star powered Atreus (older than March 2016) with PCB labels facing *down* instead of up. Specify that by adding `PCBDOWN=yes` to your `make` commands.
+`make PCBDOWN=yes atreus:default:avrdude`
 
-See [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) then the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information.
+*Unlike the TMK firmware, these commands should be run from the root of the repository, not the directory containing this readme.*
+
+See [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools), then the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information.

keyboards/atreus/rules.mk

@@ -1,19 +1,4 @@
-
-
-ifdef TEENSY2
-    OPT_DEFS += -DATREUS_TEENSY2
-    ATREUS_UPLOAD_COMMAND = teensy_loader_cli -w -mmcu=$(MCU) $(TARGET).hex
-else
-    OPT_DEFS += -DATREUS_ASTAR
-ifdef PCBDOWN
-    OPT_DEFS += -DPCBDOWN
-endif
-    ATREUS_UPLOAD_COMMAND = while [ ! -r $(USB) ]; do sleep 1; done; \
-                            avrdude -p $(MCU) -c avr109 -U flash:w:$(TARGET).hex -P $(USB)
-endif
-
 # MCU name
-#MCU = at90usb1287
 MCU = atmega32u4
 
 # Processor frequency.
@@ -48,34 +33,56 @@ ARCH = AVR8
 #     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
 F_USB = $(F_CPU)
 
-# Bootloader
-#     This definition is optional, and if your keyboard supports multiple bootloaders of
-#     different sizes, comment this out, and the correct address will be loaded 
-#     automatically (+60). See bootloader.mk for all options.
-ifdef TEENSY2
-    BOOTLOADER = halfkay
-else
-    BOOTLOADER = caterina
-endif
-
 # Interrupt driven control endpoint task(+60)
 OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
 
 
-# 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 = yes	# Console for debug(+400)
-COMMAND_ENABLE = yes    # Commands for debug and configuration
-# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
-# SLEEP_LED_ENABLE = yes  # Breathing sleep LED during USB suspend
-NKRO_ENABLE = yes		# USB Nkey Rollover - not yet supported in LUFA
-# BACKLIGHT_ENABLE = yes  # Enable keyboard backlight functionality
-# MIDI_ENABLE = YES 		# MIDI controls
-UNICODE_ENABLE = YES 		# Unicode
-# BLUETOOTH_ENABLE = yes # Enable Bluetooth with the Adafruit EZ-Key HID
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   atmega32a    bootloadHID
+ifdef TEENSY2
+    BOOTLOADER = halfkay
+    OPT_DEFS += -DATREUS_TEENSY2
+else
+    BOOTLOADER = caterina
+    OPT_DEFS += -DATREUS_ASTAR
+    ifdef PCBDOWN
+        OPT_DEFS += -DPCBDOWN
+    endif
+endif
 
-USB = /dev/cu.usbmodem1411
+
+# 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 = yes        # Console for debug(+400)
+COMMAND_ENABLE = yes        # Commands for debug and configuration
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend
+# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+NKRO_ENABLE = yes            # USB Nkey Rollover
+BACKLIGHT_ENABLE = no       # 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 = yes         # 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)

keyboards/baguette/info.json

@@ -123,7 +123,7 @@
         {"label":";", "x":10.75, "y":2},
         {"label":"'", "x":11.75, "y":2},
         {"label":"ISO #", "x":12.75, "y":2},
-        {"label":"Enter", "x":13.75, "y":2, "w":1.25, "h":2},
+        {"label":"Enter", "x":13.75, "y":1, "w":1.25, "h":2},
         {"label":"Shift", "x":0, "y":3, "w":1.25},
         {"label":"ISO \\", "x":1.25, "y":3},
         {"label":"Z", "x":2.25, "y":3},

keyboards/baguette/readme.md

@@ -6,7 +6,7 @@ Baguette
 This is a custom keyboard with backlight inspired by France.
 
 Keyboard Maintainer: [Yiancar](http://yiancar-designs.com/) and on [github](https://github.com/yiancar)  
-Hardware Supported: ATMEGA 32u4 MCU with backlight support.
+Hardware Supported: ATMEGA 32u4 MCU with backlight support.  
 Hardware Availability: Closed group-buy please contact the runners (Tesletron and Enjoy)
 
 Make example for this keyboard (after setting up your build environment):

keyboards/bm16s/bm16s.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "quantum.h"
+
+#define LAYOUT_ortho_4x4( \
+	K00, K01, K02, K03, \
+	K10, K11, K12, K13, \
+	K20, K21, K22, K23, \
+	K30, K31, K32, K33  \
+) { \
+	{ K00,   K01,   K02,   K03 }, \
+	{ K10,   K11,   K12,   K13 }, \
+	{ K20,   K21,   K22,   K23 }, \
+	{ K30,   K31,   K32,   K33 }  \
+}

keyboards/bm16s/config.h

@@ -0,0 +1,46 @@
+#pragma once
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x6060
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    KPrepublic
+#define PRODUCT         bm16s
+#define DESCRIPTION     KPrepublic bm16s
+
+/* key matrix size */
+#define MATRIX_ROWS 4
+#define MATRIX_COLS 4
+
+/* key matrix pins */
+#define MATRIX_ROW_PINS { D1, D0, D3, D2 }
+#define MATRIX_COL_PINS { F7, F6, D4, D6 }
+#define UNUSED_PINS
+
+/* COL2ROW or ROW2COL */
+#define DIODE_DIRECTION COL2ROW
+
+/* number of backlight levels */
+
+#ifdef BACKLIGHT_PIN
+    #define BACKLIGHT_LEVELS 3
+#endif
+
+/* Set 0 if debouncing isn't 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
+
+#define RGB_DI_PIN E2
+#ifdef RGB_DI_PIN
+    #define RGBLIGHT_ANIMATIONS
+    #define RGBLED_NUM 16
+    #define RGBLIGHT_HUE_STEP 8
+    #define RGBLIGHT_SAT_STEP 8
+    #define RGBLIGHT_VAL_STEP 8
+#endif

keyboards/bm16s/info.json

@@ -0,0 +1,30 @@
+{
+    "keyboard_name": "bm16s",
+    "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/bm16s/keymaps/default/keymap.c

@@ -0,0 +1,16 @@
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+	[0] = LAYOUT_ortho_4x4(
+		KC_KP_7, KC_KP_8, KC_KP_9, MO(1),   \
+		KC_KP_4, KC_KP_5, KC_KP_6, KC_PMNS, \
+		KC_KP_1, KC_KP_2, KC_KP_3, KC_PPLS, \
+		KC_KP_0, KC_PDOT, KC_PCMM, KC_PENT  \
+	),
+	[1] = LAYOUT_ortho_4x4(
+		RESET,   BL_STEP, _______, KC_VOLU, \
+		BL_TOGG, BL_DEC,  BL_INC,  KC_VOLD, \
+		RGB_TOG, RGB_MOD, RGB_HUI, KC_MUTE, \
+		RGB_SAI, RGB_SAD, RGB_HUD, _______  \
+	),
+};

keyboards/bm16s/keymaps/media/keymap.c

@@ -0,0 +1,20 @@
+#include QMK_KEYBOARD_H
+
+#define RGB_BRU RGB_VAI
+#define RGB_BRD RGB_VAD
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+	[0] = LAYOUT_ortho_4x4(
+		KC_BRIU, _______, _______, KC_VOLU, \
+		KC_BRID, _______, _______, KC_VOLD, \
+		_______, _______, _______, KC_MUTE, \
+		KC_MPRV, KC_MPLY, KC_MNXT, MO(1)    \
+	),
+	[1] = LAYOUT_ortho_4x4(
+		RESET,    _______, _______, _______, \
+		RGB_SPD,  RGB_BRU, RGB_SPI, _______, \
+		RGB_RMOD, RGB_BRD, RGB_MOD, _______, \
+		RGB_TOG,  _______, _______, _______  \
+	),
+};

keyboards/bm16s/readme.md

@@ -0,0 +1,13 @@
+# bm16s
+
+A 16-key macropad, with USB C and per-key RGB backlighting. This is a variant of the BM16A, but with low profile Choc switches.
+
+Keyboard Maintainer: QMK Community  
+Hardware Supported: The PCBs, controllers supported  
+Hardware Availability: [KPrepublic](https://kprepublic.com/collections/pcb/products/bm16s-16-keys-custom-mechanical-keyboard-pcb-plate-programmed-numpad-layouts-qmk-firmware-with-rgb-switch-leds-choc-switch); [AliExpress](https://www.aliexpress.com/item/bm16s-16-keys-Custom-Mechanical-Keyboard-PCB-plate-programmed-numpad-layouts-qmk-firmware-with-rgb-switch/32999247908.html); [Massdrop](https://www.massdrop.com/buy/78169)
+
+Make example for this keyboard (after setting up your build environment):
+
+    make bm16s: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/bm16s/rules.mk

@@ -0,0 +1,72 @@
+# 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
+#   comment out to disable the options.
+#
+BOOTMAGIC_ENABLE = lite # Virtual DIP switch configuration
+MOUSEKEY_ENABLE  = yes  # Mouse keys
+EXTRAKEY_ENABLE  = yes  # Audio control and System control
+CONSOLE_ENABLE   = no   # Console for debug
+COMMAND_ENABLE   = no   # Commands for debug and configuration
+SLEEP_LED_ENABLE = no   # Breathing sleep LED during USB suspend
+NKRO_ENABLE      = yes  # USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+BACKLIGHT_ENABLE = no   # Enable keyboard backlight functionality
+AUDIO_ENABLE     = no
+RGBLIGHT_ENABLE  = yes
+
+LAYOUTS = ortho_4x4

keyboards/boston_meetup/2019/2019.c

@@ -0,0 +1,217 @@
+/* Copyright 2019 ishtob
+ *
+ * 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 "2019.h"
+#include "qwiic.h"
+#include "action_layer.h"
+#include "haptic.h"
+
+#ifdef RGB_MATRIX_ENABLE
+#include "rgblight.h"
+
+rgb_led g_rgb_leds[DRIVER_LED_TOTAL] = {
+  /*{row | col << 4}
+    |             {x=0..224, y=0..64}
+    |              |         modifier
+    |              |         | */
+  {{1|(3<<4)},    {188, 16}, 4},
+  {{3|(3<<4)},    {187, 48}, 4},
+  {{4|(2<<4)},    {149, 64}, 4},
+  {{4|(1<<4)},    {112, 64}, 4},
+  {{3|(0<<4)},    {37,  48}, 4},
+  {{1|(0<<4)},    {38, 16}, 4}
+};
+#endif
+
+uint8_t *o_fb;
+
+uint16_t counterst = 0;
+
+
+
+#ifdef QWIIC_MICRO_OLED_ENABLE
+
+/* screen off after this many milliseconds */
+#include "timer.h"
+#define ScreenOffInterval 60000 /* milliseconds */
+static uint16_t last_flush;
+
+volatile uint8_t led_numlock = false; 
+volatile uint8_t  led_capslock = false; 
+volatile uint8_t  led_scrolllock = false;
+
+static uint8_t layer;
+static bool queue_for_send = false; 
+static uint8_t encoder_value = 32;
+
+__attribute__ ((weak))
+void draw_ui(void) {
+  clear_buffer();
+  last_flush = timer_read();
+  send_command(DISPLAYON);
+
+/* Boston MK title is 55 x 10 pixels */
+#define NAME_X 0
+#define NAME_Y 0 
+
+  draw_string(NAME_X + 1, NAME_Y + 2, "BOSTON MK", PIXEL_ON, NORM, 0);
+
+/* Layer indicator is 41 x 10 pixels */
+#define LAYER_INDICATOR_X 60
+#define LAYER_INDICATOR_Y 0 
+
+  draw_string(LAYER_INDICATOR_X + 1, LAYER_INDICATOR_Y + 2, "LAYER", PIXEL_ON, NORM, 0);
+  draw_rect_filled_soft(LAYER_INDICATOR_X + 32, LAYER_INDICATOR_Y + 1, 9, 9, PIXEL_ON, NORM);
+  draw_char(LAYER_INDICATOR_X + 34, LAYER_INDICATOR_Y + 2, layer + 0x30, PIXEL_ON, XOR, 0);
+
+/* Matrix display is 12 x 12 pixels */
+#define MATRIX_DISPLAY_X 8
+#define MATRIX_DISPLAY_Y 16
+
+  for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
+    for (uint8_t y = 0; y < MATRIX_COLS; y++) {
+      draw_pixel(MATRIX_DISPLAY_X + y + y + 2, MATRIX_DISPLAY_Y + x + x + 2,(matrix_get_row(x) & (1 << y)) > 0, NORM);
+      draw_pixel(MATRIX_DISPLAY_X + y + y + 3, MATRIX_DISPLAY_Y + x + x + 2,(matrix_get_row(x) & (1 << y)) > 0, NORM);
+      draw_pixel(MATRIX_DISPLAY_X + y + y + 2, MATRIX_DISPLAY_Y + x + x + 3,(matrix_get_row(x) & (1 << y)) > 0, NORM);
+      draw_pixel(MATRIX_DISPLAY_X + y + y + 3, MATRIX_DISPLAY_Y + x + x + 3,(matrix_get_row(x) & (1 << y)) > 0, NORM);
+
+    }
+  } 
+  draw_rect_soft(MATRIX_DISPLAY_X, MATRIX_DISPLAY_Y, 12, 12, PIXEL_ON, NORM);
+  /* hadron oled location on thumbnail */
+  draw_rect_filled_soft(MATRIX_DISPLAY_X + 5, MATRIX_DISPLAY_Y + 2, 6, 2, PIXEL_ON, NORM);
+/*
+  draw_rect_soft(0, 13, 64, 6, PIXEL_ON, NORM);
+  draw_line_vert(encoder_value, 13, 6, PIXEL_ON, NORM);
+
+*/
+
+/* Mod display is 41 x 16 pixels */
+#define MOD_DISPLAY_X 60
+#define MOD_DISPLAY_Y 20
+
+  uint8_t mods = get_mods();
+  if (mods & MOD_LSFT) {
+    draw_rect_filled_soft(MOD_DISPLAY_X + 0, MOD_DISPLAY_Y, 5 + (1 * 6), 11, PIXEL_ON, NORM);
+    draw_string(MOD_DISPLAY_X + 3, MOD_DISPLAY_Y + 2, "S", PIXEL_OFF, NORM, 0);
+  } else {
+    draw_string(MOD_DISPLAY_X + 3, MOD_DISPLAY_Y + 2, "S", PIXEL_ON, NORM, 0);
+  }
+  if (mods & MOD_LCTL) {
+    draw_rect_filled_soft(MOD_DISPLAY_X + 10, MOD_DISPLAY_Y, 5 + (1 * 6), 11, PIXEL_ON, NORM);
+    draw_string(MOD_DISPLAY_X + 13, MOD_DISPLAY_Y + 2, "C", PIXEL_OFF, NORM, 0);
+  } else {
+    draw_string(MOD_DISPLAY_X + 13, MOD_DISPLAY_Y + 2, "C", PIXEL_ON, NORM, 0);
+  }
+  if (mods & MOD_LALT) {
+    draw_rect_filled_soft(MOD_DISPLAY_X + 20, MOD_DISPLAY_Y, 5 + (1 * 6), 11, PIXEL_ON, NORM);
+    draw_string(MOD_DISPLAY_X + 23, MOD_DISPLAY_Y + 2, "A", PIXEL_OFF, NORM, 0);
+  } else {
+    draw_string(MOD_DISPLAY_X + 23, MOD_DISPLAY_Y + 2, "A", PIXEL_ON, NORM, 0);
+  }
+  if (mods & MOD_LGUI) {
+    draw_rect_filled_soft(MOD_DISPLAY_X + 30, MOD_DISPLAY_Y, 5 + (1 * 6), 11, PIXEL_ON, NORM);
+    draw_string(MOD_DISPLAY_X + 33, MOD_DISPLAY_Y + 2, "G", PIXEL_OFF, NORM, 0);
+  } else {
+    draw_string(MOD_DISPLAY_X + 33, MOD_DISPLAY_Y + 2, "G", PIXEL_ON, NORM, 0);
+  }
+
+/* Lock display is 23 x 32 */
+#define LOCK_DISPLAY_X 104
+#define LOCK_DISPLAY_Y 0
+
+  if (led_numlock == true) {
+    draw_rect_filled_soft(LOCK_DISPLAY_X, LOCK_DISPLAY_Y, 5 + (3 * 6), 9, PIXEL_ON, NORM);
+    draw_string(LOCK_DISPLAY_X + 3, LOCK_DISPLAY_Y + 1, "NUM", PIXEL_OFF, NORM, 0);
+  } else if (led_numlock == false) {
+    draw_string(LOCK_DISPLAY_X + 3, LOCK_DISPLAY_Y + 1, "NUM", PIXEL_ON, NORM, 0);
+  }
+  if (led_capslock == true) {
+    draw_rect_filled_soft(LOCK_DISPLAY_X + 0, LOCK_DISPLAY_Y + 11, 5 + (3 * 6), 9, PIXEL_ON, NORM);
+    draw_string(LOCK_DISPLAY_X + 3, LOCK_DISPLAY_Y + 11 +1, "CAP", PIXEL_OFF, NORM, 0);
+  } else if (led_capslock == false) {
+    draw_string(LOCK_DISPLAY_X + 3, LOCK_DISPLAY_Y + 11 +1, "CAP", PIXEL_ON, NORM, 0);
+  }
+
+  if (led_scrolllock == true) {
+    draw_rect_filled_soft(LOCK_DISPLAY_X + 0, LOCK_DISPLAY_Y + 22, 5 + (3 * 6), 9, PIXEL_ON, NORM);
+    draw_string(LOCK_DISPLAY_X + 3, LOCK_DISPLAY_Y + 22 +1, "SCR", PIXEL_OFF, NORM, 0);
+  } else if (led_scrolllock == false) {
+    draw_string(LOCK_DISPLAY_X + 3, LOCK_DISPLAY_Y + 22 +1, "SCR", PIXEL_ON, NORM, 0);
+  }
+  send_buffer();
+}
+
+void led_set_user(uint8_t usb_led) {
+    if (IS_LED_ON(usb_led, USB_LED_NUM_LOCK)) {
+      if (led_numlock == false){led_numlock = true;}
+    } else {
+      if (led_numlock == true){led_numlock = false;}
+    }
+    if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK)) {
+      if (led_capslock == false){led_capslock = true;}
+    } else {
+      if (led_capslock == true){led_capslock = false;}
+    }
+    if (IS_LED_ON(usb_led, USB_LED_SCROLL_LOCK)) {
+      if (led_scrolllock == false){led_scrolllock = true;}
+    } else {
+      if (led_scrolllock == true){led_scrolllock = false;}
+    }
+}
+
+uint32_t layer_state_set_kb(uint32_t state) {
+  state = layer_state_set_user(state);
+  layer = biton32(state);
+  queue_for_send = true;
+  return state;
+}
+
+bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
+  queue_for_send = true;
+  return process_record_user(keycode, record);
+}
+
+void encoder_update_kb(uint8_t index, bool clockwise) {
+  encoder_value = (encoder_value + (clockwise ? 1 : -1)) % 64;
+  queue_for_send = true;
+}
+
+#endif
+
+void matrix_init_kb(void) {
+  queue_for_send = true;
+	matrix_init_user();
+}
+            
+void matrix_scan_kb(void) {
+if (queue_for_send) {
+#ifdef QWIIC_MICRO_OLED_ENABLE
+   draw_ui();
+#endif
+   queue_for_send = false;
+  }
+#ifdef QWIIC_MICRO_OLED_ENABLE
+  if (timer_elapsed(last_flush) > ScreenOffInterval) {
+  send_command(DISPLAYOFF);      /* 0xAE */
+  }
+#endif
+  if (counterst == 0) {
+    //testPatternFB(o_fb);
+  }
+  counterst = (counterst + 1) % 1024;
+  //rgblight_task();
+	matrix_scan_user();
+}

keyboards/boston_meetup/2019/2019.h

@@ -0,0 +1,19 @@
+/* Copyright 2019 ishtob
+ *
+ * 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 "boston_meetup.h"
+

keyboards/boston_meetup/2019/config.h

@@ -0,0 +1,196 @@
+#pragma once
+
+/* USB Device descriptor parameter */
+#define DEVICE_VER 0x07E3
+
+#undef MATRIX_ROWS
+#undef MATRIX_COLS
+/* 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)
+ *
+*/
+
+#undef MATRIX_ROW_PINS
+#undef MATRIX_COL_PINS
+
+#define MATRIX_ROW_PINS { A3, B8, B9, B1 }
+#define MATRIX_COL_PINS { A7, A8, B2, B10 }
+
+#define NUMBER_OF_ENCODERS 1
+#define ENCODERS_PAD_A { B13 }
+#define ENCODERS_PAD_B { B14 }
+
+//Audio
+#undef AUDIO_VOICES
+#undef C6_AUDIO
+
+#ifdef AUDIO_ENABLE
+    #define STARTUP_SONG SONG(ONE_UP_SOUND)
+    // #define STARTUP_SONG SONG(NO_SOUND)
+
+#define AUDIO_CLICKY
+  /* to enable clicky on startup */
+  //#define AUDIO_CLICKY_ON
+#define AUDIO_CLICKY_FREQ_RANDOMNESS 1.5f
+#endif
+
+//configure qwiic micro_oled driver for the 128x32 oled
+#ifdef QWIIC_MICRO_OLED_ENABLE
+
+#undef I2C_ADDRESS_SA0_1
+#define I2C_ADDRESS_SA0_1 0b0111100
+#define LCDWIDTH      128
+#define LCDHEIGHT     32
+#define micro_oled_rotate_180
+
+#endif
+/*
+ * 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)
+ *
+*/
+
+/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
+#define DEBOUNCE 6
+
+/* 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
+
+/*
+ * 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
+
+/*
+ * 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 2
+
+/* Haptic Driver initialization settings
+ * Feedback Control Settings */
+#define FB_ERM_LRA 1 /* For ERM:0 or LRA:1*/
+#define FB_BRAKEFACTOR 6 /* For 1x:0, 2x:1, 3x:2, 4x:3, 6x:4, 8x:5, 16x:6, Disable Braking:7 */
+#define FB_LOOPGAIN 1 /* For  Low:0, Medium:1, High:2, Very High:3 */
+
+/* default 3V ERM vibration motor voltage and library*/
+#if FB_ERM_LRA == 0 
+#define RATED_VOLTAGE 3
+#define V_RMS 2.3
+#define V_PEAK 3.30
+/* Library Selection */
+#define LIB_SELECTION 4 /* For Empty:0' TS2200 library A to D:1-5, LRA Library: 6 */
+
+/* default 2V LRA voltage and library */
+#elif FB_ERM_LRA == 1
+#define RATED_VOLTAGE 2
+#define V_RMS 2.0
+#define V_PEAK 2.85
+#define F_LRA 200
+/* Library Selection */
+#define LIB_SELECTION 6 /* For Empty:0' TS2200 library A to D:1-5, LRA Library: 6 */
+
+#endif
+
+/* Control 1 register settings */
+#define DRIVE_TIME 25
+#define AC_COUPLE 0
+#define STARTUP_BOOST 1
+
+/* Control 2 Settings */
+#define BIDIR_INPUT 1
+#define BRAKE_STAB 1 /* Loopgain is reduced when braking is almost complete to improve stability */
+#define SAMPLE_TIME 3
+#define BLANKING_TIME 1
+#define IDISS_TIME 1
+
+/* Control 3 settings */
+#define NG_THRESH 2
+#define ERM_OPEN_LOOP 1
+#define SUPPLY_COMP_DIS 0
+#define DATA_FORMAT_RTO 0
+#define LRA_DRIVE_MODE 0
+#define N_PWM_ANALOG 0
+#define LRA_OPEN_LOOP 0
+/* Control 4 settings */
+#define ZC_DET_TIME 0
+#define AUTO_CAL_TIME 3
+
+#define RGBLIGHT_ANIMATIONS
+
+#define RGBLED_NUM 10
+#define RGB_DI_PIN B5
+#define DRIVER_LED_TOTAL RGBLED_NUM
+
+#define RGB_MATRIX_KEYPRESSES
+
+#define SOLENOID_PIN A14
+

keyboards/boston_meetup/2019/info.json

@@ -0,0 +1,12 @@
+{
+  "keyboard_name": "Boston Meetup 2019", 
+  "url": "", 
+  "maintainer": "qmk", 
+  "width": 4, 
+  "height": 4, 
+  "layouts": {
+    "LAYOUT": {
+      "key_count": 13,
+ "layout": [{"label":"K00", "x":0, "y":0}, {"label":"K10", "x":0, "y":1}, {"label":"K11", "x":1, "y":1}, {"label":"K12", "x":2, "y":1}, {"label":"K13", "x":3, "y":1}, {"label":"K20", "x":0, "y":2}, {"label":"K21", "x":1, "y":2}, {"label":"K22", "x":2, "y":2}, {"label":"K23", "x":3, "y":2}, {"label":"K30", "x":0, "y":3}, {"label":"K31", "x":1, "y":3}, {"label":"K32", "x":2, "y":3}, {"label":"K33", "x":3, "y":3}]    }
+  }
+}

keyboards/boston_meetup/2019/keymaps/default/keymap.c

@@ -0,0 +1,166 @@
+#include QMK_KEYBOARD_H
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+
+enum custom_layers {
+  _BASE,
+  _LOWER,
+  _RAISE,
+  _ADJUST
+};
+
+enum custom_keycodes {
+  BASE = SAFE_RANGE,
+  LOWER,
+  RAISE,
+  KC_DEMOMACRO
+};
+
+// Custom macros
+#define CTL_ESC     CTL_T(KC_ESC)               // Tap for Esc, hold for Ctrl
+#define CTL_TTAB    CTL_T(KC_TAB)               // Tap for Esc, hold for Ctrl
+#define CTL_ENT     CTL_T(KC_ENT)               // Tap for Enter, hold for Ctrl
+#define SFT_ENT     SFT_T(KC_ENT)               // Tap for Enter, hold for Shift
+// Requires KC_TRNS/_______ for the trigger key in the destination layer
+#define LT_MC(kc)   LT(_MOUSECURSOR, kc)        // L-ayer T-ap M-ouse C-ursor
+#define LT_RAI(kc)  LT(_RAISE, kc)              // L-ayer T-ap to Raise
+#define DEMOMACRO   KC_DEMOMACRO                // Sample for macros
+
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+/* Base
+ * ,------.
+ * | Esc  | 
+ * |------+------+-------------.
+ * |   :  |   7  |   8  |   9  | 
+ * |------+------+------+------|
+ * | RAISE|   4  |   5  |   6  | 
+ * |------+------+------+------|
+ * | LOWER|   1  |   2  |   3  |
+ * `---------------------------'
+ */
+[_BASE] = LAYOUT(
+  KC_ESC,
+  KC_COLN, KC_P7,  KC_P8,  KC_P9,
+  RAISE,   KC_P4,  KC_P5,  KC_P6,
+  LOWER,   KC_P1,  KC_P2,  KC_P3
+),
+
+/* Lower
+ * ,------.
+ * | Nmlk | 
+ * |------+------+-------------.
+ * |  :   |   /  |   *  |   -  | 
+ * |------+------+------+------|
+ * |      |      |   =  |   +  | 
+ * |------+------+------+------|
+ * |      |  0   |   .  |  ENT |
+ * `---------------------------'
+ */
+[_LOWER] = LAYOUT(
+  KC_NLCK,
+  KC_COLN,  KC_PSLS, KC_PAST, KC_PMNS,
+  _______,  XXXXXXX, KC_EQL,  KC_PPLS,
+  _______,  KC_P0,   KC_PDOT, KC_PENT
+),
+
+/* Raise
+ * ,------.
+ * | Esc  | 
+ * |------+------+-------------.
+ * |RGB TG|RGB M+|RGB M-|      |
+ * |------+------+------+------|
+ * |      |RGB H+|RGB S+|RGB V+| 
+ * |------+------+------+------|
+ * |  `   |RGB H-|RGB S-|RGB V-|
+ * `---------------------------'
+ */
+[_RAISE] = LAYOUT(
+  KC_NLCK,
+  RGB_TOG, RGB_MOD, RGB_RMOD, XXXXXXX,
+  _______, RGB_HUI, RGB_SAI,  RGB_VAI,
+  _______, RGB_HUD, RGB_SAD,  RGB_VAD
+
+),
+
+/* Adjust
+ * ,------.
+ * | DFU  | 
+ * |------+------+-------------.
+ * |HPT TG|HPT FB|HPT RS| BKSP | 
+ * |------+------+------+------|
+ * |      |HPT M+|      |      | 
+ * |------+------+------+------|
+ * |      |HPT M-|Clk TG| Del  |
+ * `---------------------------'
+ */
+[_ADJUST] = LAYOUT(
+  RESET,
+  HPT_TOG, HPT_FBK,  HPT_RST, KC_BSPC,
+  _______, HPT_MODI, XXXXXXX, XXXXXXX,
+  _______, HPT_MODD, CK_TOGG, KC_DEL
+),
+
+
+};
+
+uint32_t layer_state_set_user(uint32_t state) {
+  return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST);
+}
+
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case KC_DEMOMACRO:
+            if (record->event.pressed) {
+        // when keycode KC_DEMOMACRO is pressed
+        SEND_STRING("QMK is the best thing ever!");
+      } else {
+        // when keycode KC_DEMOMACRO is released
+      }
+      break;
+    case LOWER:
+      if (record->event.pressed) {
+          //not sure how to have keyboard check mode and set it to a variable, so my work around
+          //uses another variable that would be set to true after the first time a reactive key is pressed.
+        layer_on(_LOWER);
+      } else {
+        layer_off(_LOWER);
+      }
+      return false;
+      break;
+    case RAISE:
+      if (record->event.pressed) {
+        //not sure how to have keyboard check mode and set it to a variable, so my work around
+        //uses another variable that would be set to true after the first time a reactive key is pressed.
+        layer_on(_RAISE);
+      } else {
+        layer_off(_RAISE);
+      }
+      return false;
+      break;
+  }
+  return true;
+}
+
+bool music_mask_user(uint16_t keycode) {
+  switch (keycode) {
+    case RAISE:
+    case LOWER:
+      return false;
+    default:
+      return true;
+  }
+}
+
+void matrix_init_user(void) {
+}
+
+
+void matrix_scan_user(void) {
+}
+

keyboards/boston_meetup/2019/keymaps/default/readme.md

@@ -0,0 +1,51 @@
+# The Default Boston Meetup 2019 board Layout
+
+Keymap:
+```
+Base
+,------.
+| Esc  | 
+|------+------+-------------.
+|   :  |   7  |   8  |   9  | 
+|------+------+------+------|
+| RAISE|   4  |   5  |   6  | 
+|------+------+------+------|
+| LOWER|   1  |   2  |   3  |
+`---------------------------'
+
+Lower
+,------.
+| Nmlk | 
+|------+------+-------------.
+|  :   |   /  |   *  |   -  | 
+|------+------+------+------|
+|      |      |   =  |   +  | 
+|------+------+------+------|
+|      |   0  |   .  |  ENT |
+`---------------------------'
+
+Raise
+,------.
+| Esc  | 
+|------+------+-------------.
+|RGB TG|RGB M+|RGB M-|      |
+|------+------+------+------|
+|      |RGB H+|RGB S+|RGB V+| 
+|------+------+------+------|
+|      |RGB H-|RGB S-|RGB V-|
+`---------------------------'
+
+Adjust:
+,------.
+| DFU  | 
+|------+------+-------------.
+|HPT TG|HPT FB|HPT RS| BKSP | 
+|------+------+------+------|
+|      |HPT M+|      |      | 
+|------+------+------+------|
+|      |HPT M-|Clk TG| Del  |
+`---------------------------'
+
+```
+
+RGB still work in progress

keyboards/boston_meetup/2019/keymaps/readme.md

@@ -0,0 +1,22 @@
+# How to add your own keymap
+
+Folders can be named however you'd like (will be approved upon merging), or should follow the format with a preceding `_`:
+
+    _[ISO 3166-1 alpha-2 code*]_[layout variant]_[layout name/author]
+
+\* See full list: https://en.wikipedia.org/wiki/ISO_3166-1#Officially_assigned_code_elements
+
+and contain the following files:
+
+* `keymap.c`
+* `readme.md` *recommended*
+* `config.h` *optional*, found automatically when compiling
+* `Makefile` *optional*, found automatically when compling
+
+When adding your keymap to this list, keep it organised alphabetically (select list, edit->sort lines), and use this format:
+
+     * **folder_name** description
+
+# List of 2019 keymaps
+
+* **default** default 2019 macropad layout

keyboards/boston_meetup/2019/readme.md

@@ -0,0 +1,13 @@
+# Boston Meetup 2019 Macropad
+
+![Boston Meetup 2019](https://i.imgur.com/6LgBc4g.jpg)
+ 
+Limited-run board designed for Boston MK community meetup 2019.
+
+Keyboard Maintainer: [ishtob](https://github.com/ishtob), [QMK](https://github.com/qmk)  
+
+Make example for this keyboard (after setting up your build environment):
+
+    make boston_meetup/2019: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/boston_meetup/2019/rules.mk

@@ -0,0 +1,24 @@
+# project specific files
+
+# Cortex version
+MCU  = STM32F303
+
+# Build Options
+#   comment out to disable the options.
+#
+BACKLIGHT_ENABLE = no
+BOOTMAGIC_ENABLE = no	# Virtual DIP switch configuration
+## (Note that for BOOTMAGIC on Teensy LC you have to use a custom .ld script.)
+MOUSEKEY_ENABLE = yes	# Mouse keys
+EXTRAKEY_ENABLE = yes	# Audio control and System control
+CONSOLE_ENABLE = no	# Console for debug
+COMMAND_ENABLE = no    # Commands for debug and configuration
+#SLEEP_LED_ENABLE = yes  # Breathing sleep LED during USB suspend
+NKRO_ENABLE = yes	    # USB Nkey Rollover
+CUSTOM_MATRIX = no # Custom matrix file
+AUDIO_ENABLE = yes
+RGBLIGHT_ENABLE = no
+RGB_MATRIX_ENABLE = no #WS2812
+HAPTIC_ENABLE += DRV2605L
+QWIIC_ENABLE += MICRO_OLED
+# SERIAL_LINK_ENABLE = yes

keyboards/boston_meetup/boston_meetup.c

@@ -0,0 +1,2 @@
+#include "boston_meetup.h"
+

keyboards/boston_meetup/boston_meetup.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#ifdef KEYBOARD_boston_meetup_2019
+    #include "2019.h"
+#define LAYOUT( \
+    K00, \
+    K10, K11, K12, K13, \
+    K20, K21, K22, K23, \
+    K30, K31, K32, K33  \
+  ) \
+{ \
+  {  K00,  KC_NO, KC_NO, KC_NO  }, \
+  {  K10,  K11,   K12,   K13    }, \
+  {  K20,  K21,   K22,   K23    }, \
+  {  K30,  K31,   K32,   K33    }  \
+}
+#endif
+
+#include "quantum.h"

keyboards/boston_meetup/config.h

@@ -0,0 +1,60 @@
+/*
+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"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0xFB30
+#define PRODUCT_ID      0x26BE
+#define MANUFACTURER    ishtob
+#define PRODUCT         Boston Meetup Board
+#define DESCRIPTION     A limited-run community meetup board
+
+//#define AUDIO_VOICES
+
+//#define BACKLIGHT_PIN B7
+
+/* COL2ROW or ROW2COL */
+#define DIODE_DIRECTION COL2ROW
+
+/* define if matrix has ghost */
+//#define MATRIX_HAS_GHOST
+
+/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
+//#define LOCKING_SUPPORT_ENABLE
+/* Locking resynchronize hack */
+//#define LOCKING_RESYNC_ENABLE
+
+/*
+ * 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

keyboards/boston_meetup/readme.md

@@ -0,0 +1,14 @@
+# Boston Meetup Macropads
+
+![Boston Meetup Macropads](https://i.imgur.com/yQcBF8g.jpg)
+ 
+Limited-run boards designed for Boston MK community meetups.
+
+Keyboard Maintainer: [ishtob](https://github.com/ishtob), [QMK](https://github.com/qmk)  
+Hardware Supported: Boston Meetup PCB 2018, 2019 
+
+Make example for this keyboard (after setting up your build environment):
+
+    make boston_meetup/YYYY: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/boston_meetup/rules.mk

@@ -0,0 +1,2 @@
+
+DEFAULT_FOLDER = boston_meetup/2019

keyboards/butterstick/butterstick.c

@@ -0,0 +1,56 @@
+/* Copyright 2019 Jeremy Bernhardt
+ *
+ * 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 "butterstick.h"
+
+// Optional override functions below.
+// You can leave any or all of these undefined.
+// These are only required if you want to perform custom actions.
+
+/*
+
+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) {
+#ifdef DEBUG_MATRIX
+    for (uint8_t c = 0; c < MATRIX_COLS; c++)
+		for (uint8_t r = 0; r < MATRIX_ROWS; r++)
+		  if (matrix_is_on(r, c)) xprintf("r:%d c:%d \n", r, c);
+#endif
+
+  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/butterstick/butterstick.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "quantum.h"
+
+#define LAYOUT_butter( 										\
+    k09, k08, k07, k06, k05, k04, k03, k02, k01, k00,		\
+	k19, k18, k17, k16, k15, k14, k13, k12, k11, k10		\
+) { 														\
+	{ k00, k01, k02, k03, k04, k05, k06, k07, k08, k09},	\
+	{ k10, k11, k12, k13, k14, k15, k16, k17, k18, k19},	\
+}

keyboards/butterstick/config.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x1337
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    g Heavy Industries
+#define PRODUCT         Butter Stick
+#define DESCRIPTION     Its a stick of butter
+#define VERSION 		"Paula Deen"
+
+#define DEBOUNCING_DELAY 5
+#define FORCE_NKRO
+
+/* key matrix size */
+#define MATRIX_ROWS 2
+#define MATRIX_COLS 10
+#define MATRIX_ROW_PINS { F4, F5 }
+#define MATRIX_COL_PINS { B0, B1, B2, B3, B4, B5, B6, B7, C6, C7}
+#define UNUSED_PINS
+
+/* COL2ROW, ROW2COL*/
+#define DIODE_DIRECTION ROW2COL
+

keyboards/butterstick/keymaps/default/keymap.c

@@ -0,0 +1,183 @@
+#include QMK_KEYBOARD_H
+
+#include "sten.h"
+/* 	 	
+ *  Key names are inherited from steno machines
+ *  .-----------------------------------------------------.
+ *	| LSU | LFT | LP | LH | ST1 | RF | RP | RL | RT | RD  |
+ *  |-----------------------------------------------------|
+ *	| LSD | LK  | LW | LR | ST2 | RR | RB | RG | RS | RZ  |
+ *  '-----------------------------------------------------'
+ */
+
+// Function prefixes
+#define MEDIA 	(LSD | LK  | LW | LR)	
+#define FUNCT 	(LSD | LK  | LP | LH)	
+#define MOVE	(LSU | LFT | LP | LH)	
+#define SYMB	(RD  | RZ)	
+#define NUMA    (LW  | LR)	
+#define NUMB    (RR  | RB)	
+
+// QMK Layer Numbers
+ #define BASE 0
+ #define GAME 1
+
+// Do not change QMK Layer 0! This is your main keyboard.
+// Make your QMK modifications to the later layers, to add 
+// keys/customize on the first layer modify processQwerty():
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [BASE] = LAYOUT_butter(
+  	STN_S1,  STN_TL,  STN_PL,  STN_HL,  STN_ST1, STN_FR,  STN_PR,  STN_LR,  STN_TR,  STN_DR,
+   	STN_S2,  STN_KL,  STN_WL,  STN_RL,  STN_ST2, STN_RR,  STN_BR,  STN_GR,  STN_SR,  STN_ZR
+  ),
+  // I don't game don't roast me thanks
+  [GAME] = LAYOUT_butter(
+  	KC_Q,  KC_W,  KC_E,  KC_R,  KC_T, KC_Y, KC_U, KC_I,  KC_O, KC_ENT,
+  	KC_A,  KC_S,  KC_D,  KC_F,  KC_G, KC_H, KC_J, KC_K,  KC_L, TO(BASE)
+  )
+};
+
+// Note: You can only use basic keycodes here!
+// P() is just a wrapper to make your life easier, any C code can be executed.
+// Only the longest matched chord is run!
+//
+// http://docs.gboards.ca
+uint32_t processQwerty(bool lookup) {
+    // SECRET AGENT CHORDS
+    P( LSU | LK | RS | RD,    	SEND_STRING(VERSION); SEND_STRING(__DATE__));
+    P( LSD | RZ,   			 	SEND(KC_SPC));
+
+    // Dual chords
+    P( LP  | LH,    			CLICK_MOUSE(KC_MS_BTN2));
+    P( ST1 | RF,    			CLICK_MOUSE(KC_MS_BTN1));
+    P( LSU | LFT,               SEND(KC_ESC));
+	P( LSD | LK,				SEND(KC_LSFT));
+	P( RZ  | RS,				SEND(KC_LSFT));
+	P( ST2 | RR,				SEND(KC_SPC));
+    P( RP  | RL,    			SEND(KC_LGUI));
+    P( RT  | RD,    			SEND(KC_LCTL));
+    P( RL  | RT,    			SEND(KC_LALT));
+	P( LSU | LSD | LFT | LK,	SEND(KC_LCTL));
+	P( RS  | RT  | RD  | RZ,	SEND(KC_ENT));
+
+    // Function Layer
+    P( FUNCT | RF,         SEND(KC_F1));
+    P( FUNCT | RP,         SEND(KC_F2));
+    P( FUNCT | RL,         SEND(KC_F3));
+    P( FUNCT | RT,         SEND(KC_F4));
+    P( FUNCT | RF | RR,    SEND(KC_F5));
+    P( FUNCT | RP | RB,    SEND(KC_F6));
+    P( FUNCT | RL | RG,    SEND(KC_F7));
+    P( FUNCT | RT | RS,    SEND(KC_F8));
+    P( FUNCT | RR,         SEND(KC_F9));
+    P( FUNCT | RB,         SEND(KC_F10));
+    P( FUNCT | RG,         SEND(KC_F11));
+    P( FUNCT | RS,         SEND(KC_F12));
+
+    // Movement Layer
+    P( MOVE | RF,     SEND(KC_LEFT));
+    P( MOVE | RP,     SEND(KC_DOWN));
+    P( MOVE | RL,     SEND(KC_UP));
+    P( MOVE | RT,     SEND(KC_RIGHT));
+    P( MOVE | ST1,    SEND(KC_PGUP));
+    P( MOVE | ST2,    SEND(KC_PGDN));
+
+    // Media Layer
+    P( MEDIA | RF,    SEND(KC_MPRV));
+    P( MEDIA | RP,    SEND(KC_MPLY));
+    P( MEDIA | RL,    SEND(KC_MPLY));
+    P( MEDIA | RT,    SEND(KC_MNXT));
+    P( MEDIA | RG,	  SEND(KC_VOLU));
+    P( MEDIA | RB,    SEND(KC_VOLD));
+    P( MEDIA | RS,    SEND(KC_MUTE));
+
+    // Number Row, Right
+    P( NUMB | LSU,    SEND(KC_1));
+    P( NUMB | LFT,    SEND(KC_2));
+    P( NUMB | LP,     SEND(KC_3));
+    P( NUMB | LH,     SEND(KC_4));
+    P( NUMB | ST1,    SEND(KC_5));
+    P( NUMB | RF,     SEND(KC_6));
+    P( NUMB | RP,     SEND(KC_7));
+    P( NUMB | RL,     SEND(KC_8));
+    P( NUMB | RT,     SEND(KC_9));
+    P( NUMB | RD,     SEND(KC_0));
+
+    // Number Row, Left
+    P( NUMA | LSU,    SEND(KC_1));
+    P( NUMA | LFT,    SEND(KC_2));
+    P( NUMA | LP,     SEND(KC_3));
+    P( NUMA | LH,     SEND(KC_4));
+    P( NUMA | ST1,    SEND(KC_5));
+    P( NUMA | RF,     SEND(KC_6));
+    P( NUMA | RP,     SEND(KC_7));
+    P( NUMA | RL,     SEND(KC_8));
+    P( NUMA | RT,     SEND(KC_9));
+    P( NUMA | RD,     SEND(KC_0));
+
+
+    // Symbols and Numbers
+    P( SYMB | LP | LW,      SEND(KC_LSFT); SEND(KC_9));       // (
+    P( SYMB | LH | LR,      SEND(KC_LSFT); SEND(KC_0));       // )
+    P( SYMB | ST1 | ST2,    SEND(KC_GRV));                    // `
+    P( SYMB | RR  | RF,    	SEND(KC_LSFT); SEND(KC_3));       // #
+    P( SYMB | LFT | LK,     SEND(KC_LSFT); SEND(KC_4));       // $
+    P( SYMB | LSU,          SEND(KC_LSFT); SEND(KC_1));       // !
+    P( SYMB | LSD,          SEND(KC_LSFT); SEND(KC_5));       // %
+    P( SYMB | LFT,          SEND(KC_LSFT); SEND(KC_2));       // @
+    P( SYMB | LK,           SEND(KC_LSFT); SEND(KC_6));       // ^
+    P( SYMB | LP,           SEND(KC_LSFT); SEND(KC_LBRC));    // {
+    P( SYMB | LW,           SEND(KC_LBRC));
+    P( SYMB | LH,           SEND(KC_LSFT); SEND(KC_RBRC));    // }
+    P( SYMB | LR,           SEND(KC_RBRC));
+    P( SYMB | ST1,          SEND(KC_LSFT); SEND(KC_BSLS));    // |
+    P( SYMB | ST2,          SEND(KC_LSFT); SEND(KC_GRV));     // ~
+    P( SYMB | RP | RB,      SEND(KC_QUOT));
+    P( SYMB | RP | RG,      SEND(KC_LSFT); SEND(KC_QUOT));    // "
+    P( SYMB | RF,           SEND(KC_KP_PLUS));
+    P( SYMB | RR,           SEND(KC_LSFT); SEND(KC_7));       // &
+    P( SYMB | RP,           SEND(KC_MINS));
+    P( SYMB | RB,           SEND(KC_EQL));
+    P( SYMB | RL,           SEND(KC_SLSH));
+    P( SYMB | RG,           SEND(KC_COMM));
+    P( SYMB | RT,           SEND(KC_PAST));
+    P( SYMB | RS,           SEND(KC_DOT));
+
+    // Letters
+    P( LSU | LSD,    SEND(KC_A));
+    P( LFT | LK,     SEND(KC_S));
+    P( LP  | LW,     SEND(KC_D));
+    P( LH  | LR,     SEND(KC_F));
+    P( ST1 | ST2,    SEND(KC_G));
+    P( RF  | RR,     SEND(KC_H));
+    P( RT  | RS,     SEND(KC_L));
+    P( RD  | RZ,     SEND(KC_SCLN));
+    P( RG  | RL,     SEND(KC_K));
+    P( RP  | RB,     SEND(KC_J));
+    P( LSU,          SEND(KC_Q));
+    P( LSD,          SEND(KC_Z));
+    P( LFT,          SEND(KC_W));
+    P( LK,           SEND(KC_X));
+    P( LP,           SEND(KC_E));
+    P( LW,           SEND(KC_C));
+    P( LH,           SEND(KC_R));
+    P( LR,           SEND(KC_V));
+    P( ST1,          SEND(KC_T));
+    P( ST2,          SEND(KC_B));
+    P( RF,          SEND(KC_Y));
+    P( RR,          SEND(KC_N));
+    P( RP,           SEND(KC_U));
+    P( RB,           SEND(KC_M));
+    P( RL,           SEND(KC_I));
+    P( RG,           SEND(KC_COMM));
+    P( RT,           SEND(KC_O));
+    P( RS,           SEND(KC_DOT));
+    P( RD,           SEND(KC_P));
+    P( RZ,           SEND(KC_SLSH));
+
+    return 0;
+}
+
+
+// Don't fuck with this, thanks.
+size_t keymapsCount  = sizeof(keymaps)/sizeof(keymaps[0]);

keyboards/butterstick/readme.md

@@ -0,0 +1,14 @@
+# Butter Stick
+
+![Butter Stick](https://i.redd.it/mvteaomko7s21.jpg)
+
+A chorded 20% keyboard packing full sized useage into  your pocket. More info on [gboards.ca](http://docs.gboards.ca/Meet-Butter-Stick)!
+
+Keyboard Maintainer: [Germ](https://github.com/germ)  
+Hardware Availability: [g Heavy Industries](https://www.gboards.ca/product/butter-stick-limited-edition)
+
+Make example for this keyboard (after setting up your build environment):
+
+    make butterstick: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/butterstick/rules.mk

@@ -0,0 +1,19 @@
+# MCU name
+MCU = atmega32u4
+F_CPU = 16000000
+ARCH = AVR8
+F_USB = $(F_CPU)
+
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT -DONLYQWERTY -DDEBUG_MATRIX
+SRC += sten.c
+EXTRAFLAGS += -flto
+
+
+BOOTLOADER = atmel-dfu
+MOUSEKEY_ENABLE 	= yes		# Mouse keys(+4700)
+EXTRAKEY_ENABLE 	= yes       # Audio control and System control(+450)
+CONSOLE_ENABLE 		= yes       # Console for debug(+400)
+COMMAND_ENABLE 		= no		# Commands for debug and configuration
+NKRO_ENABLE 		= yes       # USB Nkey Rollover
+STENO_ENABLE		= yes 		# Needed for chording
+

keyboards/butterstick/sten.c

@@ -0,0 +1,367 @@
+#include "sten.h"
+
+// Chord state
+uint32_t cChord 		= 0;		// Current Chord
+int		 chordIndex 	= 0;		// Keys in previousachord
+int32_t  chordState[32];			// Full Chord history
+#define  QWERBUF		24			// Size of chords to buffer for output
+
+bool	 repeatFlag 	= false;	// Should we repeat?
+uint32_t pChord 		= 0;		// Previous Chord
+int		 pChordIndex 	= 0;		// Keys in previousachord
+uint32_t pChordState[32];			// Previous chord sate 
+uint32_t stickyBits = 0;			// Or'd with every incoming press
+
+// Mode state
+enum MODE { STENO = 0, QWERTY, COMMAND };
+enum MODE pMode;
+bool QWERSTENO = false;
+#ifdef ONLYQWERTY
+enum MODE cMode = QWERTY;
+#else
+enum MODE cMode = STENO;
+#endif
+
+// Command State
+#define MAX_CMD_BUF   20
+uint8_t	 CMDLEN 	= 0;
+uint8_t	 CMDBUF[MAX_CMD_BUF];
+
+// Key Repeat state
+bool     inChord  		= false;
+bool	 repEngaged 	= false;
+uint16_t repTimer 		= 0;
+#define  REP_INIT_DELAY 750
+#define  REP_DELAY 		25
+
+// Mousekeys state
+bool	inMouse 		= false;
+int8_t	mousePress;
+
+// All processing done at chordUp goes through here
+// Note, this is a gutted version of the Georgi sten.h
+bool send_steno_chord_user(steno_mode_t mode, uint8_t chord[6]) { 
+	// Check for mousekeys, this is release
+#ifdef MOUSEKEY_ENABLE
+	if (inMouse) {
+		inMouse = false;
+		mousekey_off(mousePress);
+		mousekey_send();
+	}
+#endif
+
+	// handle command mode
+	if (cChord == (LSU | LSD | RD | RZ)) {
+		if (cMode != COMMAND) {   // Entering Command Mode
+			CMDLEN = 0;
+			pMode = cMode;
+			cMode = COMMAND;
+		} else {                  // Exiting Command Mode
+			cMode = pMode;
+
+			// Press all and release all
+			for (int i = 0; i < CMDLEN; i++) {
+				register_code(CMDBUF[i]);
+			}
+			clear_keyboard();
+		}
+
+		goto out;
+	}
+
+	// Handle Gaming Toggle,
+	if (cChord == (LSU | LSD | LFT | LK | RT | RS | RD | RZ) && keymapsCount > 1) {
+#ifndef NO_DEBUG
+		uprintf("Switching to QMK\n");
+#endif
+		layer_on(1);
+		goto out;
+	}
+
+	// Do QWERTY and Momentary QWERTY
+	if (cMode == QWERTY || (cMode == COMMAND)) {
+		processChord(false);
+		goto out;
+	} 
+
+out:
+	cChord = 0;
+	inChord = false;
+	chordIndex = 0;
+	clear_keyboard();
+	repEngaged  = false;
+	for (int i = 0; i < 32; i++)
+		chordState[i] = 0xFFFF;
+
+	return false;
+}
+
+// Update Chord State 
+bool process_steno_user(uint16_t keycode, keyrecord_t *record) { 
+	// Everything happens in here when steno keys come in.
+	// Bail on keyup
+	if (!record->event.pressed) return true;
+
+	// Update key repeat timers
+	repTimer = timer_read();
+	inChord  = true;
+
+	// Switch on the press adding to chord
+	bool pr = record->event.pressed;
+	switch (keycode) {
+			// Mods and stuff
+			case STN_ST1:			pr ? (cChord |= (ST1)): (cChord &= ~(ST1)); break;
+			case STN_ST2:			pr ? (cChord |= (ST2)): (cChord &= ~(ST2)); break;
+			case STN_ST3:			pr ? (cChord |= (ST3)): (cChord &= ~(ST3)); break;
+			case STN_ST4:			pr ? (cChord |= (ST4)): (cChord &= ~(ST4)); break;
+			case STN_FN:			pr ? (cChord |= (FN)) : (cChord &= ~(FN)); break;
+			case STN_PWR:			pr ? (cChord |= (PWR)): (cChord &= ~(PWR)); break;
+			case STN_N1...STN_N6:	pr ? (cChord |= (LNO)): (cChord &= ~(LNO)); break;
+			case STN_N7...STN_NC:	pr ? (cChord |= (RNO)): (cChord &= ~(RNO)); break;
+
+			// All the letter keys
+			case STN_S1:			pr ? (cChord |= (LSU)) : (cChord &= ~(LSU));  break;
+			case STN_S2:			pr ? (cChord |= (LSD)) : (cChord &= ~(LSD));  break;
+			case STN_TL:			pr ? (cChord |= (LFT)) : (cChord &= ~(LFT)); break;
+			case STN_KL:			pr ? (cChord |= (LK)) : (cChord &= ~(LK)); break;
+			case STN_PL:			pr ? (cChord |= (LP)) : (cChord &= ~(LP)); break;
+			case STN_WL:			pr ? (cChord |= (LW)) : (cChord &= ~(LW)); break;
+			case STN_HL:			pr ? (cChord |= (LH)) : (cChord &= ~(LH)); break;
+			case STN_RL:			pr ? (cChord |= (LR)) : (cChord &= ~(LR)); break;
+			case STN_A:				pr ? (cChord |= (LA)) : (cChord &= ~(LA)); break;
+			case STN_O:				pr ? (cChord |= (LO)) : (cChord &= ~(LO)); break;
+			case STN_E:				pr ? (cChord |= (RE)) : (cChord &= ~(RE)); break;
+			case STN_U:				pr ? (cChord |= (RU)) : (cChord &= ~(RU)); break;
+			case STN_FR:			pr ? (cChord |= (RF)) : (cChord &= ~(RF)); break;
+			case STN_RR:			pr ? (cChord |= (RR)) : (cChord &= ~(RR)); break;
+			case STN_PR:			pr ? (cChord |= (RP)) : (cChord &= ~(RP)); break;
+			case STN_BR:			pr ? (cChord |= (RB)) : (cChord &= ~(RB)); break;
+			case STN_LR:			pr ? (cChord |= (RL)) : (cChord &= ~(RL)); break;
+			case STN_GR:			pr ? (cChord |= (RG)) : (cChord &= ~(RG)); break;
+			case STN_TR:			pr ? (cChord |= (RT)) : (cChord &= ~(RT)); break;
+			case STN_SR:			pr ? (cChord |= (RS)) : (cChord &= ~(RS)); break;
+			case STN_DR:			pr ? (cChord |= (RD)) : (cChord &= ~(RD)); break;
+			case STN_ZR:			pr ? (cChord |= (RZ)) : (cChord &= ~(RZ)); break;
+	}
+
+	// Store previous state for fastQWER
+	if (pr) {
+		chordState[chordIndex] = cChord; 
+		chordIndex++;
+	}
+
+	return true; 
+}
+void matrix_scan_user(void) {
+	// We abuse this for early sending of key
+	// Key repeat only on QWER/SYMB layers
+	if (cMode != QWERTY || !inChord) return;
+
+	// Check timers
+#ifndef NO_REPEAT
+	if (repEngaged && timer_elapsed(repTimer) > REP_DELAY) {
+		// Process Key for report
+		processChord(false);
+
+		// Send report to host
+		send_keyboard_report();
+		clear_keyboard();
+		repTimer = timer_read();
+	}
+
+	if (!repEngaged && timer_elapsed(repTimer) > REP_INIT_DELAY) {
+		repEngaged = true;
+	}
+#endif
+};
+
+// For Plover NKRO
+uint32_t processFakeSteno(bool lookup) { 
+	P( LSU,				SEND(KC_Q););
+	P( LSD,				SEND(KC_A););
+	P( LFT,				SEND(KC_W););
+	P( LP,				SEND(KC_E););
+	P( LH,				SEND(KC_R););
+	P( LK,				SEND(KC_S););
+	P( LW,				SEND(KC_D););
+	P( LR,				SEND(KC_F););
+	P( ST1,				SEND(KC_T););
+	P( ST2,				SEND(KC_G););
+	P( LA,				SEND(KC_C););
+	P( LO,				SEND(KC_V););
+	P( RE,				SEND(KC_N););
+	P( RU,				SEND(KC_M););
+	P( ST3,				SEND(KC_Y););
+	P( ST4,				SEND(KC_H););
+	P( RF,				SEND(KC_U););
+	P( RP,				SEND(KC_I););
+	P( RL,				SEND(KC_O););
+	P( RT,				SEND(KC_P););
+	P( RD,				SEND(KC_LBRC););
+	P( RR,				SEND(KC_J););
+	P( RB,				SEND(KC_K););
+	P( RG,				SEND(KC_L););
+	P( RS,				SEND(KC_SCLN););
+	P( RZ,				SEND(KC_COMM););
+	P( LNO,				SEND(KC_1););
+	P( RNO,				SEND(KC_1););
+
+	return 0;
+}
+
+// Traverse the chord history to a given point
+// Returns the mask to use
+void processChord(bool useFakeSteno) {
+	// Save the clean chord state
+	uint32_t savedChord = cChord;
+
+	// Apply Stick Bits if needed
+	if (stickyBits != 0) {
+		cChord |= stickyBits;
+		for (int i = 0; i <= chordIndex; i++)
+			chordState[i] |= stickyBits;
+	}
+
+	// Strip FN
+	if (cChord & FN) cChord ^= FN;
+
+	// First we test if a whole chord was passsed
+	// If so we just run it handling repeat logic
+	if (useFakeSteno && processFakeSteno(true) == cChord) {
+		processFakeSteno(false);
+		return;
+	} else if (processQwerty(true) == cChord) {
+		processQwerty(false);
+		// Repeat logic
+		if (repeatFlag) {
+			restoreState();
+			repeatFlag = false;
+			processChord(false);
+		} else {
+			saveState(cChord);
+		}
+		return;
+	}
+
+	// Iterate through chord picking out the individual 
+	// and longest chords
+	uint32_t bufChords[QWERBUF];
+	int 	 bufLen		= 0;
+	uint32_t mask		= 0;
+
+	// We iterate over it multiple times to catch the longest
+	// chord. Then that gets addded to the mask and re run.
+	while (savedChord != mask) {
+		uint32_t test  	 		= 0;
+		uint32_t longestChord	= 0;
+
+		for (int i = 0; i <= chordIndex; i++) {
+			cChord = chordState[i] & ~mask;
+			if (cChord == 0)
+				continue;
+
+			// Assume mid parse Sym is new chord
+			if (i != 0 && test != 0 && (cChord ^ test) == PWR) {
+				longestChord = test;
+				break;
+			}
+
+			// Lock SYM layer in once detected
+			if (mask & PWR)
+				cChord |= PWR;
+
+
+			// Testing for keycodes
+			if (useFakeSteno) {
+				test = processFakeSteno(true);
+			} else {
+				test = processQwerty(true);
+			}
+		 
+			if (test != 0) {
+				longestChord = test;
+			}
+		}
+		
+		mask |= longestChord;
+		bufChords[bufLen] = longestChord;
+		bufLen++;
+
+		// That's a loop of sorts, halt processing
+		if (bufLen >= QWERBUF) {
+			return;
+		}
+	}
+	
+	// Now that the buffer is populated, we run it
+	for (int i = 0; i < bufLen ; i++) {
+		cChord = bufChords[i];
+		if (useFakeSteno) {
+			processFakeSteno(false);
+		} else {
+			processQwerty(false);
+		}
+	}
+
+	// Save state in case of repeat
+	if (!repeatFlag) {			
+		saveState(savedChord);
+	}
+
+	// Restore cChord for held repeat
+	cChord = savedChord;
+
+	return;
+}
+void saveState(uint32_t cleanChord) {
+	pChord = cleanChord;
+	pChordIndex = chordIndex;
+	for (int i = 0; i < 32; i++) 
+		pChordState[i] = chordState[i];
+}
+void restoreState() {
+	cChord = pChord;
+	chordIndex = pChordIndex;
+	for (int i = 0; i < 32; i++) 
+		chordState[i] = pChordState[i];
+}
+
+// Macros for calling from keymap.c
+void SEND(uint8_t kc) {
+	// Send Keycode, Does not work for Quantum Codes
+	if (cMode == COMMAND && CMDLEN < MAX_CMD_BUF) {
+#ifndef NO_DEBUG
+		uprintf("CMD LEN: %d BUF: %d\n", CMDLEN, MAX_CMD_BUF);
+#endif
+		CMDBUF[CMDLEN] = kc;
+		CMDLEN++;
+	} 
+
+	if (cMode != COMMAND) register_code(kc);
+	return;
+}
+void REPEAT(void) {
+	if (cMode != QWERTY)
+		return;
+
+	repeatFlag = true;
+	return;
+}
+void SET_STICKY(uint32_t stick) {
+	stickyBits = stick;
+	return;
+}
+void SWITCH_LAYER(int layer) {
+	if (keymapsCount >= layer) 
+		layer_on(layer);
+}
+void CLICK_MOUSE(uint8_t kc) {
+#ifdef MOUSEKEY_ENABLE
+	mousekey_on(kc);
+	mousekey_send();
+
+	// Store state for later use
+	inMouse = true;
+	mousePress = kc;
+#endif
+}

keyboards/butterstick/sten.h

@@ -0,0 +1,77 @@
+// 2019, g Heavy Industries
+// Blessed mother of Christ, please keep this readable
+// and protect us from segfaults. For thine is the clock,
+// the slave and the master. Until we return from main.
+//
+// Amen.
+
+#include QMK_KEYBOARD_H
+#include "mousekey.h"
+#include "keymap.h"
+#include "keymap_steno.h"
+#include "wait.h"
+
+extern size_t keymapsCount;			// Total keymaps
+extern uint32_t cChord;				// Current Chord
+
+// Function defs
+void 			processChord(bool useFakeSteno);
+uint32_t		processQwerty(bool lookup);
+uint32_t 		processFakeSteno(bool lookup);
+void 			saveState(uint32_t cChord);
+void 			restoreState(void);
+
+// Macros for use in keymap.c
+void 			SEND(uint8_t kc);
+void 			REPEAT(void);
+void 			SET_STICKY(uint32_t);
+void 			SWITCH_LAYER(int);
+void 			CLICK_MOUSE(uint8_t);
+
+// Keymap helper
+#define P(chord, act) if (cChord == (chord)) { if (!lookup) {act;} return chord;}
+
+// Shift to internal representation
+// i.e) S(teno)R(ight)F
+#define STN(n) (1L<<n)
+enum ORDER { 
+		SFN = 0, SPWR, SST1, SST2, SST3, SST4, SNUML, SNUMR,
+		SLSU, SLSD, SLT, SLK, SLP, SLW, SLH, SLR, SLA, SLO, 
+		SRE, SRU, SRF, SRR, SRP, SRB, SRL, SRG, SRT, SRS, SRD, SRZ, SRES1, SRES2
+};
+
+// Break it all out
+#define FN	STN(SFN)
+#define PWR	STN(SPWR)
+#define ST1 STN(SST1)
+#define ST2 STN(SST2)
+#define ST3 STN(SST3)
+#define ST4 STN(SST4)
+#define LNO STN(SNUML) 	// STN1-6
+#define RNO STN(SNUMR) 	// STN7-C
+#define RES1 STN(SRES1) // Use reserved for sticky state
+#define RES2 STN(SRES2)
+
+#define LSU STN(SLSU)
+#define LSD STN(SLSD)
+#define LFT STN(SLT)  	// (L)e(F)t (T), preprocessor conflict
+#define LK  STN(SLK)
+#define LP  STN(SLP)
+#define LW  STN(SLW)
+#define LH  STN(SLH)
+#define LR  STN(SLR)
+#define LA  STN(SLA)
+#define LO  STN(SLO)
+
+#define RE  STN(SRE)
+#define RU  STN(SRU)
+#define RF  STN(SRF)
+#define RR  STN(SRR)
+#define RP  STN(SRP)
+#define RB  STN(SRB)
+#define RL  STN(SRL)
+#define RG  STN(SRG)
+#define RT  STN(SRT)
+#define RS  STN(SRS)
+#define RD  STN(SRD)
+#define RZ  STN(SRZ)

keyboards/cannonkeys/satisfaction75/config.h

@@ -76,7 +76,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // Bump this every time we change what we store
 // This will automatically reset the EEPROM with defaults
 // and avoid loading invalid data from the EEPROM
-#define EEPROM_VERSION 0x0F
+#define EEPROM_VERSION 0x01
 #define EEPROM_VERSION_ADDR 34
 
 // Dynamic keymap starts after EEPROM version

keyboards/cannonkeys/satisfaction75/i2c_master.c

@@ -29,8 +29,6 @@
 #include "quantum.h"
 #include <string.h>
 #include <hal.h>
-#include "chtypes.h"
-#include "ch.h"
 
 static uint8_t i2c_address;
 
@@ -44,6 +42,18 @@ static const I2CConfig i2cconfig = {
   0
 };
 
+static i2c_status_t chibios_to_qmk(const msg_t status) {
+  switch (status) {
+    case I2C_NO_ERROR:
+      return I2C_STATUS_SUCCESS;
+    case I2C_TIMEOUT:
+      return I2C_STATUS_TIMEOUT;
+    // I2C_BUS_ERROR, I2C_ARBITRATION_LOST, I2C_ACK_FAILURE, I2C_OVERRUN, I2C_PEC_ERROR, I2C_SMB_ALERT
+    default:
+      return I2C_STATUS_ERROR;
+  }
+}
+
 __attribute__ ((weak))
 void i2c_init(void)
 {
@@ -59,34 +69,32 @@ void i2c_init(void)
   //i2cInit(); //This is invoked by halInit() so no need to redo it.
 }
 
-// This is usually not needed
-uint8_t i2c_start(uint8_t address)
+i2c_status_t i2c_start(uint8_t address)
 {
   i2c_address = address;
   i2cStart(&I2C_DRIVER, &i2cconfig);
-  return 0;
+  return I2C_STATUS_SUCCESS;
 }
 
-uint8_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout)
+i2c_status_t i2c_transmit(uint8_t address, const uint8_t* data, uint16_t length, uint16_t timeout)
 {
-  msg_t status = MSG_OK;
-
   i2c_address = address;
   i2cStart(&I2C_DRIVER, &i2cconfig);
   i2cAcquireBus(&I2C_DRIVER);
-  status = i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), data, length, 0, 0, MS2ST(timeout));
+  msg_t status = i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), data, length, 0, 0, MS2ST(timeout));
   i2cReleaseBus(&I2C_DRIVER);
-  return status;
+  return chibios_to_qmk(status);
 }
 
-uint8_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_address = address;
   i2cStart(&I2C_DRIVER, &i2cconfig);
-  return i2cMasterReceiveTimeout(&I2C_DRIVER, (i2c_address >> 1), data, length, MS2ST(timeout));
+  msg_t status = i2cMasterReceiveTimeout(&I2C_DRIVER, (i2c_address >> 1), data, length, MS2ST(timeout));
+  return chibios_to_qmk(status);
 }
 
-uint8_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, const uint8_t* data, uint16_t length, uint16_t timeout)
 {
   i2c_address = devaddr;
   i2cStart(&I2C_DRIVER, &i2cconfig);
@@ -98,19 +106,19 @@ uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t l
   }
   complete_packet[0] = regaddr;
 
-  return i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), complete_packet, length + 1, 0, 0, MS2ST(timeout));
+  msg_t status = i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), complete_packet, length + 1, 0, 0, MS2ST(timeout));
+  return chibios_to_qmk(status);
 }
 
-uint8_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_address = devaddr;
   i2cStart(&I2C_DRIVER, &i2cconfig);
-  return i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), regaddr, 1, data, length, MS2ST(timeout));
+  msg_t status = i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), regaddr, 1, data, length, MS2ST(timeout));
+  return chibios_to_qmk(status);
 }
 
-// This is usually not needed. It releases the driver to allow pins to become GPIO again.
-uint8_t i2c_stop(void)
+void i2c_stop(void)
 {
   i2cStop(&I2C_DRIVER);
-  return 0;
 }

keyboards/cannonkeys/satisfaction75/keymaps/jae/keymap.c

@@ -0,0 +1,37 @@
+/*
+Copyright 2012,2013 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/>.
+*/
+
+#include QMK_KEYBOARD_H
+
+const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [0] = LAYOUT_all(
+    KC_ESC,   KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,   KC_F12,
+    KC_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_DEL, ENC_PRESS,
+    KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,  KC_BSLS,  KC_PGUP,
+    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_NUHS,  KC_ENTER, KC_PGDN,
+    KC_LSFT,  KC_NUBS,  KC_Z,     KC_X,     KC_C,     KC_V,     KC_B,     KC_N,     KC_M,     KC_COMM,  KC_DOT,   KC_SLSH,  KC_RSFT,  KC_UP,    MO(1),
+    KC_LCTL,  KC_LGUI,  KC_LALT,  KC_SPC,             KC_SPC,             KC_SPC,             KC_RALT,  MO(1),    KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT
+  ),
+  [1] = LAYOUT_all(
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_DEL, _______, OLED_TOGG,
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, CLOCK_SET,
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+    _______, _______, _______, _______,          _______,          _______,          _______, _______, _______, _______, _______, _______
+  )
+};

keyboards/cannonkeys/satisfaction75/keymaps/via/keymap.c

@@ -17,25 +17,27 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include QMK_KEYBOARD_H
 
+
 const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-  [0] = LAYOUT_default(
+  [0] = LAYOUT_all(
     KC_ESC,   KC_F1,    KC_F2,    KC_F3,    KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,   KC_F12,
-    KC_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,  ENC_PRESS,
+    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_DEL, ENC_PRESS,
     KC_TAB,   KC_Q,     KC_W,     KC_E,     KC_R,     KC_T,     KC_Y,     KC_U,     KC_I,     KC_O,     KC_P,     KC_LBRC,  KC_RBRC,  KC_BSLS,  KC_DEL,
-    KC_CAPS,  KC_A,     KC_S,     KC_D,     KC_F,     KC_G,     KC_H,     KC_J,     KC_K,     KC_L,     KC_SCLN,  KC_QUOT,  KC_ENTER,           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,                                 KC_RALT,  MO(1),  KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT
+    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_NUHS,  KC_ENTER, KC_PGUP,
+    KC_LSFT,  KC_NUBS,  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,             KC_SPC,             KC_SPC,             KC_RALT,  MO(1),    KC_RCTL,  KC_LEFT,  KC_DOWN,  KC_RGHT
   ),
-  [1] = LAYOUT_default(
+  [1] = LAYOUT_all(
     _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
-    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, OLED_TOGG,
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, OLED_TOGG,
     _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, CLOCK_SET,
-    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,          _______,
-    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,          _______, _______,
-    _______, _______, _______,                   _______,                            _______, _______, _______, _______, _______, _______
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+    RESET, _______, _______, _______,          _______,          _______,          _______, _______, _______, _______, _______, _______
   )
 };
 
+
 void matrix_init_user(void) {
   //user initialization
 }

keyboards/comet46/keymaps/satt/action_pseudo_lut.c

@@ -1,4 +1,5 @@
 #include "quantum.h"
+#include "command.h"
 #include "action_pseudo_lut.h"
 
 static uint8_t send_key_shift_bit[SHIFT_BIT_SIZE];

keyboards/cospad/config.h

@@ -15,8 +15,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 CONFIG_H
-#define CONFIG_H
+#pragma once
 
 #include "config_common.h"
 
@@ -32,42 +31,43 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define MATRIX_ROWS 6
 #define MATRIX_COLS 4
 
-// ROWS: Top to bottom, COLS: Left to right
-
+/*
+ * 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 { D0, D1, D2, D3, D4, D5 }
 #define MATRIX_COL_PINS { F0, F1, E6, C7 }
 #define UNUSED_PINS
 
-#define BACKLIGHT_PIN F7
-
 /* COL2ROW or ROW2COL */
 #define DIODE_DIRECTION COL2ROW
 
-/* define if matrix has ghost */
-//#define MATRIX_HAS_GHOST
+/* Backlight configuration */
+#define BACKLIGHT_PIN F7
+#define BACKLIGHT_LEVELS 1
 
-/* Set 0 if debouncing isn't needed */
+/* Underlight configuration */
+#define RGB_DI_PIN F6
+#define RGBLED_NUM 4
+#define RGBLIGHT_ANIMATIONS
+
+/* 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
+
 /* 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
 
-/* Backlight configuration
- */
-#define BACKLIGHT_LEVELS 4
-
-/* Underlight configuration
- */
-
-#define RGB_DI_PIN F6
-#define RGBLIGHT_ANIMATIONS
-#define RGBLED_NUM 4     // Number of LEDs
-#define RGBLIGHT_HUE_STEP 10
-#define RGBLIGHT_SAT_STEP 17
-#define RGBLIGHT_VAL_STEP 17
-
 /*
  * Feature disable options
  *  These options are also useful to firmware size reduction.
@@ -86,4 +86,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //#define NO_ACTION_MACRO
 //#define NO_ACTION_FUNCTION
 
-#endif
+/* Bootmagic Lite key configuration */
+// #define BOOTMAGIC_LITE_ROW 0
+// #define BOOTMAGIC_LITE_COLUMN 0

keyboards/cospad/cospad.c

@@ -1,37 +1,33 @@
+    
+/* 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 "cospad.h"
-#include "led.h"
 
-extern inline void cospad_bl_led_on(void);
-extern inline void cospad_bl_led_off(void);
-extern inline void cospad_bl_led_togg(void);
+#ifdef BACKLIGHT_ENABLE
 
-void matrix_init_kb(void) {
-	// put your keyboard start-up code here
-	// runs once when the firmware starts up
-	matrix_init_user();
-	led_init_ports();
-};
-
-void matrix_scan_kb(void) {
-	// put your looping keyboard code here
-	// runs every cycle (a lot)
-	matrix_scan_user();
-};
-
-void led_init_ports(void) {
-    // * Set our LED pins as output
-    DDRB |= (1<<2);
-    DDRF |= (1<<7);
-    // * Setting BL LEDs to init as off
-    PORTF |= (1<<7);
+void backlight_init_ports(void) {
+  setPinOutput(F7);
 }
 
-void led_set_kb(uint8_t usb_led) {
-    if (usb_led & (1<<USB_LED_NUM_LOCK)) {
-        // Turn numlock on
-        PORTB &= ~(1<<2);
-    } else {
-        // Turn numlock off
-        PORTB |= (1<<2);
-    }    
+void backlight_set(uint8_t level) {
+  writePin(F7, !!level);
 }
+
+void backlight_task(void) {
+    // do nothing - as default implementation of software PWM does not work
+}
+
+#endif //BACKLIGHT_ENABLE

keyboards/cospad/cospad.h

@@ -1,10 +1,32 @@
-#ifndef COSPAD_H
-#define COSPAD_H
+
+/* 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"
+#define ___ KC_NO
 
-// readability
-#define XXX KC_NO
+/* 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.
+ */
 
 /* COSPAD ortho matrix layout
    * ,-------------------.
@@ -21,40 +43,6 @@
    * | 50 | 51 | 52 | 53 |
    * `-------------------'
  */
-
-/* COSPAD gamepad matrix layout
-   * ,-------------------.
-   * | 00 | 01 | 02 | 03 |
-   * |----|----|----|----|
-   * | 10 | 11 | 12 | 13 |
-   * |----|----|----|----|
-   * | 20 | 21 | 22 |    |
-   * |----|----|----| 23 |
-   * | 30 | 31 | 32 |    |
-   * |----|----|----|----|
-   * | 40 | 41 | 42 | 43 |
-   * |----|----|----|----|
-   * | 50 | 51 | 52 | 53 |
-   * `-------------------'
- */
-
-/* COSPAD numpad matrix layout
-   * ,-------------------.
-   * | 00 | 01 | 02 | 03 |
-   * |----|----|----|----|
-   * | 10 | 11 | 12 | 13 |
-   * |----|----|----|----|
-   * | 20 | 21 | 22 |    |
-   * |----|----|----| 23 |
-   * | 30 | 31 | 32 |    |
-   * |----|----|----|----|
-   * | 40 | 41 | 42 |    |
-   * |----|----|----| 43 |
-   * |    50   | 52 |    |
-   * `-------------------'
- */
-// The first section contains all of the arguments
-// The second converts the arguments into a two-dimensional array
 #define LAYOUT_ortho_6x4( \
 	k00, k01, k02, k03, \
 	k10, k11, k12, k13, \
@@ -72,6 +60,21 @@
 	{k50, k51, k52, k53}  \
 }
 
+/* COSPAD gamepad matrix layout
+   * ,-------------------.
+   * | 00 | 01 | 02 | 03 |
+   * |----|----|----|----|
+   * | 10 | 11 | 12 | 13 |
+   * |----|----|----|----|
+   * | 20 | 21 | 22 |    |
+   * |----|----|----| 23 |
+   * | 30 | 31 | 32 |    |
+   * |----|----|----|----|
+   * | 40 | 41 | 42 | 43 |
+   * |----|----|----|----|
+   * | 50 | 51 | 52 | 53 |
+   * `-------------------'
+ */
 #define LAYOUT_gamepad_6x4( \
 	k00, k01, k02, k03, \
 	k10, k11, k12, k13, \
@@ -84,11 +87,26 @@
 	{k00, k01, k02, k03},   \
 	{k10, k11, k12, k13},   \
 	{k20, k21, k22, k23},   \
-	{k30, k31, k32, KC_NO}, \
+	{k30, k31, k32, ___}, \
 	{k40, k41, k42, k43},   \
 	{k50, k51, k52, k53}    \
 }
 
+/* COSPAD numpad matrix layout
+   * ,-------------------.
+   * | 00 | 01 | 02 | 03 |
+   * |----|----|----|----|
+   * | 10 | 11 | 12 | 13 |
+   * |----|----|----|----|
+   * | 20 | 21 | 22 |    |
+   * |----|----|----| 23 |
+   * | 30 | 31 | 32 |    |
+   * |----|----|----|----|
+   * | 40 | 41 | 42 |    |
+   * |----|----|----| 43 |
+   * |    50   | 52 |    |
+   * `-------------------'
+ */
 #define LAYOUT_numpad_6x4( \
 	k00, k01, k02, k03,  \
 	k10, k11, k12, k13,  \
@@ -98,25 +116,15 @@
 	k50,      k52, k43   \
 ) \
 { \
-	{k00, k01,   k02, k03},   \
-	{k10, k11,   k12, k13},   \
-	{k20, k21,   k22, k23},   \
-	{k30, k31,   k32, KC_NO}, \
-	{k40, k41,   k42, k43},   \
-	{k50, KC_NO, k52, KC_NO}  \
+	{k00, k01, k02, k03},   \
+	{k10, k11, k12, k13},   \
+	{k20, k21, k22, k23},   \
+	{k30, k31, k32, ___}, \
+	{k40, k41, k42, k43},   \
+	{k50, ___, k52, ___}  \
 }
-void matrix_init_user(void);
-void matrix_scan_user(void);
 
-inline void cospad_bl_led_on(void)	{ PORTF &= ~(1<<7); }
-inline void cospad_bl_led_off(void)	{ PORTF |= (1<<7); }
-
-inline void cospad_bl_led_togg(void) {
-   uint8_t bl_mask = PORTF&(1<<7);
-   if (bl_mask) {
-      PORTF &= ~(1<<7);
-   } else {
-      PORTF |= (1<<7);
-   }
-}
-#endif
+// Add backwards compatibility for existing keymaps
+#define cospad_bl_led_on   backlight_enable
+#define cospad_bl_led_off  backlight_disable
+#define cospad_bl_led_togg backlight_toggle

keyboards/cospad/info.json

@@ -7,6 +7,7 @@
   "height": 6,
   "layouts": {
     "LAYOUT_numpad_6x4": {
+      "key_count": 21,
       "layout": [
         {"label":"Esc", "x":0, "y":0},
         {"label":"Tab", "x":1, "y":0},
@@ -33,35 +34,62 @@
     },
 
     "LAYOUT_gamepad_6x4": {
+      "key_count": 23,
       "layout": [
-        {"label":"k00", "x":5, "y":0},
-        {"label":"k01", "x":5, "y":1},
-        {"label":"k02", "x":5, "y":2},
-        {"label":"k03", "x":5, "y":3},
-        {"label":"k10", "x":4, "y":0},
-        {"label":"k11", "x":4, "y":1},
-        {"label":"k12", "x":4, "y":2},
-        {"label":"k13", "x":4, "y":3},
-        {"label":"k20", "x":3, "y":0},
-        {"label":"k21", "x":3, "y":1},
-        {"label":"k22", "x":3, "y":2},
-        {"label":"k30", "x":2, "y":0},
-        {"label":"k31", "x":2, "y":1},
-        {"label":"k32", "x":2, "y":2},
-        {"label":"k23", "x":2, "y":3, "w":2},
-        {"label":"k40", "x":1, "y":0},
-        {"label":"k41", "x":1, "y":1},
-        {"label":"k42", "x":1, "y":2},
-        {"label":"k43", "x":1, "y":3},
-        {"label":"k50", "x":0, "y":0},
-        {"label":"k51", "x":0, "y":1},
-        {"label":"k52", "x":0, "y":2},
-        {"label":"k53", "x":0, "y":3}
+        {"label":"k00", "x":0, "y":0},
+        {"label":"k01", "x":1, "y":0},
+        {"label":"k02", "x":2, "y":0},
+        {"label":"k03", "x":3, "y":0},
+        {"label":"k10", "x":0, "y":1},
+        {"label":"k11", "x":1, "y":1},
+        {"label":"k12", "x":2, "y":1},
+        {"label":"k13", "x":3, "y":1},
+        {"label":"k20", "x":0, "y":2},
+        {"label":"k21", "x":1, "y":2},
+        {"label":"k22", "x":2, "y":2},
+        {"label":"k30", "x":0, "y":3},
+        {"label":"k31", "x":1, "y":3},
+        {"label":"k32", "x":2, "y":3},
+        {"label":"k23", "x":3, "y":2, "h":2},
+        {"label":"k40", "x":0, "y":4},
+        {"label":"k41", "x":1, "y":4},
+        {"label":"k42", "x":2, "y":4},
+        {"label":"k43", "x":3, "y":4},
+        {"label":"k50", "x":0, "y":5},
+        {"label":"k51", "x":1, "y":5},
+        {"label":"k52", "x":2, "y":5},
+        {"label":"k53", "x":3, "y":5}
       ]
     },
 
     "LAYOUT_ortho_6x4": {
-      "layout": [{"label":"Esc", "x":0, "y":0}, {"label":"Tab", "x":1, "y":0}, {"label":"Fn", "x":2, "y":0}, {"label":"Back", "x":3, "y":0}, {"label":"Num Lock", "x":0, "y":1}, {"label":"/", "x":1, "y":1}, {"label":"*", "x":2, "y":1}, {"label":"-", "x":3, "y":1}, {"label":"7", "x":0, "y":2}, {"label":"8", "x":1, "y":2}, {"label":"9", "x":2, "y":2}, {"label":"+", "x":3, "y":2}, {"label":"4", "x":0, "y":3}, {"label":"5", "x":1, "y":3}, {"label":"6", "x":2, "y":3}, {"x":3, "y":3}, {"label":"1", "x":0, "y":4}, {"label":"2", "x":1, "y":4}, {"label":"3", "x":2, "y":4}, {"label":"Enter", "x":3, "y":4}, {"label":"0", "x":0, "y":5}, {"x":1, "y":5}, {"label":".", "x":2, "y":5}, {"x":3, "y":5}]
+      "key_count": 24,
+      "layout": [
+        {"label":"k00", "x":0, "y":0},
+        {"label":"k01", "x":1, "y":0},
+        {"label":"k02", "x":2, "y":0},
+        {"label":"k03", "x":3, "y":0},
+        {"label":"k10", "x":0, "y":1},
+        {"label":"k11", "x":1, "y":1},
+        {"label":"k12", "x":2, "y":1},
+        {"label":"k13", "x":3, "y":1},
+        {"label":"k20", "x":0, "y":2},
+        {"label":"k21", "x":1, "y":2},
+        {"label":"k22", "x":2, "y":2},
+        {"label":"k23", "x":3, "y":2},
+        {"label":"k30", "x":0, "y":3},
+        {"label":"k31", "x":1, "y":3},
+        {"label":"k32", "x":2, "y":3},
+        {"label":"k33", "x":3, "y":3},
+        {"label":"k40", "x":0, "y":4},
+        {"label":"k41", "x":1, "y":4},
+        {"label":"k42", "x":2, "y":4},
+        {"label":"k43", "x":3, "y":4},
+        {"label":"k50", "x":0, "y":5},
+        {"label":"k51", "x":1, "y":5},
+        {"label":"k52", "x":2, "y":5},
+        {"label":"k53", "x":3, "y":5}
+      ]
     }
   }
 }

keyboards/cospad/keymaps/default/keymap.c

@@ -1,80 +1,60 @@
 #include QMK_KEYBOARD_H
-#include "led.h"
 
 // Each layer gets a name for readability, which is then used in the keymap matrix below.
 // The underscores don't mean anything - you can have a layer called STUFF or any other name.
 // Layer names don't all need to be of the same length, obviously, and you can also skip them
 // entirely and just use numbers.
-#define _BL 0
-#define _FL 1
-
-const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-  /* Keymap _BL: (Base Layer) Default Layer
-   * ,-------------------.
-   * |Esc |TAB | FN | BS |
-   * |----|----|----|----|
-   * | NL | /  | *  | -  |
-   * |----|----|----|----|
-   * | 7  | 8  | 9  |    |
-   * |----|----|----| +  |
-   * | 4  | 5  | 6  |    |
-   * |----|----|----|----|
-   * | 1  | 2  | 3  |    |
-   * |----|----|----| En |
-   * |   0     | .  |    |
-   * `-------------------'
-   */
-
-[_BL] = LAYOUT_numpad_6x4(
-  KC_ESC,   KC_TAB,   MO(_FL),   KC_BSPC, \
-  KC_NLCK,  KC_PSLS,  KC_PAST,   KC_PMNS, \
-  KC_P7,    KC_P8,    KC_P9,              \
-  KC_P4,    KC_P5,    KC_P6,     KC_PPLS, \
-  KC_P1,    KC_P2,    KC_P3,              \
-  KC_P0,              KC_PDOT,   KC_PENT),
-
-  /* Keymap _FL: Function Layer
-   * ,-------------------.
-   * |RGBT|TAB | FN | BS |
-   * |----|----|----|----|
-   * |RGBM|RGBP|BTOG| -  |
-   * |----|----|----|----|
-   * |HUD |HUI |BON |    |
-   * |----|----|----| +  |
-   * |SAD |SAI |BOFF|    |
-   * |----|----|----|----|
-   * |VAD |VAS | 3  |    |
-   * |----|----|----| En |
-   * |   0     |RST |    |
-   * `-------------------'
-   */
-[_FL] = LAYOUT_numpad_6x4(
-  RGB_TOG,  KC_TAB,   KC_TRNS,   KC_BSPC, \
-  RGB_MOD,  RGB_M_P,  BL_TOGG,   KC_PMNS, \
-  RGB_HUD,  RGB_HUI,  BL_ON,              \
-  RGB_SAD,  RGB_SAI,  BL_OFF,    KC_PPLS, \
-  RGB_VAD,  RGB_VAI,  KC_P3,              \
-  KC_P0,              RESET,     KC_PENT),
+enum layers {
+  _BL = 0,
+  _FL
 };
 
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-   switch (keycode) {
-      case BL_TOGG:
-         if (record->event.pressed) {
-            cospad_bl_led_togg();
-         }
-         return false;
-      case BL_ON:
-         if (record->event.pressed) {
-            cospad_bl_led_on();
-         }
-         return false;
-      case BL_OFF:
-         if(record->event.pressed) {
-            cospad_bl_led_off();
-         }
-         return false;
-      default:
-         return true;
-   }
-}
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+/* Keymap _BL: (Base Layer) Default Layer
+ * ,-------------------.
+ * |Esc |TAB | FN | BS |
+ * |----|----|----|----|
+ * | NL | /  | *  | -  |
+ * |----|----|----|----|
+ * | 7  | 8  | 9  |    |
+ * |----|----|----| +  |
+ * | 4  | 5  | 6  |    |
+ * |----|----|----|----|
+ * | 1  | 2  | 3  |    |
+ * |----|----|----| En |
+ * |   0     | .  |    |
+ * `-------------------'
+ */
+  [_BL] = LAYOUT_numpad_6x4(
+    KC_ESC,   KC_TAB,   MO(_FL),   KC_BSPC, \
+    KC_NLCK,  KC_PSLS,  KC_PAST,   KC_PMNS, \
+    KC_P7,    KC_P8,    KC_P9,              \
+    KC_P4,    KC_P5,    KC_P6,     KC_PPLS, \
+    KC_P1,    KC_P2,    KC_P3,              \
+    KC_P0,              KC_PDOT,   KC_PENT
+  ),
+
+/* Keymap _FL: Function Layer
+ * ,-------------------.
+ * |RGBT|    |    |    |
+ * |----|----|----|----|
+ * |RGBM|RGBP|BTOG|    |
+ * |----|----|----|----|
+ * |HUD |HUI |BON |    |
+ * |----|----|----|    |
+ * |SAD |SAI |BOFF|    |
+ * |----|----|----|----|
+ * |VAD |VAS |BSTP|    |
+ * |----|----|----|    |
+ * |         |RST |    |
+ * `-------------------'
+ */
+  [_FL] = LAYOUT_numpad_6x4(
+    RGB_TOG,  _______,  _______,   _______, \
+    RGB_MOD,  RGB_M_P,  BL_TOGG,   _______, \
+    RGB_HUD,  RGB_HUI,  BL_ON,              \
+    RGB_SAD,  RGB_SAI,  BL_OFF,    _______, \
+    RGB_VAD,  RGB_VAI,  BL_STEP,            \
+    _______,            RESET,     _______
+  ),
+};

keyboards/cospad/rules.mk

@@ -1,6 +1,5 @@
 
 # MCU name
-#MCU = at90usb1287
 MCU = atmega32u4
 
 # Processor frequency.
@@ -40,27 +39,43 @@ F_USB = $(F_CPU)
 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
+
+
 # Boot Section Size in *bytes*
 #   Teensy halfKay   512
 #   Teensy++ halfKay 1024
 #   Atmel DFU loader 4096
 #   LUFA bootloader  4096
 #   USBaspLoader     2048
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
+# OPT_DEFS += -DBOOTLOADER_SIZE=4096
 
 
 # Build Options
 #   comment out to disable the options.
 #
-BOOTMAGIC_ENABLE = no	# Virtual DIP switch configuration(+1000)
-MOUSEKEY_ENABLE = no	# 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
-NKRO_ENABLE = yes		# USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
-RGBLIGHT_ENABLE = yes   # Enable keyboard underlight functionality (+4870)
-BACKLIGHT_ENABLE = no  # Enable keyboard backlight functionality (+1150)
-MIDI_ENABLE = no 		# MIDI controls
-AUDIO_ENABLE = no
-UNICODE_ENABLE = no 		# Unicode
-BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID
+BOOTMAGIC_ENABLE = lite     # Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = no	    # 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
+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
+BACKLIGHT_CUSTOM_DRIVER = yes
+RGBLIGHT_ENABLE = yes       # Enable keyboard underlight functionality (+4870)
+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 = numpad_6x4 ortho_6x4

keyboards/crkbd/keymaps/default/keymap.c

@@ -22,9 +22,9 @@ extern uint8_t is_master;
 // Layer names don't all need to be of the same length, obviously, and you can also skip them
 // entirely and just use numbers.
 #define _QWERTY 0
-#define _LOWER 3
-#define _RAISE 4
-#define _ADJUST 16
+#define _LOWER 1
+#define _RAISE 2
+#define _ADJUST 3
 
 enum custom_keycodes {
   QWERTY = SAFE_RANGE,
@@ -246,4 +246,3 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   }
   return true;
 }
-

keyboards/crkbd/keymaps/drashna/config.h

@@ -27,7 +27,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // #define MASTER_RIGHT
 #define EE_HANDS
 
-#define SSD1306OLED
+// #define SSD1306OLED
 
 #define USE_SERIAL_PD2
 
@@ -48,3 +48,12 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define B6_AUDIO
 // #define NO_MUSIC_MODE
 #endif
+
+#undef PRODUCT
+#define PRODUCT Drashna Hacked Corne Keyboard
+
+#define OLED_FONT_H "keyboards/crkbd/keymaps/drashna/glcdfont.c"
+// #define OLED_FONT_WIDTH 5
+// #define OLED_FONT_HEIGHT 7
+
+#define TAPPING_TERM_PER_KEY

keyboards/crkbd/keymaps/drashna/glcdfont.c

@@ -0,0 +1,240 @@
+#pragma once
+
+#ifdef __AVR__
+ #include <avr/io.h>
+ #include <avr/pgmspace.h>
+#elif defined(ESP8266)
+ #include <pgmspace.h>
+#else
+ #define PROGMEM
+#endif
+
+// Helidox 8x6 font with QMK Firmware Logo
+// Online editor: http://teripom.x0.com/
+
+const unsigned char font[] PROGMEM = {
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x3E, 0x5B, 0x4F, 0x5B, 0x3E, 0x00,
+0x3E, 0x6B, 0x4F, 0x6B, 0x3E, 0x00,
+0x1C, 0x3E, 0x7C, 0x3E, 0x1C, 0x00,
+0x18, 0x3C, 0x7E, 0x3C, 0x18, 0x00,
+0x1C, 0x57, 0x7D, 0x57, 0x1C, 0x00,
+0x1C, 0x5E, 0x7F, 0x5E, 0x1C, 0x00,
+0x00, 0x18, 0x3C, 0x18, 0x00, 0x00,
+0xFF, 0xE7, 0xC3, 0xE7, 0xFF, 0x00,
+0x00, 0x18, 0x24, 0x18, 0x00, 0x00,
+0xFF, 0xE7, 0xDB, 0xE7, 0xFF, 0x00,
+0x30, 0x48, 0x3A, 0x06, 0x0E, 0x00,
+0x26, 0x29, 0x79, 0x29, 0x26, 0x00,
+0x40, 0x7F, 0x05, 0x05, 0x07, 0x00,
+0x40, 0x7F, 0x05, 0x25, 0x3F, 0x00,
+0x5A, 0x3C, 0xE7, 0x3C, 0x5A, 0x00,
+0x7F, 0x3E, 0x1C, 0x1C, 0x08, 0x00,
+0x08, 0x1C, 0x1C, 0x3E, 0x7F, 0x00,
+0x14, 0x22, 0x7F, 0x22, 0x14, 0x00,
+0x5F, 0x5F, 0x00, 0x5F, 0x5F, 0x00,
+0x06, 0x09, 0x7F, 0x01, 0x7F, 0x00,
+0x00, 0x66, 0x89, 0x95, 0x6A, 0x00,
+0x60, 0x60, 0x60, 0x60, 0x60, 0x00,
+0x94, 0xA2, 0xFF, 0xA2, 0x94, 0x00,
+0x08, 0x04, 0x7E, 0x04, 0x08, 0x00,
+0x10, 0x20, 0x7E, 0x20, 0x10, 0x00,
+0x08, 0x08, 0x2A, 0x1C, 0x08, 0x00,
+0x08, 0x1C, 0x2A, 0x08, 0x08, 0x00,
+0x1E, 0x10, 0x10, 0x10, 0x10, 0x00,
+0x0C, 0x1E, 0x0C, 0x1E, 0x0C, 0x00,
+0x30, 0x38, 0x3E, 0x38, 0x30, 0x00,
+0x06, 0x0E, 0x3E, 0x0E, 0x06, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x5F, 0x00, 0x00, 0x00,
+0x00, 0x07, 0x00, 0x07, 0x00, 0x00,
+0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00,
+0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x00,
+0x23, 0x13, 0x08, 0x64, 0x62, 0x00,
+0x36, 0x49, 0x56, 0x20, 0x50, 0x00,
+0x00, 0x08, 0x07, 0x03, 0x00, 0x00,
+0x00, 0x1C, 0x22, 0x41, 0x00, 0x00,
+0x00, 0x41, 0x22, 0x1C, 0x00, 0x00,
+0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 0x00,
+0x08, 0x08, 0x3E, 0x08, 0x08, 0x00,
+0x00, 0x80, 0x70, 0x30, 0x00, 0x00,
+0x08, 0x08, 0x08, 0x08, 0x08, 0x00,
+0x00, 0x00, 0x60, 0x60, 0x00, 0x00,
+0x20, 0x10, 0x08, 0x04, 0x02, 0x00,
+0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00,
+0x00, 0x42, 0x7F, 0x40, 0x00, 0x00,
+0x72, 0x49, 0x49, 0x49, 0x46, 0x00,
+0x21, 0x41, 0x49, 0x4D, 0x33, 0x00,
+0x18, 0x14, 0x12, 0x7F, 0x10, 0x00,
+0x27, 0x45, 0x45, 0x45, 0x39, 0x00,
+0x3C, 0x4A, 0x49, 0x49, 0x31, 0x00,
+0x41, 0x21, 0x11, 0x09, 0x07, 0x00,
+0x36, 0x49, 0x49, 0x49, 0x36, 0x00,
+0x46, 0x49, 0x49, 0x29, 0x1E, 0x00,
+0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+0x00, 0x40, 0x34, 0x00, 0x00, 0x00,
+0x00, 0x08, 0x14, 0x22, 0x41, 0x00,
+0x14, 0x14, 0x14, 0x14, 0x14, 0x00,
+0x00, 0x41, 0x22, 0x14, 0x08, 0x00,
+0x02, 0x01, 0x59, 0x09, 0x06, 0x00,
+0x3E, 0x41, 0x5D, 0x59, 0x4E, 0x00,
+0x7C, 0x12, 0x11, 0x12, 0x7C, 0x00,
+0x7F, 0x49, 0x49, 0x49, 0x36, 0x00,
+0x3E, 0x41, 0x41, 0x41, 0x22, 0x00,
+0x7F, 0x41, 0x41, 0x41, 0x3E, 0x00,
+0x7F, 0x49, 0x49, 0x49, 0x41, 0x00,
+0x7F, 0x09, 0x09, 0x09, 0x01, 0x00,
+0x3E, 0x41, 0x41, 0x51, 0x73, 0x00,
+0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00,
+0x00, 0x41, 0x7F, 0x41, 0x00, 0x00,
+0x20, 0x40, 0x41, 0x3F, 0x01, 0x00,
+0x7F, 0x08, 0x14, 0x22, 0x41, 0x00,
+0x7F, 0x40, 0x40, 0x40, 0x40, 0x00,
+0x7F, 0x02, 0x1C, 0x02, 0x7F, 0x00,
+0x7F, 0x04, 0x08, 0x10, 0x7F, 0x00,
+0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00,
+0x7F, 0x09, 0x09, 0x09, 0x06, 0x00,
+0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00,
+0x7F, 0x09, 0x19, 0x29, 0x46, 0x00,
+0x26, 0x49, 0x49, 0x49, 0x32, 0x00,
+0x03, 0x01, 0x7F, 0x01, 0x03, 0x00,
+0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00,
+0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00,
+0x3F, 0x40, 0x38, 0x40, 0x3F, 0x00,
+0x63, 0x14, 0x08, 0x14, 0x63, 0x00,
+0x03, 0x04, 0x78, 0x04, 0x03, 0x00,
+0x61, 0x59, 0x49, 0x4D, 0x43, 0x00,
+0x00, 0x7F, 0x41, 0x41, 0x41, 0x00,
+0x02, 0x04, 0x08, 0x10, 0x20, 0x00,
+0x00, 0x41, 0x41, 0x41, 0x7F, 0x00,
+0x04, 0x02, 0x01, 0x02, 0x04, 0x00,
+0x40, 0x40, 0x40, 0x40, 0x40, 0x00,
+0x00, 0x03, 0x07, 0x08, 0x00, 0x00,
+0x20, 0x54, 0x54, 0x78, 0x40, 0x00,
+0x7F, 0x28, 0x44, 0x44, 0x38, 0x00,
+0x38, 0x44, 0x44, 0x44, 0x28, 0x00,
+0x38, 0x44, 0x44, 0x28, 0x7F, 0x00,
+0x38, 0x54, 0x54, 0x54, 0x18, 0x00,
+0x00, 0x08, 0x7E, 0x09, 0x02, 0x00,
+0x18, 0x24, 0x24, 0x1C, 0x78, 0x00,
+0x7F, 0x08, 0x04, 0x04, 0x78, 0x00,
+0x00, 0x44, 0x7D, 0x40, 0x00, 0x00,
+0x20, 0x40, 0x40, 0x3D, 0x00, 0x00,
+0x7F, 0x10, 0x28, 0x44, 0x00, 0x00,
+0x00, 0x41, 0x7F, 0x40, 0x00, 0x00,
+0x7C, 0x04, 0x78, 0x04, 0x78, 0x00,
+0x7C, 0x08, 0x04, 0x04, 0x78, 0x00,
+0x38, 0x44, 0x44, 0x44, 0x38, 0x00,
+0x7C, 0x18, 0x24, 0x24, 0x18, 0x00,
+0x18, 0x24, 0x24, 0x18, 0x7C, 0x00,
+0x7C, 0x08, 0x04, 0x04, 0x08, 0x00,
+0x48, 0x54, 0x54, 0x54, 0x24, 0x00,
+0x04, 0x04, 0x3F, 0x44, 0x24, 0x00,
+0x3C, 0x40, 0x40, 0x20, 0x7C, 0x00,
+0x1C, 0x20, 0x40, 0x20, 0x1C, 0x00,
+0x3C, 0x40, 0x30, 0x40, 0x3C, 0x00,
+0x44, 0x28, 0x10, 0x28, 0x44, 0x00,
+0x4C, 0x90, 0x90, 0x90, 0x7C, 0x00,
+0x44, 0x64, 0x54, 0x4C, 0x44, 0x00,
+0x00, 0x08, 0x36, 0x41, 0x00, 0x00,
+0x00, 0x00, 0x77, 0x00, 0x00, 0x00,
+0x00, 0x41, 0x36, 0x08, 0x00, 0x00,
+0x02, 0x01, 0x02, 0x04, 0x02, 0x00,
+0x3C, 0x26, 0x23, 0x26, 0x3C, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0xC0, 0xE0,
+0xF0, 0xF8, 0xF8, 0x18, 0x00, 0xC0,
+0xF0, 0xFC, 0xFE, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x80, 0xC0, 0xE0, 0xE0,
+0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,
+0xC0, 0x80, 0x00, 0x00, 0x00, 0x00,
+0x80, 0xC0, 0xE0, 0xE0, 0xE0, 0xE0,
+0xE0, 0xE0, 0xE0, 0xE0, 0xC0, 0x80,
+0x00, 0x00, 0x00, 0xE0, 0xE0, 0xC0,
+0xC0, 0xE0, 0xE0, 0xE0, 0xE0, 0x00,
+0x00, 0xE0, 0xE0, 0xC0, 0xC0, 0xE0,
+0xE0, 0xE0, 0xE0, 0xE0, 0xC0, 0x80,
+0x00, 0x00, 0x00, 0x00, 0x80, 0xC0,
+0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,
+0xE0, 0xE0, 0xC0, 0x80, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0xE0, 0xF0, 0xF0, 0xF0, 0xE0, 0xEC,
+0xEE, 0xF7, 0xF3, 0x70, 0x20, 0x00,
+0x7C, 0x7C, 0x7C, 0x7E, 0x00, 0x7E,
+0x7E, 0x7E, 0x7F, 0x7F, 0x7F, 0x00,
+0x00, 0x80, 0xC0, 0xE0, 0x7E, 0x5B,
+0x4F, 0x5B, 0xFE, 0xC0, 0x00, 0x00,
+0xC0, 0x00, 0xDC, 0xD7, 0xDE, 0xDE,
+0xDE, 0xD7, 0xDC, 0x00, 0xC0, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0xF8, 0xFC, 0xFE,
+0xFF, 0xE0, 0x00, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0x80, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0x1F, 0x07, 0x01, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0xFF, 0xFF, 0xFF, 0x81, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x81,
+0xC3, 0xC3, 0xC3, 0x00, 0x00, 0xFF,
+0xFF, 0xFF, 0x81, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x81, 0xFF, 0xFF,
+0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
+0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0xFF, 0xFF, 0xFF, 0x01, 0x00,
+0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF,
+0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
+0x9D, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C,
+0x1C, 0x9D, 0xDF, 0xDF, 0xDF, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x0F, 0x1F, 0x3F, 0x7F, 0x7F, 0x7F,
+0x7F, 0x7F, 0x3F, 0x1E, 0x0C, 0x00,
+0x1F, 0x1F, 0x1F, 0x3F, 0x00, 0x3F,
+0x3F, 0x3F, 0x7F, 0x7F, 0x7F, 0x00,
+0x30, 0x7B, 0x7F, 0x78, 0x30, 0x20,
+0x20, 0x30, 0x78, 0x7F, 0x3B, 0x00,
+0x03, 0x00, 0x0F, 0x7F, 0x0F, 0x0F,
+0x0F, 0x7F, 0x0F, 0x00, 0x03, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x03, 0x0F, 0x1F,
+0x3F, 0x3F, 0x3F, 0x3F, 0x1F, 0x1F,
+0x3F, 0x3F, 0x7F, 0x7F, 0x7F, 0x3F,
+0x3F, 0x1F, 0x3F, 0x7F, 0x7F, 0x7F,
+0x7F, 0x7C, 0x78, 0x78, 0x38, 0x1C,
+0x0F, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x01, 0x03, 0x07, 0x07,
+0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+0x03, 0x01, 0x00, 0x00, 0x00, 0x00,
+0x01, 0x03, 0x07, 0x07, 0x07, 0x07,
+0x07, 0x07, 0x07, 0x07, 0x03, 0x01,
+0x00, 0x00, 0x00, 0x07, 0x07, 0x07,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x07, 0x07, 0x07, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x07, 0x07,
+0x07, 0x00, 0x00, 0x00, 0x01, 0x03,
+0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+0x07, 0x07, 0x03, 0x01, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};

keyboards/crkbd/keymaps/drashna/keymap.c

@@ -7,6 +7,9 @@
 #ifdef SSD1306OLED
   #include "ssd1306.h"
 #endif
+#ifdef OLED_DRIVER_ENABLE
+  #include "oled_driver.h"
+#endif
 
 extern keymap_config_t keymap_config;
 extern uint8_t is_master;
@@ -288,3 +291,123 @@ bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
 }
 
 #endif
+
+
+#ifdef OLED_DRIVER_ENABLE
+oled_rotation_t oled_init_user(oled_rotation_t rotation) {
+  if (is_master) {
+    return OLED_ROTATION_270;
+  } else {
+    return rotation;
+  }
+}
+
+void render_crkbd_logo(void) {
+  static const char PROGMEM crkbd_logo[] = {
+      0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94,
+      0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4,
+      0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4,
+      0};
+  oled_write_P(crkbd_logo, false);
+}
+
+
+void render_status(void) {
+
+  oled_write_P(PSTR("Layer"), false);
+  switch (biton32(layer_state)) {
+    case 0:
+      oled_write_P(PSTR("Base "), false);
+      break;
+    case _RAISE:
+      oled_write_P(PSTR("Raise"), false);
+      break;
+    case _LOWER:
+      oled_write_P(PSTR("Lower"), false);
+      break;
+    case _ADJUST:
+      oled_write_P(PSTR("Adjst"), false);
+      break;
+    default:
+      oled_write_P(PSTR("Unkn "), false);
+      break;
+  }
+  oled_write_P(PSTR("Lyout"), false);
+  switch (biton32(default_layer_state)) {
+    case _QWERTY:
+      oled_write_P(PSTR("QWRTY"), false);
+      break;
+    case _COLEMAK:
+      oled_write_P(PSTR("COLMK"), false);
+      break;
+    case _DVORAK:
+      oled_write_P(PSTR("DVRAK"), false);
+      break;
+    case _WORKMAN:
+      oled_write_P(PSTR("WRKMN"), false);
+      break;
+    case _NORMAN:
+      oled_write_P(PSTR("NORMN"), false);
+      break;
+    case _MALTRON:
+      oled_write_P(PSTR("MLTRN"), false);
+      break;
+    case _EUCALYN:
+      oled_write_P(PSTR("ECLYN"), false);
+      break;
+    case _CARPLAX:
+      oled_write_P(PSTR("CRPLX"), false);
+      break;
+  }
+
+  uint8_t modifiers = get_mods();
+  uint8_t one_shot = get_oneshot_mods();
+
+  oled_write_P(PSTR("Mods:"), false);
+  oled_write_P( (modifiers & MOD_MASK_CTRL  || one_shot & MOD_MASK_CTRL ) ? PSTR(" CTL ") : PSTR("     "), false);
+  oled_write_P( (modifiers & MOD_MASK_GUI   || one_shot & MOD_MASK_GUI  ) ? PSTR(" GUI ") : PSTR("     "), false);
+  oled_write_P( (modifiers & MOD_MASK_ALT   || one_shot & MOD_MASK_ALT  ) ? PSTR(" ALT ") : PSTR("     "), false);
+  oled_write_P( (modifiers & MOD_MASK_SHIFT || one_shot & MOD_MASK_SHIFT) ? PSTR(" SFT ") : PSTR("     "), false);
+
+
+  oled_write_P(PSTR("BTMGK"), false);
+  static const char PROGMEM mode_logo[4][4] = {
+    {0x95,0x96,0x0a,0},
+    {0xb5,0xb6,0x0a,0},
+    {0x97,0x98,0x0a,0},
+    {0xb7,0xb8,0x0a,0} };
+
+  if (keymap_config.swap_lalt_lgui != false) {
+    oled_write_P(mode_logo[0], false);
+    oled_write_P(mode_logo[1], false);
+  } else {
+    oled_write_P(mode_logo[2], false);
+    oled_write_P(mode_logo[3], false);
+  }
+
+  uint8_t led_usb_state = host_keyboard_leds();
+  oled_write_P(PSTR("Lock:"), false);
+  oled_write_P(led_usb_state & (1<<USB_LED_NUM_LOCK)    ? PSTR(" NUM ") : PSTR("     "), false);
+  oled_write_P(led_usb_state & (1<<USB_LED_CAPS_LOCK)   ? PSTR(" CAPS") : PSTR("     "), false);
+  oled_write_P(led_usb_state & (1<<USB_LED_SCROLL_LOCK) ? PSTR(" SCRL") : PSTR("     "), false);
+}
+
+
+void oled_task_user(void) {
+  if (is_master) {
+    render_status();     // Renders the current keyboard state (layer, lock, caps, scroll, etc)
+  } else {
+    render_crkbd_logo();
+    oled_scroll_left();  // Turns on scrolling
+  }
+}
+#endif
+
+uint16_t get_tapping_term(uint16_t keycode) {
+  switch (keycode) {
+    case ALT_T(KC_A):
+      return TAPPING_TERM + 100;
+    default:
+      return TAPPING_TERM;
+  }
+}

keyboards/crkbd/keymaps/drashna/rules.mk

@@ -3,31 +3,24 @@
 #   change to "no" to disable the options, or define them in the Makefile in
 #   the appropriate keymap folder that will get included automatically
 #
-BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration(+1000)
-MOUSEKEY_ENABLE = no        # 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
-NKRO_ENABLE = yes           # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
-BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality
-MIDI_ENABLE = no            # MIDI controls
-AUDIO_ENABLE = no           # Audio output on port C6
-UNICODE_ENABLE = no         # Unicode
-BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
-RGBLIGHT_ENABLE = yes       # Enable WS2812 RGB underlight.
-SWAP_HANDS_ENABLE = no      # Enable one-hand typing
+BOOTMAGIC_ENABLE           = no  # Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE            = no  # 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
+NKRO_ENABLE                = yes # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+BACKLIGHT_ENABLE           = no  # Enable keyboard backlight functionality
+MIDI_ENABLE                = no  # MIDI controls
+AUDIO_ENABLE               = no  # Audio output on port C6
+UNICODE_ENABLE             = no  # Unicode
+BLUETOOTH_ENABLE           = no  # Enable Bluetooth with the Adafruit EZ-Key HID
+RGBLIGHT_ENABLE            = yes # Enable WS2812 RGB underlight.
+SWAP_HANDS_ENABLE          = no  # Enable one-hand typing
+RGBLIGHT_STARTUP_ANIMATION = yes
 
 # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
 SLEEP_LED_ENABLE = no    # Breathing sleep LED during USB suspend
 
 BOOTLOADER = qmk-dfu
 
-# If you want to change the display of OLED, you need to change here
-SRC +=  ./lib/glcdfont.c \
-        ./lib/logo_reader.c \
-        # ./lib/rgb_state_reader.c \
-        # ./lib/keylogger.c \
-        # ./lib/host_led_state_reader.c \
-        # ./lib/mode_icon_reader.c \
-        # ./lib/layer_state_reader.c \
-        # ./lib/timelogger.c \
+OLED_DRIVER_ENABLE = yes