Fix tapdance when one-shot is disabled.

According to @fredizzimo, this is a safer and easier way to handle the
boilerplate.

.gitmodules

@@ -1,7 +1,6 @@
 [submodule "lib/chibios"]
 	path = lib/chibios
 	url = https://github.com/qmk/ChibiOS
-  branch = handwire
 [submodule "lib/chibios-contrib"]
 	path = lib/chibios-contrib
 	url = https://github.com/qmk/ChibiOS-Contrib

Vagrantfile

@@ -2,27 +2,8 @@
 # vi: set ft=ruby :
 
 Vagrant.configure(2) do |config|
-  # You can only have one config.vm.box uncommented at a time
-
-  # Comment this and uncomment another if you don't want to use the minimal Arch box
-  #config.vm.box = "dragon788/arch-ala-elasticdog"
-
   # VMware/Virtualbox 64 bit
   config.vm.box = "phusion/ubuntu-14.04-amd64"
-  #
-  # VMware/Virtualbox 64 bit
-  #config.vm.box = "puphpet/centos65-x64"
-  #
-  # The opensuse boxes don't have dfu-util in their default repositories
-  #
-  # The virtualbox version has tools issues
-  # VMware/Virtualbox 64 bit
-  #config.vm.box = "bento/opensuse-13.2-x86_64"
-  #
-  # Virtualbox only
-  #config.vm.box = "bento/opensuse-13.2-i386"
-  # config.vm.box = ""
-  # config.vm.box = ""
 
   # This section allows you to customize the Virtualbox VM
   # settings, ie showing the GUI or upping the memory
@@ -81,18 +62,16 @@ Vagrant.configure(2) do |config|
   config.vm.provision "shell", run: "always", path: "./util/install_dependencies.sh", args: "-update"
 
   config.vm.post_up_message = <<-EOT
-  Log into the VM using 'vagrant ssh' on OSX or from Git Bash (Win)
-  or 'vagrant ssh-config' and Putty or Bitvise SSH or another SSH tool
 
-  Change directory (cd) to the keyboard you wish to program
-  (Optionally) modify your layout,
-  then run 'make clean'
-  and then 'make' to compile the .eep and .hex files.
-
-  Or you can copy and paste the example line below.
-
-  cd /vagrant; cd keyboards; cd ergodox; make clean; make
+  Log into the VM using 'vagrant ssh'. QMK directory synchronized with host is
+  located at /vagrant
+  To compile the .hex files use make command inside this directory.
 
+  QMK's make format recently changed to use folder locations and colons:
+     make project_folder:keymap[:target]
+  Examples:
+     make planck/rev4:default:dfu
+     make planck:default
 
   EOT
 end

common.mk

@@ -3,16 +3,16 @@ include message.mk
 # Directory common source files exist
 TOP_DIR = .
 TMK_DIR = tmk_core
-TMK_PATH = $(TMK_DIR)
-LIB_PATH = lib
+TMK_PATH = $(TOP_DIR)/$(TMK_DIR)
+LIB_PATH = $(TOP_DIR)/lib
 
 QUANTUM_DIR = quantum
-QUANTUM_PATH = $(QUANTUM_DIR)
+QUANTUM_PATH = $(TOP_DIR)/$(QUANTUM_DIR)
 
 DRIVER_DIR = drivers
-DRIVER_PATH = $(DRIVER_DIR)
+DRIVER_PATH = $(TOP_DIR)/$(DRIVER_DIR)
 
-BUILD_DIR := .build
+BUILD_DIR := $(TOP_DIR)/.build
 
 COMMON_VPATH := $(TOP_DIR)
 COMMON_VPATH += $(TMK_PATH)
@@ -21,4 +21,4 @@ COMMON_VPATH += $(QUANTUM_PATH)/keymap_extras
 COMMON_VPATH += $(QUANTUM_PATH)/audio
 COMMON_VPATH += $(QUANTUM_PATH)/process_keycode
 COMMON_VPATH += $(QUANTUM_PATH)/api
-COMMON_VPATH += $(DRIVER_PATH)
+COMMON_VPATH += $(DRIVER_PATH)

common_features.mk

@@ -20,13 +20,6 @@ SERIAL_SRC += $(wildcard $(SERIAL_PATH)/system/*.c)
 SERIAL_DEFS += -DSERIAL_LINK_ENABLE
 COMMON_VPATH += $(SERIAL_PATH)
 
-COMMON_VPATH += $(DRIVER_PATH)
-ifeq ($(PLATFORM),AVR)
-  COMMON_VPATH += $(DRIVER_PATH)/avr
-else
-  COMMON_VPATH += $(DRIVER_PATH)/arm
-endif
-
 ifeq ($(strip $(API_SYSEX_ENABLE)), yes)
     OPT_DEFS += -DAPI_SYSEX_ENABLE
     SRC += $(QUANTUM_DIR)/api/api_sysex.c
@@ -124,7 +117,7 @@ endif
 ifeq ($(strip $(RGB_MATRIX_ENABLE)), yes)
     OPT_DEFS += -DRGB_MATRIX_ENABLE
     SRC += is31fl3731.c
-    I2C_ENABLE = yes
+    SRC += i2c_master.c
     SRC += $(QUANTUM_DIR)/color.c
     SRC += $(QUANTUM_DIR)/rgb_matrix.c
     CIE1931_CURVE = yes
@@ -204,25 +197,6 @@ ifeq ($(strip $(USB_HID_ENABLE)), yes)
     include $(TMK_DIR)/protocol/usb_hid.mk
 endif
 
-ifeq ($(strip $(I2C_SLAVE_ENABLE)), yes)
-    I2C_ENABLE = yes
-    OPT_DEFS += -DI2C_SLAVE_ENABLE
-endif
-
-ifeq ($(strip $(ENCODER_ENABLE)), yes)
-    OPT_DEFS += -DENCODER_ENABLE
-    SRC += $(QUANTUM_DIR)/encoder.c
-endif
-
-ifeq ($(strip $(QWIIC_KEYBOARD_ENABLE)), yes)
-    SRC += qwiic/qwiic_keyboard.c
-    OPT_DEFS += -DQWIIC_KEYBOARD_ENABLE
-endif
-
-ifeq ($(strip $(I2C_ENABLE)), yes)
-    SRC += twi2c.c
-endif
-
 QUANTUM_SRC:= \
     $(QUANTUM_DIR)/quantum.c \
     $(QUANTUM_DIR)/keymap_common.c \

docs/_summary.md

@@ -34,7 +34,6 @@
   * [Bootmagic](feature_bootmagic.md)
   * [Command](feature_command.md)
   * [Dynamic Macros](feature_dynamic_macros.md)
-  * [Encoders](feature_encoders.md)
   * [Grave Escape](feature_grave_esc.md)
   * [Key Lock](feature_key_lock.md)
   * [Layouts](feature_layouts.md)

docs/config_options.md

@@ -123,21 +123,23 @@ If you define these options you will enable the associated feature, which may in
 ## Behaviors That Can Be Configured
 
 * `#define TAPPING_TERM 200`
-  * how long before a tap becomes a hold
+  * how long before a tap becomes a hold, if set above 500, a key tapped during the tapping term will turn it into a hold too
 * `#define RETRO_TAPPING`
   * tap anyway, even after TAPPING_TERM, if there was no other key interruption between press and release
 * `#define TAPPING_TOGGLE 2`
   * how many taps before triggering the toggle
 * `#define PERMISSIVE_HOLD`
   * makes tap and hold keys work better for fast typers who don't want tapping term set above 500
+* `#define IGNORE_MOD_TAP_INTERRUPT`
+  * makes it possible to do rolling combos (zx) with keys that convert to other keys on hold
+* `#define TAPPING_FORCE_HOLD`
+  * makes it possible to use a dual role key as modifier shortly after having been tapped
 * `#define LEADER_TIMEOUT 300`
   * how long before the leader key times out
 * `#define ONESHOT_TIMEOUT 300`
   * how long before oneshot times out
 * `#define ONESHOT_TAP_TOGGLE 2`
   * how many taps before oneshot toggle is triggered
-* `#define IGNORE_MOD_TAP_INTERRUPT`
-  * makes it possible to do rolling combos (zx) with keys that convert to other keys on hold
 * `#define QMK_KEYS_PER_SCAN 4`
   * Allows sending more than one key per scan. By default, only one key event gets
     sent via `process_record()` per scan. This has little impact on most typing, but

docs/contributing.md

@@ -11,7 +11,7 @@ Third-party contributions help us grow and improve QMK. We want to make the pull
 
 ## I Don't Want to Read This Whole Thing! I Just Have a Question!
 
-If you'd like to ask questions about QMK you can do so on the [OLKB Subreddit](https://reddit.com/r/olkb) or on [Gitter](https://gitter.im/qmk/qmk_firmware).
+If you'd like to ask questions about QMK you can do so on the [OLKB Subreddit](https://reddit.com/r/olkb) or on [Discord](https://discord.gg/Uq7gcHh).
 
 Please keep these things in mind:
 
@@ -29,7 +29,7 @@ QMK is largely written in C, with specific features and parts written in C++. It
 
 # Where Can I Go for Help?
 
-If you need help you can [open an issue](https://github.com/qmk/qmk_firmware/issues) or [chat on gitter](http://gitter.im/QMK/qmk_firmware).
+If you need help you can [open an issue](https://github.com/qmk/qmk_firmware/issues) or [chat on Discord](https://discord.gg/Uq7gcHh).
 
 # How Do I Make a Contribution?
 
@@ -124,7 +124,7 @@ We also ask that you follow these guidelines:
 
 Before you put a lot of work into building your new feature you should make sure you are implementing it in the best way. You can get a basic understanding of QMK by reading [Understanding QMK](understanding_qmk.md), which will take you on a tour of the QMK program flow. From here you should talk to us to get a sense of the best way to implement your idea. There are two main ways to do this:
 
-* [Chat on Gitter](https://gitter.im/qmk/qmk_firmware)
+* [Chat on Discord](https://discord.gg/Uq7gcHh)
 * [Open an Issue](https://github.com/qmk/qmk_firmware/issues/new)
 
 Feature and Bug Fix PR's affect all keyboards. We are also in the process of restructuring QMK. For this reason it is especially important for significant changes to be discussed before implementation has happened. If you open a PR without talking to us first please be prepared to do some significant rework if your choices do not mesh well with our planned direction.

docs/custom_quantum_functions.md

@@ -135,9 +135,11 @@ void led_set_user(uint8_t usb_led) {
 * Keyboard/Revision: `void led_set_kb(uint8_t usb_led)`
 * Keymap: `void led_set_user(uint8_t usb_led)`
 
+
 # Matrix Initialization Code
 
-Before a keyboard can be used the hardware must be initialized. QMK handles initialization of the keyboard matrix itself, but if you have other hardware like LED's or i²c controllers you will need to set up that hardware before it can be used.
+Before a keyboard can be used the hardware must be initialized. QMK handles initialization of the keyboard matrix itself, but if you have other hardware like LED's or i²c controllers you will need to set up that hardware before it can be used.  
+
 
 ### Example `matrix_init_user()` Implementation
 
@@ -165,7 +167,7 @@ Whenever possible you should customize your keyboard by using `process_record_*(
 
 ### Example `matrix_scan_*` Implementation
 
-This example has been deliberately omitted. You should understand enough about QMK internals to write this without an example before hooking into such a performance sensitive area. If you need help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) or [chat with us on gitter](https://gitter.im/qmk/qmk_firmware).
+This example has been deliberately omitted. You should understand enough about QMK internals to write this without an example before hooking into such a performance sensitive area. If you need help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) or [chat with us on Discord](https://discord.gg/Uq7gcHh).
 
 ### `matrix_scan_*` Function Documentation
 
@@ -177,9 +179,38 @@ This function gets called at every matrix scan, which is basically as often as t
 You should use this function if you need custom matrix scanning code. It can also be used for custom status output (such as LED's or a display) or other functionality that you want to trigger regularly even when the user isn't typing.
 
 
+# Keyboard Idling/Wake Code
+
+If the board supports it, it can be "idled", by stopping a number of functions.  A good example of this is RGB lights or backlights.   This can save on power consumption, or may be better behavior for your keyboard.  
+
+This is controlled by two functions: `suspend_power_down_*` and `suspend_wakeup_init_*`, which are called when the system is board is idled and when it wakes up, respectively. 
+
+
+### Example suspend_power_down_user() and suspend_wakeup_init_user() Implementation
+
+This example, at the keyboard level, sets up B1, B2, and B3 as LED pins.
+
+```
+void suspend_power_down_user(void)
+{
+    rgb_matrix_set_suspend_state(true);
+}
+
+void suspend_wakeup_init_user(void)
+{
+    rgb_matrix_set_suspend_state(false);
+}
+
+```
+
+### `keyboard_init_*` Function Documentation
+
+* Keyboard/Revision: `void suspend_power_down_kb(void)` and `void suspend_wakeup_init_user(void)`
+* Keymap: `void suspend_power_down_kb(void)` and `void suspend_wakeup_init_user(void)`
+
 # Layer Change Code
 
-Thir runs code every time that the layers get changed.  This can be useful for layer indication, or custom layer handling. 
+This runs code every time that the layers get changed.  This can be useful for layer indication, or custom layer handling. 
 
 ### Example `layer_state_set_*` Implementation
 

docs/faq_build.md

@@ -104,3 +104,17 @@ brew install dfu-programmer
 brew install gcc-arm-none-eabi
 brew install avrdude
 ```
+
+### avr-gcc 8.1 and LUFA
+
+If you updated your avr-gcc to above 7 you may see errors involving LUFA. For example:
+
+`lib/lufa/LUFA/Drivers/USB/Class/Device/AudioClassDevice.h:380:5: error: 'const' attribute on function returning 'void'`
+
+For now, you need to rollback avr-gcc to 7 in brew.
+
+```
+brew uninstall --force avr-gcc
+brew install avr-gcc@7
+brew link avr-gcc@7
+```

docs/feature_advanced_keycodes.md

@@ -175,3 +175,31 @@ Example: (Tapping Term = 200ms)
 - SHFT_T(KC_A) Up
 
 With defaults, if above is typed within tapping term, this will emit `ax`. With permissive hold, if above is typed within tapping term, this will emit `X` (so, Shift+X).
+
+# Mod tap interrupt
+
+When a dual role key used for a modifier is quickly followed by another keys, it is interpreted as held even before the tapping term elapsed.  This is a problem if a key is used for example inside a rolling combo because the second key will be pressed before the first key is released.
+
+For example, when trying to type the rolling combo "zx" and z being configured to send Ctrl when hold, z rapidly followed by x actually sends Ctrl-x. That's bad.
+
+You can disable this behavior by defining `IGNORE_MOD_TAP_INTERRUPT` in `config.h`.
+
+Note that this only concerns modifiers and not layer switching keys.
+
+# Hold after tap
+
+When the user holds a key after tap, this repeats the tapped key rather to hold a modifier key.  This allows to use auto repeat for the tapped key.  If you prefer to hold a modifier instead, define `TAPPING_FORCE_HOLD` in `config.h`.
+
+Example:
+
+- SHFT_T(KC_A) Down
+- SHFT_T(KC_A) Up
+- SHFT_T(KC_A) Down
+- wait more than tapping term...
+- SHFT_T(KC_A) Up
+
+With default settings, `a` will be sent on the first release, then `a` will be sent on the second press allowing the computer to trigger its auto repeat function.
+
+With `TAPPING_FORCE_HOLD`, the second press will be interpreted as a Shift, allowing to use it as a modifier shortly after having used it as a tap.
+
+!> `TAPPING_FORCE_HOLD` will break anything that uses tapping toggles (Such as the `TT` layer keycode, and the One Shot Tapping Toggle).

docs/feature_encoders.md

@@ -1,41 +0,0 @@
-# Encoders
-
-Basic encoders are supported by adding this to your `rules.mk`:
-
-    ENCODER_ENABLE = yes
-
-and this to your `config.h`:
-
-    #define NUMBER_OF_ENCODERS 1
-    #define ENCODERS_PAD_A { B12 }
-    #define ENCODERS_PAD_B { B13 }
-
-Each PAD_A/B variable defines an array so multiple encoders can be defined, e.g.:
-
-    #define ENCODERS_PAD_A { encoder1a, encoder2a }
-    #define ENCODERS_PAD_B { encoder1a, encoder2b }
-
-If your encoder's clockwise directions are incorrect, you can swap the A & B pad definitions.
-
-Additionally, the resolution can be specified in the same file (the default & suggested is 4):
-
-    #define ENCODER_RESOLUTION 4
-
-## Callbacks
-
-The callback functions can be inserted into your `<keyboard>.c`:
-
-    void encoder_update_kb(uint8_t index, bool clockwise) {
-        encoder_update_user(index, clockwise);
-    }
-
-or `keymap.c`:
-
-    void encoder_update_user(uint8_t index, bool clockwise) {
-        
-    }
-
-
-## Hardware
-
-The A an B lines of the encoders should be wired directly to the MCU, and the C/common lines should be wired to ground.

docs/feature_rgb_matrix.md

@@ -119,6 +119,7 @@ A similar function works in the keymap as `rgb_matrix_indicators_user`.
 	#define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
 	#define RGB_DISABLE_WHEN_USB_SUSPENDED false // turn off effects when suspended
     #define RGB_MATRIX_SKIP_FRAMES 1 // number of frames to skip when displaying animations (0 is full effect) if not defined defaults to 1
+    #define RGB_MATRIX_MAXIMUM_BRIGHTNESS 200 // limits maximum brightness of LEDs to 200 out of 255. If not defined maximum brightness is set to 255
 
 ## EEPROM storage
 

docs/feature_rgblight.md

@@ -146,6 +146,7 @@ These control the RGB Lighting functionality.
 |`RGB_MODE_KNIGHT`  |`RGB_M_K` |"Knight Rider" animation mode                                       |
 |`RGB_MODE_XMAS`    |`RGB_M_X` |Christmas animation mode                                            |
 |`RGB_MODE_GRADIENT`|`RGB_M_G` |Static gradient animation mode                                      |
+|`RGB_MODE_RGBTEST `|`RGB_M_T` |Red,Green,Blue test animation mode                                  |
 
 note: for backwards compatibility, `RGB_SMOD` is an alias for `RGB_MOD`.
 

docs/getting_started_build_tools.md

@@ -56,7 +56,7 @@ If you're using [homebrew,](http://brew.sh/) you can use the following commands:
     brew tap osx-cross/avr
     brew tap PX4/homebrew-px4
     brew update
-    brew install avr-gcc
+    brew install avr-gcc@7
     brew install dfu-programmer
     brew install gcc-arm-none-eabi
     brew install avrdude

docs/getting_started_getting_help.md

@@ -4,13 +4,7 @@ There are a lot of resources for getting help with QMK.
 
 ## Realtime Chat
 
-You can find QMK developers and users on our main [gitter chat room](https://gitter.im/qmk/qmk_firmware). We also have other rooms for more specific discussion:
-
-* [Main Firmware Chat](https://gitter.im/qmk/qmk_firmware)
-* [QMK Toolbox](https://gitter.im/qmk/qmk_toolbox)
-* [Hardware Design Discussion](https://gitter.im/qmk/qmk_hardware)
-* [Web Configurator](https://gitter.im/qmk/qmk_configurator)
-* [Compiler API](https://gitter.im/qmk/qmk_compiler_api)
+You can find QMK developers and users on our main [Discord server](https://discord.gg/Uq7gcHh). There are specific channels in the server for chatting about the firmware, Toolbox, hardware, and configurator.
 
 ## OLKB Subreddit
 

docs/getting_started_introduction.md

@@ -6,12 +6,16 @@ This page attempts to explain the basic information you need to know to work wit
 
 QMK is a fork of [Jun Wako](https://github.com/tmk)'s [tmk_keyboard](https://github.com/tmk/tmk_keyboard) project. The original TMK code, with modifications, can be found in the `tmk` folder. The QMK additions to the project may be found in the `quantum` folder. Keyboard projects may be found in the `handwired` and `keyboard` folders.
 
+### Userspace Structure
+
+Within the folder `users` is a directory for each user. This is a place for users to put code that they might use between keyboards. See the docs for [Userspace feature](feature_userspace.md) for more information.
+
 ### Keyboard Project Structure
 
 Within the folder `keyboards` and its subfolder `handwired` is a directory for each keyboard project, for example `qmk_firmware/keyboards/clueboard`. Within it you'll find the following structure:
 
 * `keymaps/`: Different keymaps that can be built
-* `rules.mk`: The file that sets the default "make" options. Do not edit this file directly, instead use a keymap specific `Makefile`
+* `rules.mk`: The file that sets the default "make" options. Do not edit this file directly, instead use a keymap specific `rules.mk`.
 * `config.h`: The file that sets the default compile time options. Do not edit this file directly, instead use a keymap specific `config.h`.
 
 ### Keymap Structure
@@ -25,23 +29,26 @@ In every keymap folder, the following files may be found. Only `keymap.c` is req
 
 # The `config.h` File
 
-There are 2 `config.h` locations:
+There are 3 possible `config.h` locations:
 
 * keyboard (`/keyboards/<keyboard>/config.h`)
+* userspace (`/users/<user>/config.h`)
 * keymap (`/keyboards/<keyboard>/keymaps/<keymap>/config.h`)
 
-If the keymap `config.h` exists, that file is included by the build system and the keyboard `config.h` is not included. If you wish to override settings in your keymap's `config.h` you will need to include some glue code:
+The build system automatically picks up the config files in the above order. If you wish to override any setting set by a previous `config.h` you will need to first include some boilerplate code for the settings you wish to change.
 
 ```
-#ifndef CONFIG_USER_H
-#define CONFIG_USER_H
-
-#include "config_common.h"
+#pragma once
 ```
 
-If you want to override a setting from the parent `config.h` file, you need to `#undef` and then `#define` the setting again, like this:
+Then to override a setting from the previous `config.h` file you must `#undef` and then `#define` the setting again.
 
-```c
+The boilerplate code and setting look like this together:
+
+```
+#pragma once
+
+// overrides go here!
 #undef MY_SETTING
 #define MY_SETTING 4
 ```

docs/hardware_keyboard_guidelines.md

@@ -47,16 +47,6 @@ The `info.json` file is a JSON formatted dictionary with the following keys avai
   * Example: `Clueboard 66%`
 * `url`
   * A URL to the keyboard's product page, [QMK.fm/keyboards](https://qmk.fm/keyboards) page, or other page describing information about the keyboard.
-* `bootloader`
-  * What bootloader this keyboard uses. Available options:
-    * `atmel-dfu`
-    * `kiibohd-dfu-util`
-    * `lufa-dfu`
-    * `qmk-dfu`
-    * `stm32-dfu-util`
-    * `caterina`
-    * `halfkay`
-    * `bootloadHID`
 * `maintainer`
   * GitHub username of the maintainer, or `qmk` for community maintained boards
 * `width`

docs/keycodes.md

@@ -167,6 +167,7 @@ This is a reference only. Each group of keys links to the page documenting their
 |`KC_MEDIA_STOP`        |`KC_MSTP`           |Stop Track                                     |
 |`KC_MEDIA_PLAY_PAUSE`  |`KC_MPLY`           |Play/Pause Track                               |
 |`KC_MEDIA_SELECT`      |`KC_MSEL`           |                                               |
+|`KC_MEDIA_EJECT`       |`KC_EJCT`           |Eject (macOS)                                  |
 |`KC_NUMLOCK`           |`KC_NLCK`           |Keypad Num Lock and Clear                      |
 |`KC_KP_SLASH`          |`KC_PSLS`           |Keypad `/`                                     |
 |`KC_KP_ASTERISK`       |`KC_PAST`           |Keypad `*`                                     |
@@ -283,6 +284,7 @@ This is a reference only. Each group of keys links to the page documenting their
 |`RGB_MODE_KNIGHT`  |`RGB_M_K` |"Knight Rider" animation mode                                       |
 |`RGB_MODE_XMAS`    |`RGB_M_X` |Christmas animation mode                                            |
 |`RGB_MODE_GRADIENT`|`RGB_M_G` |Static gradient animation mode                                      |
+|`RGB_MODE_RGBTEST` |`RGB_M_T` |Red,Green,Blue test animation mode                                  |
 
 ## [RGB Matrix Lighting](feature_rgb_matrix.md)
 

docs/keycodes_basic.md

@@ -194,6 +194,7 @@ Windows and macOS use different keycodes for "next track" and "previous track".
 |`KC_MEDIA_STOP`        |`KC_MSTP`|Stop Track                       |
 |`KC_MEDIA_PLAY_PAUSE`  |`KC_MPLY`|Play/Pause Track                 |
 |`KC_MEDIA_SELECT`      |`KC_MSEL`|                                 |
+|`KC_MEDIA_EJECT`       |`KC_EJCT`|Eject (macOS)                    |
 
 ## Number Pad
 

docs/newbs.md

@@ -1,4 +1,4 @@
-# The Compelete Newbs Guide To QMK
+# The Complete Newbs Guide To QMK
 
 QMK is a powerful Open Source firmware for your mechanical keyboard. You can use QMK to customize your keyboard in ways both simple and powerful. People of all skill levels, from complete newbie to master programmer, have successfully used QMK to customize their keyboard. This guide will help you do the same, no matter your skill level.
 
@@ -12,5 +12,7 @@ There are 4 main sections to this guide:
 * [Building Your First Firmware](newbs_building_firmware.md)
 * [Flashing Firmware](newbs_flashing.md)
 * [Testing and Debugging](newbs_testing_debugging.md)
+* [Learn More with these Resources](newbs_learn_more_resources.md)
 
 This guide is focused on helping someone who has never compiled software before. It makes choices and recommendations based on that viewpoint. There are alternative methods for many of these procedures, and we support most of those alternatives. If you have any doubt about how to accomplish a task you can [ask us for guidance](getting_started_getting_help.md).
+

docs/newbs_learn_more_resources.md

@@ -0,0 +1,13 @@
+# Learning Resources
+These resources are aimed at giving new members in the qmk community more understanding to the information provided in the newbs docs.
+
+Git resources:
+*
+*[Great General Tutorial](https://www.codecademy.com/learn/learn-git)
+*[Git Game To Learn From Examples](https://learngitbranching.js.org/)
+*[Git Resources to Learn More About Github](getting_started_github.md)
+*[Git Resources Aimed Specificly toward QMK](contributing.md)
+
+
+Command Line resources:
+*[Good General Tutorial on Command Line](https://www.codecademy.com/learn/learn-the-command-line)

drivers/arm/twi2c.c

@@ -1,168 +0,0 @@
-/* Copyright 2018 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/>.
- */
-
-#include "twi2c.h"
-#include <string.h>
-#include <hal.h>
-#include "chprintf.h"
-#include "memstreams.h"
-#include "printf.h"
-#include "hal_i2cslave.h"
-
-/**
- * I2C slave test routine.
- *
- * To use: Add file to a project, call startComms() with the address of a serial stream
- *
- * There are two different responses:
- *  a) A read-only transaction - returns the "Initial Reply" message
- *  b) A write then read transaction - calls a message processor and returns the generated reply.
- *          Stretches clock until reply available.
- */
-// static const I2CConfig masterI2CConfig = {
-//   400000
-// };
-
-I2CSlaveMsgCB twi2c_incoming_message_process, twi2c_catch_error, twi2c_clear_after_send;
-twi2c_message_received twi2c_message_received_callback;
-
-static uint8_t twi2c_address;
-
-static const I2CConfig i2cconfig = {
-  STM32_TIMINGR_PRESC(15U) |
-  STM32_TIMINGR_SCLDEL(4U) | STM32_TIMINGR_SDADEL(2U) |
-  STM32_TIMINGR_SCLH(15U)  | STM32_TIMINGR_SCLL(21U),
-  0,
-  0
-};
-
-/**
- * Track I2C errors
- */
-uint8_t gotI2cError = 0;
-uint32_t lastI2cErrorFlags = 0;
-
-// Called from ISR to log error
-void noteI2cError(uint32_t flags)
-{
-  lastI2cErrorFlags = flags;
-  gotI2cError = 1;
-}
-
-/**
- * Generic error handler
- *
- * Called in interrupt context, so need to watch what we do
- */
-void twi2c_catch_error(I2CDriver *i2cp)
-{
-  noteI2cError(i2cp->errors);
-}
-
-/**
- * Callback after sending of response complete - restores default reply in case polled
- */
-void twi2c_clear_after_send(I2CDriver *i2cp)
-{
-  // echoReply.size = 0;               // Clear receive message
-  // i2cSlaveReplyI(i2cp, &initialReply);
-}
-
-uint8_t twi2c_start(void) {
-  i2cStart(&I2C_DRIVER, &i2cconfig);
-  return 0;
-}
-
-void twi2c_init(void) {
-  palSetGroupMode(GPIOB,6,7, PAL_MODE_INPUT);       // Try releasing special pins for a short time
-  chThdSleepMilliseconds(10);
-
-  palSetPadMode(GPIOB, 6, PAL_MODE_ALTERNATE(4) | PAL_STM32_OTYPE_OPENDRAIN | PAL_STM32_PUPDR_PULLUP);
-  palSetPadMode(GPIOB, 7, PAL_MODE_ALTERNATE(4) | PAL_STM32_OTYPE_OPENDRAIN | PAL_STM32_PUPDR_PULLUP);
-
-  // try high drive (from kiibohd)
-  // I2C_DRIVER.i2c->C2 |= I2Cx_C2_HDRS;
-  // try glitch fixing (from kiibohd)
-  // I2C_DRIVER.i2c->FLT = 4;
-}
-
-uint8_t twi2c_write(uint8_t data) {
-  return i2cMasterTransmitTimeout(&I2C_DRIVER, twi2c_address/2, &data, 1, 0, 0, MS2ST(100));
-}
-
-uint8_t twi2c_transmit(uint8_t address, uint8_t * data, uint16_t length) {
-  return i2cMasterTransmitTimeout(&I2C_DRIVER, address/2, data, length, 0, 0, MS2ST(100));
-}
-
-uint8_t twi2c_receive(uint8_t address, uint8_t * data, uint16_t length) {
-  return i2cMasterReceiveTimeout(&I2C_DRIVER, address/2, data, length, MS2ST(100));
-}
-
-
-uint8_t twi2c_incoming_body[50];
-uint8_t twi2c_outgoing_body[1024];
-
-// Response to received messages
-I2CSlaveMsg twi2c_incoming_message = {
-  sizeof(twi2c_incoming_body),
-  twi2c_incoming_body,
-  NULL,
-  twi2c_incoming_message_process,
-  twi2c_catch_error                   /* Error hook */
-};
-
-void twi2c_incoming_message_process(I2CDriver * i2cp) {
-  size_t len = i2cSlaveBytes(i2cp);
-  (*twi2c_message_received_callback)(i2cp, twi2c_incoming_body, len);
-}
-
-// Response to received messages
-I2CSlaveMsg twi2c_outgoing_message = {
-  sizeof(twi2c_outgoing_body),
-  twi2c_outgoing_body,
-  NULL,
-  twi2c_clear_after_send,
-  twi2c_catch_error
-};
-
-uint8_t twi2c_reply(I2CDriver * i2cp, uint8_t * data, uint16_t length) {
-  memcpy(twi2c_outgoing_body, data, length);
-  twi2c_outgoing_message.size = length;
-  i2cSlaveReplyI(i2cp, &twi2c_outgoing_message);
-  return 0;
-}
-
-uint8_t twi2c_transmit_receive(uint8_t address, uint8_t * tx_body, uint16_t tx_length, uint8_t * rx_body, uint16_t rx_length) {
-  return i2cMasterTransmitTimeout(&I2C_DRIVER, address/2, tx_body, tx_length, rx_body, rx_length, MS2ST(100));
-}
-
-uint8_t twi2c_start_listening(uint8_t address, twi2c_message_received callback) {
-  twi2c_message_received_callback = callback;
-  I2C_DRIVER.slaveTimeout = MS2ST(100);
-  i2cSlaveConfigure(&I2C_DRIVER, &twi2c_incoming_message, &twi2c_outgoing_message);
-  i2cMatchAddress(&I2C_DRIVER, address/2);
-  return 0;
-}
-
-uint8_t twi2c_restart_listening(uint8_t address) {
-  i2cMatchAddress(&I2C_DRIVER, address/2);
-  return 0;
-}
-
-void twi2c_stop(void) {
-  i2cUnmatchAll(&I2C_DRIVER);
-  i2cStop(&I2C_DRIVER);
-}

drivers/arm/twi2c.h

@@ -1,48 +0,0 @@
-/* Copyright 2018 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/>.
- */
-
-#ifndef TWI2C_H
-#define TWI2C_H
-
-#include "ch.h"
-#include "hal.h"
-
-#ifndef I2C_DRIVER
-  #define I2C_DRIVER I2CD1
-#endif
-
-#define slaveI2Caddress  0x30       /* Address in our terms - halved by later code */
-//#define myOtherI2Caddress 0x19
-I2CSlaveMsgCB twi2c_incoming_message_process, twi2c_catch_error, twi2c_clear_after_send;
-typedef void (*twi2c_message_received)(I2CDriver *, uint8_t *, uint16_t);
-
-void twi2c_init(void);
-uint8_t twi2c_start(void);
-uint8_t twi2c_write(uint8_t data);
-uint8_t twi2c_read_ack(void);
-uint8_t twi2c_read_nack(void);
-uint8_t twi2c_transmit(uint8_t address, uint8_t* data, uint16_t length);
-uint8_t twi2c_receive(uint8_t address, uint8_t* data, uint16_t length);
-uint8_t twi2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length);
-uint8_t twi2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length);
-void twi2c_stop(void);
-
-uint8_t twi2c_reply(I2CDriver * i2cp, uint8_t * data, uint16_t length);
-uint8_t twi2c_transmit_receive(uint8_t address, uint8_t * tx_body, uint16_t tx_length, uint8_t * rx_body, uint16_t rx_length);
-uint8_t twi2c_start_listening(uint8_t address, twi2c_message_received callback);
-uint8_t twi2c_restart_listening(uint8_t address);
-
-#endif

drivers/arm/ws2812.c

@@ -1,159 +0,0 @@
-/*
- * LEDDriver.c
- *
- *  Created on: Aug 26, 2013
- *      Author: Omri Iluz
- */
-
-#include "ws2812.h"
-#include "stdlib.h"
-
-static uint8_t *fb;
-static int sLeds;
-static stm32_gpio_t *sPort;
-static uint32_t sMask;
-uint8_t* dma_source;
-
-void setColor(uint8_t color, uint8_t *buf,uint32_t mask){
-  int i;
-  for (i=0;i<8;i++){
-    buf[i]=((color<<i)&0b10000000?0x0:mask);
-  }
-}
-
-void setColorRGB(Color c, uint8_t *buf, uint32_t mask){
-  setColor(c.G,buf, mask);
-  setColor(c.R,buf+8, mask);
-  setColor(c.B,buf+16, mask);
-}
-
-/**
- * @brief   Initialize Led Driver
- * @details Initialize the Led Driver based on parameters.
- *          Following initialization, the frame buffer would automatically be
- *          exported to the supplied port and pins in the right timing to drive
- *          a chain of WS2812B controllers
- * @note    The function assumes the controller is running at 72Mhz
- * @note    Timing is critical for WS2812. While all timing is done in hardware
- *          need to verify memory bandwidth is not exhausted to avoid DMA delays
- *
- * @param[in] leds      length of the LED chain controlled by each pin
- * @param[in] port      which port would be used for output
- * @param[in] mask      Which pins would be used for output, each pin is a full chain
- * @param[out] o_fb     initialized frame buffer
- *
- */
-void ledDriverInit(int leds, stm32_gpio_t *port, uint32_t mask, uint8_t **o_fb) {
-  sLeds=leds;
-  sPort=port;
-  sMask=mask;
-  palSetGroupMode(port, sMask, 0, PAL_MODE_OUTPUT_PUSHPULL|PAL_STM32_OSPEED_HIGHEST|PAL_STM32_PUPDR_FLOATING);
-
-  // configure pwm timers -
-  // timer 2 as master, active for data transmission and inactive to disable transmission during reset period (50uS)
-  // timer 3 as slave, during active time creates a 1.25 uS signal, with duty cycle controlled by frame buffer values
-  static PWMConfig pwmc2 = {72000000 / 90, /* 800Khz PWM clock frequency. 1/90 of PWMC3   */
-                            (72000000 / 90) * 0.05, /*Total period is 50ms (20FPS), including sLeds cycles + reset length for ws2812b and FB writes  */
-                            NULL,
-                            { {PWM_OUTPUT_ACTIVE_HIGH, NULL},
-                              {PWM_OUTPUT_DISABLED, NULL},
-                              {PWM_OUTPUT_DISABLED, NULL},
-                              {PWM_OUTPUT_DISABLED, NULL}},
-                              TIM_CR2_MMS_2, /* master mode selection */
-                              0, };
-  /* master mode selection */
-  static PWMConfig pwmc3 = {72000000,/* 72Mhz PWM clock frequency.   */
-                            90, /* 90 cycles period (1.25 uS per period @72Mhz       */
-                            NULL,
-                            { {PWM_OUTPUT_ACTIVE_HIGH, NULL},
-                              {PWM_OUTPUT_ACTIVE_HIGH, NULL},
-                              {PWM_OUTPUT_ACTIVE_HIGH, NULL},
-                              {PWM_OUTPUT_ACTIVE_HIGH, NULL}},
-                              0,
-                              0,
-  };
-  dma_source = chHeapAlloc(NULL, 1);
-  fb = chHeapAlloc(NULL, ((sLeds) * 24)+10);
-  *o_fb=fb;
-  int j;
-  for (j = 0; j < (sLeds) * 24; j++) fb[j] = 0;
-  dma_source[0] = sMask;
-  // DMA stream 2, triggered by channel3 pwm signal. if FB indicates, reset output value early to indicate "0" bit to ws2812
-  dmaStreamAllocate(STM32_DMA1_STREAM2, 10, NULL, NULL);
-  dmaStreamSetPeripheral(STM32_DMA1_STREAM2, &(sPort->BSRR.H.clear));
-  dmaStreamSetMemory0(STM32_DMA1_STREAM2, fb);
-  dmaStreamSetTransactionSize(STM32_DMA1_STREAM2, (sLeds) * 24);
-  dmaStreamSetMode(
-      STM32_DMA1_STREAM2,
-      STM32_DMA_CR_DIR_M2P | STM32_DMA_CR_MINC | STM32_DMA_CR_PSIZE_BYTE
-      | STM32_DMA_CR_MSIZE_BYTE | STM32_DMA_CR_CIRC | STM32_DMA_CR_PL(2));
-  // DMA stream 3, triggered by pwm update event. output high at beginning of signal
-  dmaStreamAllocate(STM32_DMA1_STREAM3, 10, NULL, NULL);
-  dmaStreamSetPeripheral(STM32_DMA1_STREAM3, &(sPort->BSRR.H.set));
-  dmaStreamSetMemory0(STM32_DMA1_STREAM3, dma_source);
-  dmaStreamSetTransactionSize(STM32_DMA1_STREAM3, 1);
-  dmaStreamSetMode(
-      STM32_DMA1_STREAM3, STM32_DMA_CR_TEIE |
-      STM32_DMA_CR_DIR_M2P | STM32_DMA_CR_PSIZE_BYTE | STM32_DMA_CR_MSIZE_BYTE
-      | STM32_DMA_CR_CIRC | STM32_DMA_CR_PL(3));
-  // DMA stream 6, triggered by channel1 update event. reset output value late to indicate "1" bit to ws2812.
-  // always triggers but no affect if dma stream 2 already change output value to 0
-  dmaStreamAllocate(STM32_DMA1_STREAM6, 10, NULL, NULL);
-  dmaStreamSetPeripheral(STM32_DMA1_STREAM6, &(sPort->BSRR.H.clear));
-  dmaStreamSetMemory0(STM32_DMA1_STREAM6, dma_source);
-  dmaStreamSetTransactionSize(STM32_DMA1_STREAM6, 1);
-  dmaStreamSetMode(
-      STM32_DMA1_STREAM6,
-      STM32_DMA_CR_DIR_M2P | STM32_DMA_CR_PSIZE_BYTE | STM32_DMA_CR_MSIZE_BYTE
-      | STM32_DMA_CR_CIRC | STM32_DMA_CR_PL(3));
-  pwmStart(&PWMD2, &pwmc2);
-  pwmStart(&PWMD3, &pwmc3);
-  // set pwm3 as slave, triggerd by pwm2 oc1 event. disables pwmd2 for synchronization.
-  PWMD3.tim->SMCR |= TIM_SMCR_SMS_0 | TIM_SMCR_SMS_2 | TIM_SMCR_TS_0;
-  PWMD2.tim->CR1 &= ~TIM_CR1_CEN;
-  // set pwm values.
-  // 28 (duty in ticks) / 90 (period in ticks) * 1.25uS (period in S) = 0.39 uS
-  pwmEnableChannel(&PWMD3, 2, 28);
-  // 58 (duty in ticks) / 90 (period in ticks) * 1.25uS (period in S) = 0.806 uS
-  pwmEnableChannel(&PWMD3, 0, 58);
-  // active during transfer of 90 cycles * sLeds * 24 bytes * 1/90 multiplier
-  pwmEnableChannel(&PWMD2, 0, 90 * sLeds * 24 / 90);
-  // stop and reset counters for synchronization
-  PWMD2.tim->CNT = 0;
-  // Slave (TIM3) needs to "update" immediately after master (TIM2) start in order to start in sync.
-  // this initial sync is crucial for the stability of the run
-  PWMD3.tim->CNT = 89;
-  PWMD3.tim->DIER |= TIM_DIER_CC3DE | TIM_DIER_CC1DE | TIM_DIER_UDE;
-  dmaStreamEnable(STM32_DMA1_STREAM3);
-  dmaStreamEnable(STM32_DMA1_STREAM6);
-  dmaStreamEnable(STM32_DMA1_STREAM2);
-  // all systems go! both timers and all channels are configured to resonate
-  // in complete sync without any need for CPU cycles (only DMA and timers)
-  // start pwm2 for system to start resonating
-  PWMD2.tim->CR1 |= TIM_CR1_CEN;
-}
-
-void ledDriverWaitCycle(void){
-  while (PWMD2.tim->CNT < 90 * sLeds * 24 / 90){chThdSleepMicroseconds(1);};
-}
-
-void testPatternFB(uint8_t *fb){
-  int i;
-  Color tmpC = {rand()%256, rand()%256, rand()%256};
-  for (i=0;i<sLeds;i++){
-    setColorRGB(tmpC,fb+24*i, sMask);
-  }
-}
-
-void ws2812_setleds(LED_TYPE *ledarray, uint16_t number_of_leds) {
-//   uint8_t i = 0;
-//   while (i < number_of_leds) {
-//     ws2812_write_led(i, ledarray[i].r, ledarray[i].g, ledarray[i].b);
-//     i++;
-//   }
-}
-
-
-void ws2812_setleds_rgbw(LED_TYPE *ledarray, uint16_t number_of_leds) {
-
-}

drivers/arm/ws2812.h

@@ -1,31 +0,0 @@
-/*
- * LEDDriver.h
- *
- *  Created on: Aug 26, 2013
- *      Author: Omri Iluz
- */
-
-#ifndef WS2812_H_
-#define WS2812_H_
-
-#include "hal.h"
-#include "rgblight_types.h"
-
-#define sign(x) (( x > 0 ) - ( x < 0 ))
-
-typedef struct Color Color;
-struct Color {
-  uint8_t R;
-  uint8_t G;
-  uint8_t B;
-};
-
-void ledDriverInit(int leds, stm32_gpio_t *port, uint32_t mask, uint8_t **o_fb);
-void setColorRGB(Color c, uint8_t *buf, uint32_t mask);
-void testPatternFB(uint8_t *fb);
-void ledDriverWaitCycle(void);
-
-void ws2812_setleds(LED_TYPE *ledarray, uint16_t number_of_leds);
-void ws2812_setleds_rgbw(LED_TYPE *ledarray, uint16_t number_of_leds);
-
-#endif /* LEDDRIVER_H_ */

drivers/avr/i2c_master.c

@@ -0,0 +1,218 @@
+/* Library made by: g4lvanix
+ * Github repository: https://github.com/g4lvanix/I2C-master-lib
+ */
+
+#include <avr/io.h>
+#include <util/twi.h>
+
+#include "i2c_master.h"
+#include "timer.h"
+
+#define F_SCL 400000UL // SCL frequency
+#define Prescaler 1
+#define TWBR_val ((((F_CPU / F_SCL) / Prescaler) - 16 ) / 2)
+
+void i2c_init(void)
+{
+  TWSR = 0;     /* no prescaler */
+	TWBR = (uint8_t)TWBR_val;
+}
+
+i2c_status_t i2c_start(uint8_t address, uint16_t timeout)
+{
+	// reset TWI control register
+	TWCR = 0;
+	// transmit START condition
+	TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);
+
+  uint16_t timeout_timer = timer_read();
+  while( !(TWCR & (1<<TWINT)) ) {
+    if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
+      return I2C_STATUS_TIMEOUT;
+    }
+  }
+
+	// check if the start condition was successfully transmitted
+	if(((TW_STATUS & 0xF8) != TW_START) && ((TW_STATUS & 0xF8) != TW_REP_START)){ return I2C_STATUS_ERROR; }
+
+	// load slave address into data register
+	TWDR = address;
+	// start transmission of address
+	TWCR = (1<<TWINT) | (1<<TWEN);
+
+  timeout_timer = timer_read();
+  while( !(TWCR & (1<<TWINT)) ) {
+    if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
+      return I2C_STATUS_TIMEOUT;
+    }
+  }
+
+	// check if the device has acknowledged the READ / WRITE mode
+	uint8_t twst = TW_STATUS & 0xF8;
+	if ( (twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK) ) return I2C_STATUS_ERROR;
+
+	return I2C_STATUS_SUCCESS;
+}
+
+i2c_status_t i2c_write(uint8_t data, uint16_t timeout)
+{
+	// load data into data register
+	TWDR = data;
+	// start transmission of data
+	TWCR = (1<<TWINT) | (1<<TWEN);
+
+  uint16_t timeout_timer = timer_read();
+  while( !(TWCR & (1<<TWINT)) ) {
+    if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
+      return I2C_STATUS_TIMEOUT;
+    }
+  }
+
+	if( (TW_STATUS & 0xF8) != TW_MT_DATA_ACK ){ return I2C_STATUS_ERROR; }
+
+	return I2C_STATUS_SUCCESS;
+}
+
+int16_t i2c_read_ack(uint16_t timeout)
+{
+
+	// start TWI module and acknowledge data after reception
+	TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWEA);
+
+  uint16_t timeout_timer = timer_read();
+  while( !(TWCR & (1<<TWINT)) ) {
+    if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
+      return I2C_STATUS_TIMEOUT;
+    }
+  }
+
+	// return received data from TWDR
+	return TWDR;
+}
+
+int16_t i2c_read_nack(uint16_t timeout)
+{
+
+	// start receiving without acknowledging reception
+	TWCR = (1<<TWINT) | (1<<TWEN);
+
+  uint16_t timeout_timer = timer_read();
+  while( !(TWCR & (1<<TWINT)) ) {
+    if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
+      return I2C_STATUS_TIMEOUT;
+    }
+  }
+
+	// return received data from TWDR
+	return TWDR;
+}
+
+i2c_status_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout)
+{
+  i2c_status_t status = i2c_start(address | I2C_WRITE, timeout);
+	if (status) return status;
+
+	for (uint16_t i = 0; i < length; i++) {
+		status = i2c_write(data[i], timeout);
+    if (status) return status;
+	}
+
+	status = i2c_stop(timeout);
+  if (status) return status;
+
+	return I2C_STATUS_SUCCESS;
+}
+
+i2c_status_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout)
+{
+  i2c_status_t status = i2c_start(address | I2C_READ, timeout);
+	if (status) return status;
+
+	for (uint16_t i = 0; i < (length-1); i++) {
+    status = i2c_read_ack(timeout);
+    if (status >= 0) {
+      data[i] = status;
+    } else {
+      return status;
+    }
+	}
+
+  status = i2c_read_nack(timeout);
+  if (status >= 0 ) {
+    data[(length-1)] = status;
+  } else {
+    return status;
+  }
+
+  status = i2c_stop(timeout);
+  if (status) return status;
+
+	return 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 status = i2c_start(devaddr | 0x00, timeout);
+	if (status) return status;
+
+	status = i2c_write(regaddr, timeout);
+  if (status) return status;
+
+	for (uint16_t i = 0; i < length; i++) {
+    status = i2c_write(data[i], timeout);
+		if (status) return status;
+	}
+
+	status = i2c_stop(timeout);
+  if (status) return status;
+
+	return I2C_STATUS_SUCCESS;
+}
+
+i2c_status_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout)
+{
+  i2c_status_t status = i2c_start(devaddr, timeout);
+	if (status) return status;
+
+  status = i2c_write(regaddr, timeout);
+  if (status) return status;
+
+  status = i2c_start(devaddr | 0x01, timeout);
+	if (status) return status;
+
+	for (uint16_t i = 0; i < (length-1); i++) {
+		status = i2c_read_ack(timeout);
+    if (status >= 0) {
+      data[i] = status;
+    } else {
+      return status;
+    }
+	}
+
+  status = i2c_read_nack(timeout);
+  if (status >= 0 ) {
+    data[(length-1)] = status;
+  } else {
+    return status;
+  }
+
+  status = i2c_stop(timeout);
+  if (status) return status;
+
+	return I2C_STATUS_SUCCESS;
+}
+
+i2c_status_t i2c_stop(uint16_t timeout)
+{
+	// transmit STOP condition
+	TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
+
+  uint16_t timeout_timer = timer_read();
+  while(TWCR & (1<<TWSTO)) {
+    if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
+      return I2C_STATUS_TIMEOUT;
+    }
+  }
+
+  return I2C_STATUS_SUCCESS;
+}

drivers/avr/i2c_master.h

@@ -0,0 +1,31 @@
+/* Library made by: g4lvanix
+ * Github repository: https://github.com/g4lvanix/I2C-master-lib
+ */
+
+#ifndef I2C_MASTER_H
+#define I2C_MASTER_H
+
+#define I2C_READ 0x01
+#define I2C_WRITE 0x00
+
+typedef int16_t i2c_status_t;
+
+#define I2C_STATUS_SUCCESS (0)
+#define I2C_STATUS_ERROR   (-1)
+#define I2C_STATUS_TIMEOUT (-2)
+
+#define I2C_TIMEOUT_IMMEDIATE (0)
+#define I2C_TIMEOUT_INFINITE (0xFFFF)
+
+void i2c_init(void);
+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_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);
+i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
+i2c_status_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
+i2c_status_t i2c_stop(uint16_t timeout);
+
+#endif // I2C_MASTER_H

drivers/avr/i2c_slave.c

@@ -0,0 +1,100 @@
+/* Library made by: g4lvanix
+ * Github repository: https://github.com/g4lvanix/I2C-slave-lib
+ */
+
+#include <avr/io.h>
+#include <util/twi.h>
+#include <avr/interrupt.h>
+
+#include "i2c_slave.h"
+
+void i2c_init(uint8_t address){
+	// load address into TWI address register
+	TWAR = (address << 1);
+	// set the TWCR to enable address matching and enable TWI, clear TWINT, enable TWI interrupt
+	TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN);
+}
+
+void i2c_stop(void){
+	// clear acknowledge and enable bits
+	TWCR &= ~( (1<<TWEA) | (1<<TWEN) );
+}
+
+ISR(TWI_vect){
+	
+	// temporary stores the received data
+	uint8_t data;
+	
+	// own address has been acknowledged
+	if( (TWSR & 0xF8) == TW_SR_SLA_ACK ){  
+		buffer_address = 0xFF;
+		// clear TWI interrupt flag, prepare to receive next byte and acknowledge
+		TWCR |= (1<<TWIE) | (1<<TWINT) | (1<<TWEA) | (1<<TWEN); 
+	}
+	else if( (TWSR & 0xF8) == TW_SR_DATA_ACK ){ // data has been received in slave receiver mode
+		
+		// save the received byte inside data 
+		data = TWDR;
+		
+		// check wether an address has already been transmitted or not
+		if(buffer_address == 0xFF){
+			
+			buffer_address = data; 
+			
+			// clear TWI interrupt flag, prepare to receive next byte and acknowledge
+			TWCR |= (1<<TWIE) | (1<<TWINT) | (1<<TWEA) | (1<<TWEN); 
+		}
+		else{ // if a databyte has already been received
+			
+			// store the data at the current address
+			rxbuffer[buffer_address] = data;
+			
+			// increment the buffer address
+			buffer_address++;
+			
+			// if there is still enough space inside the buffer
+			if(buffer_address < 0xFF){
+				// clear TWI interrupt flag, prepare to receive next byte and acknowledge
+				TWCR |= (1<<TWIE) | (1<<TWINT) | (1<<TWEA) | (1<<TWEN); 
+			}
+			else{
+				// Don't acknowledge
+				TWCR &= ~(1<<TWEA); 
+				// clear TWI interrupt flag, prepare to receive last byte.
+				TWCR |= (1<<TWIE) | (1<<TWINT) | (1<<TWEN); 
+			}
+		}
+	}
+	else if( (TWSR & 0xF8) == TW_ST_DATA_ACK ){ // device has been addressed to be a transmitter
+		
+		// copy data from TWDR to the temporary memory
+		data = TWDR;
+		
+		// if no buffer read address has been sent yet
+		if( buffer_address == 0xFF ){
+			buffer_address = data;
+		}
+		
+		// copy the specified buffer address into the TWDR register for transmission
+		TWDR = txbuffer[buffer_address];
+		// increment buffer read address
+		buffer_address++;
+		
+		// if there is another buffer address that can be sent
+		if(buffer_address < 0xFF){
+			// clear TWI interrupt flag, prepare to send next byte and receive acknowledge
+			TWCR |= (1<<TWIE) | (1<<TWINT) | (1<<TWEA) | (1<<TWEN); 
+		}
+		else{
+			// Don't acknowledge
+			TWCR &= ~(1<<TWEA); 
+			// clear TWI interrupt flag, prepare to receive last byte.
+			TWCR |= (1<<TWIE) | (1<<TWINT) | (1<<TWEN); 
+		}
+		
+	}
+	else{
+		// if none of the above apply prepare TWI to be addressed again
+		TWCR |= (1<<TWIE) | (1<<TWEA) | (1<<TWEN);
+	} 
+}

drivers/avr/i2c_slave.h

@@ -0,0 +1,19 @@
+/* Library made by: g4lvanix
+ * Github repository: https://github.com/g4lvanix/I2C-slave-lib
+
+ Info: Inititate the library by giving the required address.
+       Read or write to the necessary buffer according to the opperation.
+ */
+
+#ifndef I2C_SLAVE_H
+#define I2C_SLAVE_H
+
+volatile uint8_t buffer_address;
+volatile uint8_t txbuffer[0xFF];
+volatile uint8_t rxbuffer[0xFF];
+
+void i2c_init(uint8_t address);
+void i2c_stop(void);
+ISR(TWI_vect);
+
+#endif // I2C_SLAVE_H

drivers/avr/is31fl3731.c

@@ -0,0 +1,262 @@
+/* Copyright 2017 Jason Williams
+ * Copyright 2018 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/>.
+ */
+
+#include "is31fl3731.h"
+#include <avr/interrupt.h>
+#include <avr/io.h>
+#include <util/delay.h>
+#include <string.h>
+#include "i2c_master.h"
+#include "progmem.h"
+
+// This is a 7-bit address, that gets left-shifted and bit 0
+// set to 0 for write, 1 for read (as per I2C protocol)
+// The address will vary depending on your wiring:
+// 0b1110100 AD <-> GND
+// 0b1110111 AD <-> VCC
+// 0b1110101 AD <-> SCL
+// 0b1110110 AD <-> SDA
+#define ISSI_ADDR_DEFAULT 0x74
+
+#define ISSI_REG_CONFIG  0x00
+#define ISSI_REG_CONFIG_PICTUREMODE 0x00
+#define ISSI_REG_CONFIG_AUTOPLAYMODE 0x08
+#define ISSI_REG_CONFIG_AUDIOPLAYMODE 0x18
+
+#define ISSI_CONF_PICTUREMODE 0x00
+#define ISSI_CONF_AUTOFRAMEMODE 0x04
+#define ISSI_CONF_AUDIOMODE 0x08
+
+#define ISSI_REG_PICTUREFRAME  0x01
+
+#define ISSI_REG_SHUTDOWN 0x0A
+#define ISSI_REG_AUDIOSYNC 0x06
+
+#define ISSI_COMMANDREGISTER 0xFD
+#define ISSI_BANK_FUNCTIONREG 0x0B    // helpfully called 'page nine'
+
+#ifndef ISSI_TIMEOUT
+  #define ISSI_TIMEOUT 100
+#endif
+
+#ifndef ISSI_PERSISTENCE
+  #define ISSI_PERSISTENCE 0
+#endif
+
+// Transfer buffer for TWITransmitData()
+uint8_t g_twi_transfer_buffer[20];
+
+// These buffers match the IS31FL3731 PWM registers 0x24-0xB3.
+// Storing them like this is optimal for I2C transfers to the registers.
+// We could optimize this and take out the unused registers from these
+// buffers and the transfers in IS31FL3731_write_pwm_buffer() but it's
+// probably not worth the extra complexity.
+uint8_t g_pwm_buffer[DRIVER_COUNT][144];
+bool g_pwm_buffer_update_required = false;
+
+uint8_t g_led_control_registers[DRIVER_COUNT][18] = { { 0 }, { 0 } };
+bool g_led_control_registers_update_required = false;
+
+// This is the bit pattern in the LED control registers
+// (for matrix A, add one to register for matrix B)
+//
+//  reg -  b7  b6  b5  b4  b3  b2  b1  b0
+// 0x00 - R08,R07,R06,R05,R04,R03,R02,R01
+// 0x02 - G08,G07,G06,G05,G04,G03,G02,R00
+// 0x04 - B08,B07,B06,B05,B04,B03,G01,G00
+// 0x06 -  - , - , - , - , - ,B02,B01,B00
+// 0x08 -  - , - , - , - , - , - , - , -
+// 0x0A - B17,B16,B15, - , - , - , - , -
+// 0x0C - G17,G16,B14,B13,B12,B11,B10,B09
+// 0x0E - R17,G15,G14,G13,G12,G11,G10,G09
+// 0x10 - R16,R15,R14,R13,R12,R11,R10,R09
+
+
+void IS31FL3731_write_register( uint8_t addr, uint8_t reg, uint8_t data )
+{
+	g_twi_transfer_buffer[0] = reg;
+	g_twi_transfer_buffer[1] = data;
+
+  #if ISSI_PERSISTENCE > 0
+    for (uint8_t i = 0; i < ISSI_PERSISTENCE; i++) {
+      if (i2c_transmit(addr << 1, g_twi_transfer_buffer, 2, ISSI_TIMEOUT) == 0)
+        break;
+    }
+  #else
+    i2c_transmit(addr << 1, g_twi_transfer_buffer, 2, ISSI_TIMEOUT);
+  #endif
+}
+
+void IS31FL3731_write_pwm_buffer( uint8_t addr, uint8_t *pwm_buffer )
+{
+	// assumes bank is already selected
+
+	// transmit PWM registers in 9 transfers of 16 bytes
+	// g_twi_transfer_buffer[] is 20 bytes
+
+	// iterate over the pwm_buffer contents at 16 byte intervals
+	for ( int i = 0; i < 144; i += 16 ) {
+		// set the first register, e.g. 0x24, 0x34, 0x44, etc.
+		g_twi_transfer_buffer[0] = 0x24 + i;
+		// copy the data from i to i+15
+		// device will auto-increment register for data after the first byte
+		// thus this sets registers 0x24-0x33, 0x34-0x43, etc. in one transfer
+		for ( int j = 0; j < 16; j++ ) {
+			g_twi_transfer_buffer[1 + j] = pwm_buffer[i + j];
+		}
+
+    #if ISSI_PERSISTENCE > 0
+      for (uint8_t i = 0; i < ISSI_PERSISTENCE; i++) {
+        if (i2c_transmit(addr << 1, g_twi_transfer_buffer, 17, ISSI_TIMEOUT) == 0)
+          break;
+      }
+    #else
+      i2c_transmit(addr << 1, g_twi_transfer_buffer, 17, ISSI_TIMEOUT);
+    #endif
+	}
+}
+
+void IS31FL3731_init( uint8_t addr )
+{
+	// In order to avoid the LEDs being driven with garbage data
+	// in the LED driver's PWM registers, first enable software shutdown,
+	// then set up the mode and other settings, clear the PWM registers,
+	// then disable software shutdown.
+
+	// select "function register" bank
+	IS31FL3731_write_register( addr, ISSI_COMMANDREGISTER, ISSI_BANK_FUNCTIONREG );
+
+	// enable software shutdown
+	IS31FL3731_write_register( addr, ISSI_REG_SHUTDOWN, 0x00 );
+	// this delay was copied from other drivers, might not be needed
+	_delay_ms( 10 );
+
+	// picture mode
+	IS31FL3731_write_register( addr, ISSI_REG_CONFIG, ISSI_REG_CONFIG_PICTUREMODE );
+	// display frame 0
+	IS31FL3731_write_register( addr, ISSI_REG_PICTUREFRAME, 0x00 );
+	// audio sync off
+	IS31FL3731_write_register( addr, ISSI_REG_AUDIOSYNC, 0x00 );
+
+	// select bank 0
+	IS31FL3731_write_register( addr, ISSI_COMMANDREGISTER, 0 );
+
+	// turn off all LEDs in the LED control register
+	for ( int i = 0x00; i <= 0x11; i++ )
+	{
+		IS31FL3731_write_register( addr, i, 0x00 );
+	}
+
+	// turn off all LEDs in the blink control register (not really needed)
+	for ( int i = 0x12; i <= 0x23; i++ )
+	{
+		IS31FL3731_write_register( addr, i, 0x00 );
+	}
+
+	// set PWM on all LEDs to 0
+	for ( int i = 0x24; i <= 0xB3; i++ )
+	{
+		IS31FL3731_write_register( addr, i, 0x00 );
+	}
+
+	// select "function register" bank
+	IS31FL3731_write_register( addr, ISSI_COMMANDREGISTER, ISSI_BANK_FUNCTIONREG );
+
+	// disable software shutdown
+	IS31FL3731_write_register( addr, ISSI_REG_SHUTDOWN, 0x01 );
+
+	// select bank 0 and leave it selected.
+	// most usage after initialization is just writing PWM buffers in bank 0
+	// as there's not much point in double-buffering
+	IS31FL3731_write_register( addr, ISSI_COMMANDREGISTER, 0 );
+
+}
+
+void IS31FL3731_set_color( int index, uint8_t red, uint8_t green, uint8_t blue )
+{
+	if ( index >= 0 && index < DRIVER_LED_TOTAL ) {
+		is31_led led = g_is31_leds[index];
+
+		// Subtract 0x24 to get the second index of g_pwm_buffer
+		g_pwm_buffer[led.driver][led.r - 0x24] = red;
+		g_pwm_buffer[led.driver][led.g - 0x24] = green;
+		g_pwm_buffer[led.driver][led.b - 0x24] = blue;
+		g_pwm_buffer_update_required = true;
+	}
+}
+
+void IS31FL3731_set_color_all( uint8_t red, uint8_t green, uint8_t blue )
+{
+	for ( int i = 0; i < DRIVER_LED_TOTAL; i++ )
+	{
+		IS31FL3731_set_color( i, red, green, blue );
+	}
+}
+
+void IS31FL3731_set_led_control_register( uint8_t index, bool red, bool green, bool blue )
+{
+	is31_led led = g_is31_leds[index];
+
+  uint8_t control_register_r = (led.r - 0x24) / 8;
+  uint8_t control_register_g = (led.g - 0x24) / 8;
+  uint8_t control_register_b = (led.b - 0x24) / 8;
+  uint8_t bit_r = (led.r - 0x24) % 8;
+  uint8_t bit_g = (led.g - 0x24) % 8;
+  uint8_t bit_b = (led.b - 0x24) % 8;
+
+	if ( red ) {
+		g_led_control_registers[led.driver][control_register_r] |= (1 << bit_r);
+	} else {
+		g_led_control_registers[led.driver][control_register_r] &= ~(1 << bit_r);
+	}
+	if ( green ) {
+		g_led_control_registers[led.driver][control_register_g] |= (1 << bit_g);
+	} else {
+		g_led_control_registers[led.driver][control_register_g] &= ~(1 << bit_g);
+	}
+	if ( blue ) {
+		g_led_control_registers[led.driver][control_register_b] |= (1 << bit_b);
+	} else {
+		g_led_control_registers[led.driver][control_register_b] &= ~(1 << bit_b);
+	}
+
+	g_led_control_registers_update_required = true;
+
+}
+
+void IS31FL3731_update_pwm_buffers( uint8_t addr1, uint8_t addr2 )
+{
+	if ( g_pwm_buffer_update_required )
+	{
+		IS31FL3731_write_pwm_buffer( addr1, g_pwm_buffer[0] );
+		IS31FL3731_write_pwm_buffer( addr2, g_pwm_buffer[1] );
+	}
+	g_pwm_buffer_update_required = false;
+}
+
+void IS31FL3731_update_led_control_registers( uint8_t addr1, uint8_t addr2 )
+{
+	if ( g_led_control_registers_update_required )
+	{
+		for ( int i=0; i<18; i++ )
+		{
+			IS31FL3731_write_register(addr1, i, g_led_control_registers[0][i] );
+			IS31FL3731_write_register(addr2, i, g_led_control_registers[1][i] );
+		}
+	}
+}
+

drivers/avr/is31fl3731.h

@@ -23,7 +23,7 @@
 #include <stdbool.h>
 
 typedef struct is31_led {
-  uint8_t driver:2;
+	uint8_t driver:2;
   uint8_t r;
   uint8_t g;
   uint8_t b;

drivers/avr/twi2c.c

@@ -1,149 +0,0 @@
-/* Library made by: g4lvanix
- * Github repository: https://github.com/g4lvanix/I2C-master-lib
- */
-
-#include <avr/io.h>
-#include <util/twi.h>
-
-#include "twi2c.h"
-
-#define F_SCL 400000UL // SCL frequency
-#define Prescaler 1
-#define TWBR_val ((((F_CPU / F_SCL) / Prescaler) - 16 ) / 2)
-
-void twi2c_init(void)
-{
-	TWBR = (uint8_t)TWBR_val;
-}
-
-uint8_t twi2c_start(uint8_t address)
-{
-	// reset TWI control register
-	TWCR = 0;
-	// transmit START condition
-	TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);
-	// wait for end of transmission
-	while( !(TWCR & (1<<TWINT)) );
-
-	// check if the start condition was successfully transmitted
-	if((TWSR & 0xF8) != TW_START){ return 1; }
-
-	// load slave address into data register
-	TWDR = address;
-	// start transmission of address
-	TWCR = (1<<TWINT) | (1<<TWEN);
-	// wait for end of transmission
-	while( !(TWCR & (1<<TWINT)) );
-
-	// check if the device has acknowledged the READ / WRITE mode
-	uint8_t twst = TW_STATUS & 0xF8;
-	if ( (twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK) ) return 1;
-
-	return 0;
-}
-
-uint8_t twi2c_write(uint8_t data)
-{
-	// load data into data register
-	TWDR = data;
-	// start transmission of data
-	TWCR = (1<<TWINT) | (1<<TWEN);
-	// wait for end of transmission
-	while( !(TWCR & (1<<TWINT)) );
-
-	if( (TWSR & 0xF8) != TW_MT_DATA_ACK ){ return 1; }
-
-	return 0;
-}
-
-uint8_t twi2c_read_ack(void)
-{
-
-	// start TWI module and acknowledge data after reception
-	TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWEA);
-	// wait for end of transmission
-	while( !(TWCR & (1<<TWINT)) );
-	// return received data from TWDR
-	return TWDR;
-}
-
-uint8_t twi2c_read_nack(void)
-{
-
-	// start receiving without acknowledging reception
-	TWCR = (1<<TWINT) | (1<<TWEN);
-	// wait for end of transmission
-	while( !(TWCR & (1<<TWINT)) );
-	// return received data from TWDR
-	return TWDR;
-}
-
-uint8_t twi2c_transmit(uint8_t address, uint8_t* data, uint16_t length)
-{
-	if (twi2c_start(address | I2C_WRITE)) return 1;
-
-	for (uint16_t i = 0; i < length; i++)
-	{
-		if (twi2c_write(data[i])) return 1;
-	}
-
-	twi2c_stop();
-
-	return 0;
-}
-
-uint8_t twi2c_receive(uint8_t address, uint8_t* data, uint16_t length)
-{
-	if (twi2c_start(address | I2C_READ)) return 1;
-
-	for (uint16_t i = 0; i < (length-1); i++)
-	{
-		data[i] = twi2c_read_ack();
-	}
-	data[(length-1)] = twi2c_read_nack();
-
-	twi2c_stop();
-
-	return 0;
-}
-
-uint8_t twi2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length)
-{
-	if (twi2c_start(devaddr | 0x00)) return 1;
-
-	twi2c_write(regaddr);
-
-	for (uint16_t i = 0; i < length; i++)
-	{
-		if (twi2c_write(data[i])) return 1;
-	}
-
-	twi2c_stop();
-
-	return 0;
-}
-
-uint8_t twi2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length)
-{
-	if (twi2c_start(devaddr)) return 1;
-
-	twi2c_write(regaddr);
-
-	if (twi2c_start(devaddr | 0x01)) return 1;
-
-	for (uint16_t i = 0; i < (length-1); i++)
-	{
-		data[i] = twi2c_read_ack();
-	}
-	data[(length-1)] = twi2c_read_nack();
-
-	twi2c_stop();
-
-	return 0;
-}
-
-void twi2c_stop(void)
-{
-	// transmit STOP condition
-	TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
-}

drivers/avr/twi2c.h

@@ -1,22 +0,0 @@
-/* Library made by: g4lvanix
- * Github repository: https://github.com/g4lvanix/I2C-master-lib
- */
-
-#ifndef TWI2C_H
-#define TWI2C_H
-
-#define I2C_READ 0x01
-#define I2C_WRITE 0x00
-
-void twi2c_init(void);
-uint8_t twi2c_start(uint8_t address);
-uint8_t twi2c_write(uint8_t data);
-uint8_t twi2c_read_ack(void);
-uint8_t twi2c_read_nack(void);
-uint8_t twi2c_transmit(uint8_t address, uint8_t* data, uint16_t length);
-uint8_t twi2c_receive(uint8_t address, uint8_t* data, uint16_t length);
-uint8_t twi2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length);
-uint8_t twi2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length);
-void twi2c_stop(void);
-
-#endif // I2C_MASTER_H

drivers/is31fl3731.c

@@ -1,244 +0,0 @@
-/* Copyright 2017 Jason Williams
- * Copyright 2018 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/>.
- */
-
-#include "is31fl3731.h"
-#include "wait.h"
-#include <string.h>
-#include "twi2c.h"
-#include "progmem.h"
-
-// This is a 7-bit address, that gets left-shifted and bit 0
-// set to 0 for write, 1 for read (as per I2C protocol)
-// The address will vary depending on your wiring:
-// 0b1110100 AD <-> GND
-// 0b1110111 AD <-> VCC
-// 0b1110101 AD <-> SCL
-// 0b1110110 AD <-> SDA
-#define ISSI_ADDR_DEFAULT 0x74
-
-#define ISSI_REG_CONFIG  0x00
-#define ISSI_REG_CONFIG_PICTUREMODE 0x00
-#define ISSI_REG_CONFIG_AUTOPLAYMODE 0x08
-#define ISSI_REG_CONFIG_AUDIOPLAYMODE 0x18
-
-#define ISSI_CONF_PICTUREMODE 0x00
-#define ISSI_CONF_AUTOFRAMEMODE 0x04
-#define ISSI_CONF_AUDIOMODE 0x08
-
-#define ISSI_REG_PICTUREFRAME  0x01
-
-#define ISSI_REG_SHUTDOWN 0x0A
-#define ISSI_REG_AUDIOSYNC 0x06
-
-#define ISSI_COMMANDREGISTER 0xFD
-#define ISSI_BANK_FUNCTIONREG 0x0B    // helpfully called 'page nine'
-
-// Transfer buffer for TWITransmitData()
-uint8_t g_twi_transfer_buffer[20];
-
-// These buffers match the IS31FL3731 PWM registers 0x24-0xB3.
-// Storing them like this is optimal for I2C transfers to the registers.
-// We could optimize this and take out the unused registers from these
-// buffers and the transfers in IS31FL3731_write_pwm_buffer() but it's
-// probably not worth the extra complexity.
-uint8_t g_pwm_buffer[DRIVER_COUNT][144];
-bool g_pwm_buffer_update_required = false;
-
-uint8_t g_led_control_registers[DRIVER_COUNT][18] = { { 0 }, { 0 } };
-bool g_led_control_registers_update_required = false;
-
-// This is the bit pattern in the LED control registers
-// (for matrix A, add one to register for matrix B)
-//
-//  reg -  b7  b6  b5  b4  b3  b2  b1  b0
-// 0x00 - R08,R07,R06,R05,R04,R03,R02,R01
-// 0x02 - G08,G07,G06,G05,G04,G03,G02,R00
-// 0x04 - B08,B07,B06,B05,B04,B03,G01,G00
-// 0x06 -  - , - , - , - , - ,B02,B01,B00
-// 0x08 -  - , - , - , - , - , - , - , -
-// 0x0A - B17,B16,B15, - , - , - , - , -
-// 0x0C - G17,G16,B14,B13,B12,B11,B10,B09
-// 0x0E - R17,G15,G14,G13,G12,G11,G10,G09
-// 0x10 - R16,R15,R14,R13,R12,R11,R10,R09
-
-
-void IS31FL3731_write_register( uint8_t addr, uint8_t reg, uint8_t data )
-{
-  g_twi_transfer_buffer[0] = reg;
-  g_twi_transfer_buffer[1] = data;
-
-  //Transmit data until succesful
-  //while(twi2c_transmit(addr << 1, g_twi_transfer_buffer,2) != 0);
-  twi2c_transmit(addr << 1, g_twi_transfer_buffer,2);
-}
-
-void IS31FL3731_write_pwm_buffer( uint8_t addr, uint8_t *pwm_buffer )
-{
-  // assumes bank is already selected
-
-  // transmit PWM registers in 9 transfers of 16 bytes
-  // g_twi_transfer_buffer[] is 20 bytes
-
-  // iterate over the pwm_buffer contents at 16 byte intervals
-  for ( int i = 0; i < 144; i += 16 )
-  {
-    // set the first register, e.g. 0x24, 0x34, 0x44, etc.
-    g_twi_transfer_buffer[0] = 0x24 + i;
-    // copy the data from i to i+15
-    // device will auto-increment register for data after the first byte
-    // thus this sets registers 0x24-0x33, 0x34-0x43, etc. in one transfer
-    for ( int j = 0; j < 16; j++ )
-    {
-      g_twi_transfer_buffer[1 + j] = pwm_buffer[i + j];
-    }
-
-    //Transmit buffer until succesful
-    //while(twi2c_transmit(addr << 1, g_twi_transfer_buffer,17) != 0);
-    twi2c_transmit(addr << 1, g_twi_transfer_buffer,17);
-  }
-}
-
-void IS31FL3731_init( uint8_t addr )
-{
-  // In order to avoid the LEDs being driven with garbage data
-  // in the LED driver's PWM registers, first enable software shutdown,
-  // then set up the mode and other settings, clear the PWM registers,
-  // then disable software shutdown.
-
-  // select "function register" bank
-  IS31FL3731_write_register( addr, ISSI_COMMANDREGISTER, ISSI_BANK_FUNCTIONREG );
-
-  // enable software shutdown
-  IS31FL3731_write_register( addr, ISSI_REG_SHUTDOWN, 0x00 );
-  // this delay was copied from other drivers, might not be needed
-  wait_ms( 10 );
-
-  // picture mode
-  IS31FL3731_write_register( addr, ISSI_REG_CONFIG, ISSI_REG_CONFIG_PICTUREMODE );
-  // display frame 0
-  IS31FL3731_write_register( addr, ISSI_REG_PICTUREFRAME, 0x00 );
-  // audio sync off
-  IS31FL3731_write_register( addr, ISSI_REG_AUDIOSYNC, 0x00 );
-
-  // select bank 0
-  IS31FL3731_write_register( addr, ISSI_COMMANDREGISTER, 0 );
-
-  // turn off all LEDs in the LED control register
-  for ( int i = 0x00; i <= 0x11; i++ )
-  {
-    IS31FL3731_write_register( addr, i, 0x00 );
-  }
-
-  // turn off all LEDs in the blink control register (not really needed)
-  for ( int i = 0x12; i <= 0x23; i++ )
-  {
-    IS31FL3731_write_register( addr, i, 0x00 );
-  }
-
-  // set PWM on all LEDs to 0
-  for ( int i = 0x24; i <= 0xB3; i++ )
-  {
-    IS31FL3731_write_register( addr, i, 0x00 );
-  }
-
-  // select "function register" bank
-  IS31FL3731_write_register( addr, ISSI_COMMANDREGISTER, ISSI_BANK_FUNCTIONREG );
-
-  // disable software shutdown
-  IS31FL3731_write_register( addr, ISSI_REG_SHUTDOWN, 0x01 );
-
-  // select bank 0 and leave it selected.
-  // most usage after initialization is just writing PWM buffers in bank 0
-  // as there's not much point in double-buffering
-  IS31FL3731_write_register( addr, ISSI_COMMANDREGISTER, 0 );
-}
-
-void IS31FL3731_set_color( int index, uint8_t red, uint8_t green, uint8_t blue )
-{
-  if ( index >= 0 && index < DRIVER_LED_TOTAL ) {
-    is31_led led = g_is31_leds[index];
-
-    // Subtract 0x24 to get the second index of g_pwm_buffer
-    g_pwm_buffer[led.driver][led.r - 0x24] = red;
-    g_pwm_buffer[led.driver][led.g - 0x24] = green;
-    g_pwm_buffer[led.driver][led.b - 0x24] = blue;
-    g_pwm_buffer_update_required = true;
-  }
-}
-
-void IS31FL3731_set_color_all( uint8_t red, uint8_t green, uint8_t blue )
-{
-  for ( int i = 0; i < DRIVER_LED_TOTAL; i++ )
-  {
-    IS31FL3731_set_color( i, red, green, blue );
-  }
-}
-
-void IS31FL3731_set_led_control_register( uint8_t index, bool red, bool green, bool blue )
-{
-  is31_led led = g_is31_leds[index];
-
-  uint8_t control_register_r = (led.r - 0x24) / 8;
-  uint8_t control_register_g = (led.g - 0x24) / 8;
-  uint8_t control_register_b = (led.b - 0x24) / 8;
-  uint8_t bit_r = (led.r - 0x24) % 8;
-  uint8_t bit_g = (led.g - 0x24) % 8;
-  uint8_t bit_b = (led.b - 0x24) % 8;
-
-  if ( red ) {
-    g_led_control_registers[led.driver][control_register_r] |= (1 << bit_r);
-  } else {
-    g_led_control_registers[led.driver][control_register_r] &= ~(1 << bit_r);
-  }
-  if ( green ) {
-    g_led_control_registers[led.driver][control_register_g] |= (1 << bit_g);
-  } else {
-    g_led_control_registers[led.driver][control_register_g] &= ~(1 << bit_g);
-  }
-  if ( blue ) {
-    g_led_control_registers[led.driver][control_register_b] |= (1 << bit_b);
-  } else {
-    g_led_control_registers[led.driver][control_register_b] &= ~(1 << bit_b);
-  }
-
-  g_led_control_registers_update_required = true;
-
-
-}
-
-void IS31FL3731_update_pwm_buffers( uint8_t addr1, uint8_t addr2 )
-{
-  if ( g_pwm_buffer_update_required )
-  {
-    IS31FL3731_write_pwm_buffer( addr1, g_pwm_buffer[0] );
-    IS31FL3731_write_pwm_buffer( addr2, g_pwm_buffer[1] );
-  }
-  g_pwm_buffer_update_required = false;
-}
-
-void IS31FL3731_update_led_control_registers( uint8_t addr1, uint8_t addr2 )
-{
-  if ( g_led_control_registers_update_required )
-  {
-    for ( int i=0; i<18; i++ )
-    {
-      IS31FL3731_write_register(addr1, i, g_led_control_registers[0][i] );
-      IS31FL3731_write_register(addr2, i, g_led_control_registers[1][i] );
-    }
-  }
-}
-

drivers/qwiic/qwiic_keyboard.c

@@ -1,189 +0,0 @@
-/* Copyright 2018 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/>.
- */
-
-#include "qwiic_keyboard.h"
-#include "keymap.h"
-#include "matrix.h"
-#include "keyboard.h"
-#include "twi2c.h"
-#include <string.h>
-#include "usb_main.h"
-#include "usb_driver.h"
-
-#define QWIIC_KEYBOARD_LAYERS 16
-#define QWIIC_KEYBOARD_ROWS 8
-#define QWIIC_KEYBOARD_COLS 8
-
-#define qwiic_matrix_t uint8_t
-
-#define QWIIC_KEYBOARD_HANDSHAKE_ADDRESS       0b01010100
-#define QWIIC_KEYBOARD_LISTENING_ADDRESS_START 0b01010110
-#define QWIIC_KEYBOARD_HANDSHAKE_MESSAGE_SIZE  (QWIIC_KEYBOARD_LAYERS * QWIIC_KEYBOARD_ROWS * QWIIC_KEYBOARD_COLS)
-#define QWIIC_KEYBOARD_MATRIX_MESSAGE_SIZE     MATRIX_ROWS
-
-void qwiic_keyboard_write_keymap(uint8_t * pointer);
-void qwiic_keyboard_read_keymap(uint8_t * pointer);
-
-static bool qwiic_keyboard_master = false;
-static bool qwiic_keyboard_connected = false;
-static uint8_t qwiic_keyboard_handshake_message[QWIIC_KEYBOARD_HANDSHAKE_MESSAGE_SIZE] = {0};
-static uint8_t qwiic_keyboard_matrix_message[QWIIC_KEYBOARD_ROWS] = {0};
-static qwiic_matrix_t matrix_prev[QWIIC_KEYBOARD_ROWS] = {0};
-static twi2c_message_received qwiic_keyboard_message_received_ptr = qwiic_keyboard_message_received;
-
-static uint16_t qwiic_keyboard_keymap[QWIIC_KEYBOARD_LAYERS][QWIIC_KEYBOARD_ROWS][QWIIC_KEYBOARD_COLS] = {{{0}}};
-static uint8_t qwiic_keyboard_listening_address = QWIIC_KEYBOARD_LISTENING_ADDRESS_START;
-
-void qwiic_keyboard_init(void) {
-  twi2c_init();
-  twi2c_start();
-  twi2c_start_listening(QWIIC_KEYBOARD_HANDSHAKE_ADDRESS, qwiic_keyboard_message_received_ptr);
-}
-
-void qwiic_keyboard_set_master(void) {
-  twi2c_stop();
-  twi2c_start();
-  qwiic_keyboard_master = true;
-}
-
-uint8_t command[1] = { 0x00 };
-
-void qwiic_keyboard_task(void) {
-  if (USB_DRIVER.state == USB_ACTIVE)
-    qwiic_keyboard_master = true;
-  else
-    qwiic_keyboard_master = false;
-  if (qwiic_keyboard_master) {
-    if (qwiic_keyboard_connected) {
-      // send empty message, expecting matrix info
-      if (MSG_OK != twi2c_transmit_receive(qwiic_keyboard_listening_address,
-        command, 1,
-        qwiic_keyboard_matrix_message, QWIIC_KEYBOARD_MATRIX_MESSAGE_SIZE
-      )) {
-        // disconnect
-        // qwiic_keyboard_connected = false;
-      }
-    } else { // if not connected
-      // send new address to listen on, expect back keymap
-      if (MSG_OK == twi2c_transmit_receive(QWIIC_KEYBOARD_HANDSHAKE_ADDRESS,
-        &qwiic_keyboard_listening_address, 1,
-        qwiic_keyboard_handshake_message, QWIIC_KEYBOARD_HANDSHAKE_MESSAGE_SIZE
-      )) {
-        qwiic_keyboard_connected = true;
-        // load keymap into memory
-        qwiic_keyboard_read_keymap(qwiic_keyboard_handshake_message);
-      }
-    }
-  }
-}
-
-float song_one_up[][2]  = SONG(ONE_UP_SOUND);
-bool first_message = true;
-
-void qwiic_keyboard_message_received(I2CDriver *i2cp, uint8_t * body, uint16_t size) {
-  if (qwiic_keyboard_connected) {
-    for (uint8_t row = 0; row < QWIIC_KEYBOARD_ROWS; row++) {
-      if (row < MATRIX_ROWS) {
-        qwiic_keyboard_matrix_message[row] = matrix_get_row(row);
-      } else {
-        qwiic_keyboard_matrix_message[row] = 0;
-      }
-    }
-    twi2c_reply(i2cp, qwiic_keyboard_matrix_message, QWIIC_KEYBOARD_MATRIX_MESSAGE_SIZE);
-    if (first_message) {
-      PLAY_SONG(song_one_up);
-      first_message = false;
-    }
-  } else {
-    qwiic_keyboard_connected = true;
-    qwiic_keyboard_master = false;
-    qwiic_keyboard_listening_address = body[0];
-    twi2c_restart_listening(qwiic_keyboard_listening_address);
-    qwiic_keyboard_write_keymap(qwiic_keyboard_handshake_message);
-    twi2c_reply(i2cp, qwiic_keyboard_handshake_message, QWIIC_KEYBOARD_HANDSHAKE_MESSAGE_SIZE);
-  }
-}
-
-// qwiic_keyboard_message_received_ptr = qwiic_keyboard_message_received;
-
-__attribute__((optimize("O0")))
-void qwiic_keyboard_write_keymap(uint8_t * pointer) {
-  for (uint8_t layer = 0; layer < QWIIC_KEYBOARD_LAYERS; layer++) {
-    for (uint8_t row = 0; row < QWIIC_KEYBOARD_ROWS; row++) {
-      for (uint8_t col = 0; col < QWIIC_KEYBOARD_COLS; col++) {
-        uint16_t keycode = pgm_read_word(&keymaps[layer][row][col]);
-        *pointer++ = (keycode >> 8);
-        *pointer++ = (keycode & 0xFF);
-      }
-    }
-  }
-}
-
-void qwiic_keyboard_read_keymap(uint8_t * pointer) {
-  for (uint8_t layer = 0; layer < QWIIC_KEYBOARD_LAYERS; layer++) {
-    for (uint8_t row = 0; row < QWIIC_KEYBOARD_ROWS; row++) {
-      for (uint8_t col = 0; col < QWIIC_KEYBOARD_COLS; col++) {
-        uint16_t keycode = ((*pointer++) << 8);
-        keycode |= (*pointer++);
-        qwiic_keyboard_keymap[layer][row][col] = keycode;
-      }
-    }
-  }
-}
-
-// overwrite the built-in function - slaves don't need to process keycodes
-bool is_keyboard_master(void) {
-  return qwiic_keyboard_master;
-}
-
-// overwrite the built-in function
-uint16_t keymap_key_to_keycode(uint8_t layer, keymatrix_t key) {
-  if (key.matrix == 0) {
-    // Read entire word (16bits)
-    return pgm_read_word(&keymaps[(layer)][(key.pos.row)][(key.pos.col)]);
-  } else {
-    return qwiic_keyboard_keymap[(layer)][(key.pos.row)][(key.pos.col)];
-  }
-}
-
-uint8_t multimatrix_get_num_matrices(void) {
-  return qwiic_keyboard_connected ? 1 : 0;
-}
-
-uint8_t multimatrix_get_num_cols(uint8_t matrix) {
-  return QWIIC_KEYBOARD_COLS;
-}
-
-uint8_t multimatrix_get_num_rows(uint8_t matrix) {
-  return QWIIC_KEYBOARD_ROWS;
-}
-
-uint32_t multimatrix_get_row(uint8_t matrix, uint8_t row) {
-return qwiic_keyboard_matrix_message[row];
-}
-
-uint32_t multimatrix_get_row_cache(uint8_t matrix, uint8_t row) {
-  return matrix_prev[row];
-}
-
-void multimatrix_set_row_cache(uint8_t matrix, uint8_t row, uint32_t value) {
-  matrix_prev[row] = value;
-}
-
-uint8_t* multimatrix_get_source_layers_cache(uint8_t matrix) {
-    static uint8_t source_layers_cache[(QWIIC_KEYBOARD_ROWS * QWIIC_KEYBOARD_COLS * MAX_LAYER_BITS + 7) / 8] = {0};
-    return source_layers_cache;
-}

keyboards/al1/al1.c

@@ -1,4 +1,4 @@
-/* Copyright 2018 Jack Humbert
+/* Copyright 2018 MechMerlin
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -13,23 +13,28 @@
  * 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 "al1.h"
 
-#ifndef MUON_LIGHT_H
-#define MUON_LIGHT_H
-
-#include "quantum.h"
-
-#define LAYOUT_ortho_4x6( \
-	k00, k01, k02, k03, k04, k05, \
-	k10, k11, k12, k13, k14, k15, \
-	k20, k21, k22, k23, k24, k25, \
-	k30, k31, k32, k33, k34, k35 \
-) \
-{ \
-	{ k00, k01, k02, k03, k04, k05 }, \
-	{ k10, k11, k12, k13, k14, k15 }, \
-	{ k20, k21, k22, k23, k24, k25 }, \
-	{ k30, k31, k32, k33, k34, k35 } \
+bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
+	return process_record_user(keycode, record);
 }
 
-#endif
+void led_set_kb(uint8_t usb_led) {
+    CONFIG_LED_IO;
+    print_dec(usb_led);
+    if (usb_led & (1<<USB_LED_CAPS_LOCK))
+        PORTB &= ~(1<<7);
+    else
+        PORTB |=  (1<<7);
+
+    if (usb_led & (1<<USB_LED_NUM_LOCK))
+        PORTD &= ~(1<<0);
+    else
+        PORTD |=  (1<<0);
+
+    if (usb_led & (1<<USB_LED_SCROLL_LOCK))
+        PORTD &= ~(1<<1);
+    else
+        PORTD |=  (1<<1);
+	led_set_user(usb_led);
+}

keyboards/al1/al1.h

@@ -0,0 +1,58 @@
+/* Copyright 2018 MechMerlin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef AL1_H
+#define AL1_H
+
+#include "quantum.h"
+
+#define CONFIG_LED_IO \
+  DDRB |= (1<<7) | (1<<6); \
+  DDRD |= (1<<0) | (1<<1);
+
+
+#define LAYOUT( \
+               K500, K000, K001, K002, K003, K004, K005, K006, K007, K008, K009, K010, K011, K012, K013, K014, K015, K415, K414,\
+               K501, K100, K101, K102, K103, K104, K105, K106, K107, K108, K109, K110, K111, K112, K113, K114, K115, K215, K413,\
+               K502, K200, K201, K202, K203, K204, K205, K206, K207, K208, K209, K210, K211,             K212, K213, K214,      \
+               K503, K300, K301, K302, K303, K304, K305, K306, K307, K308, K309, K310, K311,       K312, K313, K314, K315, K412,\
+               K400, K401, K402, K403, K404, K405, K406,                                     K407, K408, K409, K410, K411       \
+) \
+{ \
+    { K000, K001, K002, K003, K004, K005, K006, K007, K008, K009, K010, K011, K012, K013, K014, K015}, \
+    { K100, K101, K102, K103, K104, K105, K106, K107, K108, K109, K110, K111, K112, K113, K114, K115}, \
+    { K200, K201, K202, K203, K204, K205, K206, K207, K208, K209, K210, K211, K212, K213, K214, K215}, \
+    { K300, K301, K302, K303, K304, K305, K306, K307, K308, K309, K310, K311, K312, K313, K314, K315}, \
+    { K400, K401, K402, K403, K404, K405, K406, K407, K408, K409, K410, K411, K412, K413, K414, K415}, \
+    { K500, K501, K502, K503, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO} \
+}
+
+#define LAYOUT_split_bs( \
+               K500, K000, K001, K002, K003, K004, K005, K006, K007, K008, K009, K010, K011, K512, K012, K013, K014, K015, K415, K414, \
+               K501, K100, K101, K102, K103, K104, K105, K106, K107, K108, K109, K110, K111, K112, K113, K114, K115, K215, K413,\
+               K502, K200, K201, K202, K203, K204, K205, K206, K207, K208, K209, K210, K211,             K212, K213, K214,      \
+               K503, K300, K301, K302, K303, K304, K305, K306, K307, K308, K309, K310, K311,       K312, K313, K314, K315, K412,\
+               K400, K401, K402, K403, K404, K405, K406,                                     K407, K408, K409, K410, K411       \
+) \
+{ \
+    { K000, K001, K002, K003, K004, K005, K006, K007, K008, K009, K010, K011, K012, K013, K014, K015}, \
+    { K100, K101, K102, K103, K104, K105, K106, K107, K108, K109, K110, K111, K112, K113, K114, K115}, \
+    { K200, K201, K202, K203, K204, K205, K206, K207, K208, K209, K210, K211, K212, K213, K214, K215}, \
+    { K300, K301, K302, K303, K304, K305, K306, K307, K308, K309, K310, K311, K312, K313, K314, K315}, \
+    { K400, K401, K402, K403, K404, K405, K406, K407, K408, K409, K410, K411, K412, K413, K414, K415}, \
+    { K500, K501, K502, K503, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, K512, KC_NO, KC_NO, KC_NO} \
+}
+
+#endif

keyboards/al1/config.h

@@ -1,5 +1,5 @@
 /*
-Copyright 2012 Jun Wako <wakojun@gmail.com>
+Copyright 2018 MechMerlin
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -22,15 +22,15 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 /* USB Device descriptor parameter */
 #define VENDOR_ID       0xFEED
-#define PRODUCT_ID      0x6160
-#define MANUFACTURER    OLKB
-#define PRODUCT         Muon Light
-#define DESCRIPTION     A compact ortholinear keyboard
-#define DEVICE_VER      0x0001
+#define PRODUCT_ID      0x6050
+#define DEVICE_VER      0x0104
+#define MANUFACTURER    Alsoran
+#define PRODUCT         AL1
+#define DESCRIPTION     A custom keyboard
 
 /* key matrix size */
-#define MATRIX_ROWS 4
-#define MATRIX_COLS 6
+#define MATRIX_ROWS 7
+#define MATRIX_COLS 20
 
 /*
  * Keyboard Matrix Assignments
@@ -42,30 +42,32 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *                  ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
  *
 */
-#undef MATRIX_ROW_PINS
-#undef MATRIX_COL_PINS
-#define MATRIX_ROW_PINS { B5, B10, A9, A8 }
-#define MATRIX_COL_PINS { A10, B2, A15, A0, A1, A2 }
 
-/* COL2ROW or ROW2COL */
+/* COL2ROW, ROW2COL, or CUSTOM_MATRIX */
 #define DIODE_DIRECTION COL2ROW
 
-#define MUSIC_MAP
+#define BACKLIGHT_PIN B6
+#define BACKLIGHT_BREATHING
+#define BACKLIGHT_LEVELS 3
 
-#define NUMBER_OF_ENCODERS 1
-#define ENCODERS_PAD_A { B12 }
-#define ENCODERS_PAD_B { B13 }
 
 /* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
-#define DEBOUNCE 6
+#define DEBOUNCING_DELAY 5
 
-/* Prevent modifiers from being stuck on after layer changes. */
-#define PREVENT_STUCK_MODIFIERS
+/* 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
+#define LOCKING_SUPPORT_ENABLE
 /* Locking resynchronize hack */
-//#define LOCKING_RESYNC_ENABLE
+#define LOCKING_RESYNC_ENABLE
+
+/* If defined, GRAVE_ESC will always act as ESC when CTRL is held.
+ * This is userful for the Windows task manager shortcut (ctrl+shift+esc).
+ */
+// #define GRAVE_ESC_CTRL_OVERRIDE
 
 /*
  * Force NKRO
@@ -88,11 +90,59 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 //#define FORCE_NKRO
 
+/*
+ * Magic Key Options
+ *
+ * Magic keys are hotkey commands that allow control over firmware functions of
+ * the keyboard. They are best used in combination with the HID Listen program,
+ * found here: https://www.pjrc.com/teensy/hid_listen.html
+ *
+ * The options below allow the magic key functionality to be changed. This is
+ * useful if your keyboard/keypad is missing keys and you want magic key support.
+ *
+ */
+
 /* key combination for magic key command */
 #define IS_COMMAND() ( \
-  keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
+    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
 )
 
+/* control how magic key switches layers */
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS  true
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS  true
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM false
+
+/* override magic key keymap */
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM
+//#define MAGIC_KEY_HELP1          H
+//#define MAGIC_KEY_HELP2          SLASH
+//#define MAGIC_KEY_DEBUG          D
+//#define MAGIC_KEY_DEBUG_MATRIX   X
+//#define MAGIC_KEY_DEBUG_KBD      K
+//#define MAGIC_KEY_DEBUG_MOUSE    M
+//#define MAGIC_KEY_VERSION        V
+//#define MAGIC_KEY_STATUS         S
+//#define MAGIC_KEY_CONSOLE        C
+//#define MAGIC_KEY_LAYER0_ALT1    ESC
+//#define MAGIC_KEY_LAYER0_ALT2    GRAVE
+//#define MAGIC_KEY_LAYER0         0
+//#define MAGIC_KEY_LAYER1         1
+//#define MAGIC_KEY_LAYER2         2
+//#define MAGIC_KEY_LAYER3         3
+//#define MAGIC_KEY_LAYER4         4
+//#define MAGIC_KEY_LAYER5         5
+//#define MAGIC_KEY_LAYER6         6
+//#define MAGIC_KEY_LAYER7         7
+//#define MAGIC_KEY_LAYER8         8
+//#define MAGIC_KEY_LAYER9         9
+//#define MAGIC_KEY_BOOTLOADER     PAUSE
+//#define MAGIC_KEY_LOCK           CAPS
+//#define MAGIC_KEY_EEPROM         E
+//#define MAGIC_KEY_NKRO           N
+//#define MAGIC_KEY_SLEEP_LED      Z
+
 /*
  * Feature disable options
  *  These options are also useful to firmware size reduction.
@@ -134,21 +184,4 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 1
 
-// This is a 7-bit address, that gets left-shifted and bit 0
-// set to 0 for write, 1 for read (as per I2C protocol)
-// The address will vary depending on your wiring:
-// 0b1110100 AD <-> GND
-// 0b1110111 AD <-> VCC
-// 0b1110101 AD <-> SCL
-// 0b1110110 AD <-> SDA
-#define DRIVER_ADDR_1 0b1110100
-#define DRIVER_ADDR_2 0b1110110
-
-#define DRIVER_COUNT 2
-#define DRIVER_1_LED_TOTAL 25
-#define DRIVER_2_LED_TOTAL 24
-#define DRIVER_LED_TOTAL DRIVER_1_LED_TOTAL + DRIVER_2_LED_TOTAL
-
-#define NO_USB_STARTUP_CHECK
-
 #endif

keyboards/al1/info.json

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

keyboards/al1/keymaps/default/keymap.c

@@ -0,0 +1,69 @@
+/* Copyright 2018 MechMerlin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+       [0] = LAYOUT(\
+       KC_ESC,  KC_1,    KC_2,     KC_3,    KC_4,     KC_5,     KC_6,     KC_7,    KC_8,     KC_9,     KC_0,     KC_MINS,  KC_EQL,   KC_BSPC,  KC_INS,   KC_NLCK,  KC_PSLS,  KC_PAST,  KC_PMNS,\
+       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_DELETE, KC_P7,    KC_P8,    KC_P9,    KC_PPLS,\
+       KC_CAPS, KC_A,    KC_S,     KC_D,    KC_F,     KC_G,     KC_H,     KC_J,    KC_K,     KC_L,     KC_SCLN,  KC_QUOT,  KC_ENT,                 KC_P4,    KC_P5,    KC_P6,          \
+       KC_LSFT, KC_Z,    KC_X,     KC_C,    KC_V,     KC_B,     KC_N,     KC_M,    KC_COMMA, KC_DOT,   KC_SLSH,  KC_RSFT,  KC_FN0,          KC_UP,    KC_P1,    KC_P2,    KC_P3,    KC_PENT, \
+       KC_LCTL, KC_LGUI,  KC_LALT, KC_SPACE,   KC_FN0,  KC_RGUI,  KC_RCTRL,                                         KC_LEFT,  KC_DOWN,  KC_RIGHT, KC_P0,    KC_PDOT         ),
+
+       [1] = LAYOUT(\
+       KC_ESC,  KC_F1,    KC_F2,     KC_F3,    KC_F4,     KC_F5,     KC_F6,     KC_F7,    KC_F8,     KC_F9,     KC_F10,     KC_F11,  KC_F12,    KC_BSPC,  KC_INS,   KC_NLCK,  KC_PSLS,  KC_PAST,  KC_PMNS,\
+       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_DELETE, KC_P7,    KC_P8,    KC_P9,    KC_PPLS,\
+       KC_CAPS, KC_A,    KC_S,     KC_D,    KC_F,     KC_G,     KC_H,     KC_J,    KC_K,     KC_L,     KC_SCLN,  KC_QUOT,  KC_ENT,                 KC_P4,    KC_P5,    KC_P6,          \
+       KC_LSFT, KC_Z,    KC_X,     KC_C,    KC_V,     KC_B,     KC_N,     KC_M,    KC_COMMA, KC_DOT,   KC_SLSH,  KC_RSFT,  KC_FN0,          KC_UP,    KC_P1,    KC_P2,    KC_P3,    KC_PENT, \
+       KC_LCTL, KC_LGUI,  KC_LALT, KC_SPACE,   KC_FN0,  KC_RGUI,  KC_RCTRL,                                         KC_FN1,  KC_FN2,  KC_FN3, KC_P0,    KC_PDOT         ),
+};
+
+
+const uint16_t PROGMEM fn_actions[] = {
+
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+  // MACRODOWN only works in this function
+      switch(id) {
+        case 0:
+          if (record->event.pressed) {
+            register_code(KC_RSFT);
+          } else {
+            unregister_code(KC_RSFT);
+          }
+        break;
+      }
+    return MACRO_NONE;
+};
+
+
+void matrix_init_user(void) {
+
+}
+
+void matrix_scan_user(void) {
+
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  return true;
+}
+
+void led_set_user(uint8_t usb_led) {
+
+}

keyboards/al1/keymaps/default/readme.md

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

keyboards/al1/keymaps/splitbs/keymap.c

@@ -0,0 +1,52 @@
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+	[0] = LAYOUT_split_bs(\
+       KC_ESC,  KC_1,    KC_2,     KC_3,    KC_4,     KC_5,     KC_6,     KC_7,    KC_8,     KC_9,     KC_0,     KC_MINS,  KC_EQL,   KC_GRAVE, KC_BSPC,  KC_INS,   KC_NLCK,  KC_PSLS,  KC_PAST,  KC_PMNS, \
+       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_DELETE, KC_P7,    KC_P8,    KC_P9,    KC_PPLS,\
+       KC_CAPS, KC_A,    KC_S,     KC_D,    KC_F,     KC_G,     KC_H,     KC_J,    KC_K,     KC_L,     KC_SCLN,  KC_QUOT,  KC_ENT,                 KC_P4,    KC_P5,    KC_P6,          \
+       KC_LSFT, KC_Z,    KC_X,     KC_C,    KC_V,     KC_B,     KC_N,     KC_M,    KC_COMMA, KC_DOT,   KC_SLSH,  KC_RSFT,  KC_FN0,          KC_UP,    KC_P1,    KC_P2,    KC_P3,    KC_PENT, \
+       KC_LCTL, KC_LGUI,  KC_LALT, KC_SPACE,   KC_FN0,  KC_RGUI,  KC_RCTRL,                                         KC_LEFT,  KC_DOWN,  KC_RIGHT, KC_P0,    KC_PDOT         ),
+        [1] = LAYOUT_split_bs(\
+        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_GRAVE, KC_DELETE,  KC_INS,   KC_NLCK,  KC_PSLS,  KC_PAST,  KC_PMNS, \
+        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_DELETE, KC_P7,    KC_P8,    KC_P9,    KC_PPLS,\
+        KC_CAPS, KC_A,    KC_S,     KC_D,    KC_F,     KC_G,     KC_H,     KC_J,    KC_K,     KC_L,     KC_SCLN,  KC_QUOT,  KC_ENT,                 KC_P4,    KC_P5,    KC_P6,          \
+        KC_LSFT, KC_Z,    KC_X,     KC_C,    KC_V,     KC_B,     KC_N,     KC_M,    KC_COMMA, KC_DOT,   KC_SLSH,  KC_RSFT,  KC_FN0,          KC_UP,    KC_P1,    KC_P2,    KC_P3,    KC_PENT, \
+        KC_LCTL, KC_LGUI,  KC_LALT, KC_SPACE,   KC_FN0,  KC_RGUI,  KC_RCTRL,                                         KC_FN1,  KC_FN2,  KC_FN3, KC_P0,    KC_PDOT         ),
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+  // MACRODOWN only works in this function
+      switch(id) {
+        case 0:
+          if (record->event.pressed) {
+            register_code(KC_RSFT);
+          } else {
+            unregister_code(KC_RSFT);
+          }
+        break;
+      }
+    return MACRO_NONE;
+};
+
+
+void matrix_init_user(void) {
+
+}
+
+void matrix_scan_user(void) {
+
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  return true;
+}
+
+void led_set_user(uint8_t usb_led) {
+
+}

keyboards/al1/matrix.c

@@ -0,0 +1,201 @@
+#include <stdint.h>
+#include <stdbool.h>
+#include <avr/io.h>
+#include <util/delay.h>
+#include "print.h"
+#include "debug.h"
+#include "util.h"
+#include "matrix.h"
+
+#ifndef DEBOUNCING_DELAY
+#   define DEBOUNCING_DELAY 5
+#endif
+static uint8_t debouncing = DEBOUNCING_DELAY;
+
+static matrix_row_t matrix[MATRIX_ROWS];
+static matrix_row_t matrix_debouncing[MATRIX_ROWS];
+
+static uint8_t read_rows(void);
+static void init_rows(void);
+static void unselect_cols(void);
+static void select_col(uint8_t col);
+
+inline uint8_t matrix_rows(void) {
+  return MATRIX_ROWS;
+}
+
+inline uint8_t matrix_cols(void) {
+  return MATRIX_COLS;
+}
+
+__attribute__ ((weak))
+void matrix_init_kb(void) {
+	matrix_init_user();
+}
+
+__attribute__ ((weak))
+void matrix_scan_kb(void) {
+    matrix_scan_user();
+}
+
+__attribute__ ((weak))
+void matrix_init_user(void) {
+}
+
+__attribute__ ((weak))
+void matrix_scan_user(void) {
+}
+
+void matrix_init(void) {
+  // initialize row and col
+    unselect_cols();
+    init_rows();
+
+    // initialize matrix state: all keys off
+    for (uint8_t i=0; i < MATRIX_ROWS; i++) {
+        matrix[i] = 0;
+        matrix_debouncing[i] = 0;
+    }
+  matrix_init_quantum();
+}
+
+uint8_t matrix_scan(void) {
+  for (uint8_t col = 0; col < MATRIX_COLS; col++) {
+    select_col(col);
+    _delay_us(3);
+    uint8_t rows = read_rows();
+    for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
+      bool prev_bit = matrix_debouncing[row] & ((matrix_row_t)1<<col);
+      bool curr_bit = rows & (1<<row);
+      if (prev_bit != curr_bit) {
+        matrix_debouncing[row] ^= ((matrix_row_t)1<<col);
+        debouncing = DEBOUNCING_DELAY;
+      }
+    }
+    unselect_cols();
+  }
+
+  if (debouncing) {
+    if (--debouncing) {
+      _delay_ms(1);
+    } else {
+      for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+        matrix[i] = matrix_debouncing[i];
+      }
+    }
+  }
+
+  matrix_scan_quantum();
+  return 1;
+}
+
+bool matrix_is_modified(void) {
+  if (debouncing)
+    return false;
+  else
+    return true;
+}
+
+inline bool matrix_is_on(uint8_t row, uint8_t col) {
+  return (matrix[row] & ((matrix_row_t)1<<col));
+}
+
+inline matrix_row_t matrix_get_row(uint8_t row) {
+  return matrix[row];
+}
+
+void matrix_print(void) {
+  print("\nr/c 0123456789ABCDEF\n");
+  for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
+    xprintf("%02X: %032lb\n", row, bitrev32(matrix_get_row(row)));
+  }
+}
+
+uint8_t matrix_key_count(void) {
+  uint8_t count = 0;
+  for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+    count += bitpop32(matrix[i]);
+  }
+  return count;
+}
+
+/* Row pin configuration
+ *
+ * row: 0    1    2    3    4    5
+ * pin: C7   B1   B2   C6   B4   B5
+ *
+ */
+static void init_rows(void)
+{
+  DDRC &= ~0b11000000;
+  DDRB &= ~0b00110110;
+  PORTC |= 0b11000000;
+  PORTB |= 0b00110110;
+}
+
+static uint8_t read_rows(void) {
+  return (PINC&(1<<PC7) ? 0 : (1<<0)) |
+    (PINB&(1<<PB1) ? 0 : (1<<1)) |
+    (PINB&(1<<PB2) ? 0 : (1<<2)) |
+    (PINC&(1<<PC6) ? 0 : (1<<3)) |
+    (PINB&(1<<PB4) ? 0 : (1<<4)) |
+    (PINB&(1<<PB5) ? 0 : (1<<5));
+}
+
+/* Row pin configuration
+ * pin:     D3  D7  D6  D5  D4
+ * row: off  0   x   x   x   x
+ *      0    1   0   0   0   0
+ *      1    1   0   0   0   1
+ *      2    1   0   0   1   0
+ *      3    1   0   0   1   1
+ *      4    1   0   1   0   0
+ *      5    1   0   1   0   1
+ *      6    1   0   1   1   0
+ *      7    1   0   1   1   1
+ *      8    1   1   0   0   0
+ *      9    1   1   0   0   1
+ *      10   1   1   0   1   0
+ *      11   1   1   0   1   1
+ *      12   1   1   1   0   0
+ *      13   1   1   1   0   1
+ *      14   1   1   1   1   0
+ *      15   1   1   1   1   1
+ */
+static void  unselect_cols(void)
+{
+  // output high(DDR:1, PORT:1) to unselect
+  DDRB  |= (1 << PD3);
+  PORTB |= (1 << PD3);
+}
+
+static void select_col(uint8_t col) {
+  DDRD  |= (1<<PD3 | 1<<PD4 | 1<<PD5 | 1<<PD6 | 1<<PD7);
+
+  PORTD &= ~(1<<PD3);
+
+  if (col & (1<<0)) {
+    PORTD |= (1<<PD4);
+  }
+  else {
+    PORTD &= ~(1<<PD4);
+  }
+  if (col & (1<<1)) {
+    PORTD |= (1<<PD5);
+  }
+  else {
+    PORTD &= ~(1<<PD5);
+  }
+  if (col & (1<<2)) {
+    PORTD |= (1<<PD6);
+  }
+  else {
+    PORTD &= ~(1<<PD6);
+  }
+  if (col & (1<<3)) {
+    PORTD |= (1<<PD7);
+  }
+  else {
+    PORTD &= ~(1<<PD7);
+  }
+}

keyboards/al1/readme.md

@@ -0,0 +1,16 @@
+# TriangleLabs AL1
+
+![AL1](imgur.com image replace me!)
+
+Keyboard Maintainer: [MechMerlin](https://github.com/mechmerlin), [Olivia](https://github.com/olivia)  
+Hardware Supported: AL1 PCB  
+Hardware Availability: [GroupBuy](https://geekhack.org/index.php?topic=93258.0)  
+
+Ported from [TriangleLab](https://github.com/TriangleLab)'s repo: https://github.com/TriangleLab/AL1-Firmware/tree/master/keyboards/al1
+
+Make example for this keyboard (after setting up your build environment):
+
+    make al1:default
+    make al1:splitbs
+
+See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.

keyboards/al1/rules.mk

@@ -0,0 +1,71 @@
+# MCU name
+#MCU = at90usb1286
+MCU = atmega32u4
+
+# Processor frequency.
+#     This will define a symbol, F_CPU, in all source code files equal to the
+#     processor frequency in Hz. You can then use this symbol in your source code to
+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#     automatically to create a 32-bit value in your source code.
+#
+#     This will be an integer division of F_USB below, as it is sourced by
+#     F_USB after it has run through any CPU prescalers. Note that this value
+#     does not *change* the processor frequency - it should merely be updated to
+#     reflect the processor speed set externally so that the code can use accurate
+#     software delays.
+F_CPU = 16000000
+
+
+#
+# LUFA specific
+#
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+# Input clock frequency.
+#     This will define a symbol, F_USB, in all source code files equal to the
+#     input clock frequency (before any prescaling is performed) in Hz. This value may
+#     differ from F_CPU if prescaling is used on the latter, and is required as the
+#     raw input clock is fed directly to the PLL sections of the AVR for high speed
+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
+#     at the end, this will be done automatically to create a 32-bit value in your
+#     source code.
+#
+#     If no clock division is performed on the input clock inside the AVR (via the
+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
+F_USB = $(F_CPU)
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+
+# 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 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 = no            # USB Nkey Rollover
+BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality on B7 by default
+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
+
+CUSTOM_MATRIX = yes
+SRC += matrix.c

keyboards/amj40/keymaps/jetpacktuxedo/config.h

@@ -0,0 +1 @@
+#define PERMISSIVE_HOLD

keyboards/atreus/keymaps/yttyx/README.md

@@ -0,0 +1,77 @@
+# Overview
+
+A Balance 12 layout for the Atreus keyboard.
+
+Balance 12 was created by Sasha Viminitz. Please see [this page](https://mathematicalmulticore.wordpress.com/the-keyboard-layout-project/)
+for some background on the design of the layout.
+
+* The variant used here is a mirror of the original for left-handers
+* The central column of punctuation keys has been moved elsewhere
+* Home positions for the left and right forefingers are *T* and *A* respectively
+
+## To build/flash
+
+> make atreus:yttyx:avrdude
+
+## Layers
+
+### Base:
+
+      .----------------------------------.         .------------------------------.
+      | P    | L    | C    | D   | W     |         | U    | O   | Y   | K   | Q   |
+      +------+------+------+-----+-------|         |------+-----+-----+-----+-----|
+      | N    | R    | S    | T   | M     |         | A    | E   | I   | H   | V   |
+      +------+------+------+-----+-------|         |------+-----+-----+-----+-----|
+      | Z    | J    | F    | G   | B     |         | ,    | .   | ;   | X   | -   |
+      +------+------+------+-----+-------+---------+------+-----+-----+-----+-----|
+      | Shft | Ctl  | Alt  | BS  | Space | L1 | R1 | Shft | R2  | Win | Ctl | Alt |
+      '---------------------------------------------------------------------------'
+
+### L1:
+
+      .---------------------------------.         .--------------------------------.
+      | 1    | 2    | 3    | 4  | 5     |         | 6    | 7  | 8   | 9    | 0     |
+      |------+------+------+----+-------|         |------+----+-----+------+-------|
+      | Tab  | ?    | =    | -  | _     |         | '    | "  | +   | *    | Enter |
+      |------+------+------+----+-------|         |------+----+-----+------+-------|
+      | Esc  | !    | &    |    |       |         | ,    | .  | ;   |      | -     |
+      |------+------+------+----+-------+---------+------+----+-----+------+-------|
+      | Shft | Ctrl | Alt  | Bk | Space | L1 | R1 | Shft | R2 | Sup | Ctrl | Alt   |
+      '----------------------------------------------------------------------------'
+
+### R1:
+
+      .---------------------------------.         .-------------------------------.
+      | <    | >    | {   | }   | @     |         | $    | <20>  |     |      | R3   |
+      +------+------+-----+-----|-------|         |------+----+-----+------+------|
+      | [    | ]    | (   | )   | #     |         | '    | "  | ~   | `    | Caps |
+      |------+------+-----+-----+-------|         |------+----+-----+------+------|
+      | /    | \    | ^   | |   | %     |         | ,    | .  | ;   |      | PScn |
+      |------+------+-----+-----+-------+---------+------+----+-----+------+------|
+      | Shft | Ctrl | Alt | Del | Space | L1 | R1 | Shft | R2 | Sup | Ctrl | Alt  |
+      '---------------------------------------------------------------------------'
+
+### R2:
+
+      .-----------------------------------.         .--------------------.-----------------.
+      | F12  | F11  | F10  | F9   | Copy  |         | Home | Up   | End  | PgUp | Insert   |
+      |------+------+------+------+-------|         |------+------+------+------+----------|
+      | F8   | F7   | F6   | F5   | Paste |         | Left | Down | Right| PgDn | Enter    |
+      |------+------+------+------+-------|         |------+------+------+------+----------|
+      | F4   | F3   | F2   | F1   | Cut   |         | ^Tab |      | Tab  |      |          |
+      |------+------+------+------+-------+---------+------+------+------+------+----------|
+      | Shft | Ctrl | Alt  | Del  | Undo  | L1 | R1 | Shft | R2   | Sup  | Ctrl | WinRight |
+      '------------------------------------------------------------------------------------'
+
+### R3:
+
+      .----------------------------.         .------------------------.
+      | RESET |    |     |    |    |         |    |    |    |    | R3 |
+      |-------+----+-----+----+----|         |----+----+----+----+----|
+      |       |    |     |    |    |         |    |    |    |    |    |
+      |-------+----+-----+----+----|         |----+----+----+----+----|
+      |       |    |     |    |    |         |    |    |    |    |    |
+      |-------+----+-----+----+----+---------+----+----+----+----+----|
+      |       |    |     |    |    |    |    |    |    |    |    |    |
+      '---------------------------------------------------------------'
+

keyboards/atreus/keymaps/yttyx/config.h

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

keyboards/atreus/keymaps/yttyx/keymap.c

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

keyboards/bfake/bfake.h

@@ -25,16 +25,33 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
    K11, K01, K02, K03, K04, K14, K15, K05, K06, K07, K08, K18, K16,  K20,   \
     K12, K21, K22, K23, K24, K34, K35, K25, K26, K27, K28, K38,   K40,      \
   K19, K13, K41, K42, K43, K44, K54, K55, K45, K46, K47, K58,   K49,    K50,\
-  K09,   K00,   K39,           K30,                 K59,   K69,   K37,   K29\
+  K09,   K00,   K39,           K30,                 K59,   K69,   K57,   K29\
 ){ \
-  { KC_NO, K01, K02, K03, K04, K05, K06, K07, K08, K09, K00}, \
-  { KC_NO, K11, K12, K13, K14, K15, K16, KC_NO, K18, K19, K10}, \
-  { KC_NO, K21, K22, K23, K24, K25, K26, K27, K28, K29, K20}, \
-  { KC_NO, KC_NO, KC_NO, KC_NO, K34, K35, KC_NO, K37, K38, K39, K30}, \
-  { KC_NO, K41, K42, K43, K44, K45, K46, K47, KC_NO, K49, K40}, \
-  { KC_NO, KC_NO, KC_NO, KC_NO, K54, K55, KC_NO, KC_NO, K58, K59, K50}, \
-  { KC_NO, K61, KC_NO, KC_NO, K64, K65, K66, KC_NO, K68, K69, K60}, \
-  { KC_NO, K71, K72, K73, K74, K75, K76, K77, K78, KC_NO, KC_NO}, \
+  { KC_NO, K01,   K02,   K03,   K04, K05, K06,   K07,   K08,   K09,   K00},   \
+  { KC_NO, K11,   K12,   K13,   K14, K15, K16,   KC_NO, K18,   K19,   K10},   \
+  { KC_NO, K21,   K22,   K23,   K24, K25, K26,   K27,   K28,   K29,   K20},   \
+  { KC_NO, KC_NO, KC_NO, KC_NO, K34, K35, KC_NO, KC_NO, K38,   K39,   K30},   \
+  { KC_NO, K41,   K42,   K43,   K44, K45, K46,   K47,   KC_NO, K49,   K40},   \
+  { KC_NO, KC_NO, KC_NO, KC_NO, K54, K55, KC_NO, K57,   K58,   K59,   K50},   \
+  { KC_NO, K61,   KC_NO, KC_NO, K64, K65, K66,   KC_NO, K68,   K69,   K60},   \
+  { KC_NO, K71,   K72,   K73,   K74, K75, K76,   K77,   K78,   KC_NO, KC_NO}, \
+}
+
+#define LAYOUT_60_ansi( \
+  K61, K71, K72, K73, K74, K64, K65, K75, K76, K77, K78, K68, K66,      K60,\
+   K11, K01, K02, K03, K04, K14, K15, K05, K06, K07, K08, K18, K16,  K20,   \
+    K12, K21, K22, K23, K24, K34, K35, K25, K26, K27, K28, K38,   K40,      \
+  K19,      K41, K42, K43, K44, K54, K55, K45, K46, K47, K58,   K49,        \
+  K09,   K00,   K39,           K30,                 K59,   K69,   K57,   K29\
+){ \
+  { KC_NO, K01,   K02,   K03,   K04, K05, K06,   K07,   K08,   K09,   K00},   \
+  { KC_NO, K11,   K12,   KC_NO, K14, K15, K16,   KC_NO, K18,   K19,   KC_NO}, \
+  { KC_NO, K21,   K22,   K23,   K24, K25, K26,   K27,   K28,   K29,   K20},   \
+  { KC_NO, KC_NO, KC_NO, KC_NO, K34, K35, KC_NO, KC_NO, K38,   K39,   K30},   \
+  { KC_NO, K41,   K42,   K43,   K44, K45, K46,   K47,   KC_NO, K49,   K40},   \
+  { KC_NO, KC_NO, KC_NO, KC_NO, K54, K55, KC_NO, K57,   K58,   K59,   KC_NO}, \
+  { KC_NO, K61,   KC_NO, KC_NO, K64, K65, K66,   KC_NO, K68,   K69,   K60},   \
+  { KC_NO, K71,   K72,   K73,   K74, K75, K76,   K77,   K78,   KC_NO, KC_NO}, \
 }
 
 #endif

keyboards/bfake/info.json

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

keyboards/bfake/readme.md

@@ -1,10 +1,10 @@
 B.fake
 ========
 
-A 60% keyboard with RGB
+A 60% keyboard with RGB. The B.fake pcb is a copy of the B.face PCB sold by [winkeyless](https://winkeyless.kr/). However, the switch matrix is actually the same as the [FaceW](https://github.com/qmk/qmk_firmware/tree/master/keyboards/facew), a ps2avr PCB sold on [mechanicalkeyboards.com](https://mechanicalkeyboards.com/). 
 
-Keyboard Maintainer: QMK Community
-Hardware Supported: B.fake PCB
+Keyboard Maintainer: QMK Community  
+Hardware Supported: B.fake PCB  
 Hardware Availability: https://www.aliexpress.com/store/product/bface-60-RGB-underground-copy-pcb-from-china-gh60-pcb-Customize-keyboard-PCB/2230037_32731084597.html
 
 Make example for this keyboard (after setting up your build environment):

keyboards/bfo9000/keymaps/andylikescandy6x18/config.h

@@ -0,0 +1,43 @@
+/*
+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/>.
+*/
+
+#ifndef CONFIG_USER_H
+#define CONFIG_USER_H
+
+#include "config_common.h"
+
+/* 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 PERMISSIVE_HOLD
+
+ #define PREVENT_STUCK_MODIFIERS
+
+
+#endif

keyboards/bfo9000/keymaps/andylikescandy6x18/keymap.c

@@ -0,0 +1,64 @@
+#include QMK_KEYBOARD_H
+
+#include "action_layer.h"
+
+
+
+#define _BASE 0
+#define _RAISE 1
+#define _NAVIGATION 3
+
+
+// Fillers to make layering more clear
+#define _______ KC_TRNS
+#define XXXXXXX KC_NO
+
+// layer access
+#define RSESPC LT( 1, KC_SPC)
+#define NAVSPC LT( 3, KC_SPC)
+
+// Key Combos
+#define CTRLSFT LCTL(KC_LSFT)
+#define CTLALTSFT LALT(LCTL(KC_LSFT))
+#define CTLALTDEL LALT(LCTL(KC_DEL))
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+
+
+
+
+
+[_BASE] = LAYOUT( \
+    KC_KP_SLASH,  KC_KP_ASTERISK,   KC_PMNS,  KC_PPLS,    KC_PSCREEN,       KC_CAPS,    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_P7,        KC_P8,            KC_P9,    KC_LBRC,    KC_RBRC,          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_P4,        KC_P5,            KC_P6,    KC_HOME,    KC_END,           KC_TAB,     KC_Q,     KC_W,     KC_F,    KC_P,     KC_G,    KC_J,    KC_L,    KC_U,    KC_Y,        KC_SCLN,        KC_BSPC,        KC_BSLS,  \
+    KC_P1,        KC_P2,            KC_P3,    KC_SLCK,    KC_PGUP,          KC_ESC,     KC_A,     KC_R,     KC_S,    KC_T,     KC_D,    KC_H,    KC_N,    KC_E,    KC_I,        KC_O,           KC_QUOT,        KC_ENT,   \
+    KC_P0,        KC_PDOT,          KC_PENT,  KC_UP,      KC_PGDN,          KC_LSFT,    KC_Z,     KC_X,     KC_C,    KC_V,     KC_B,    KC_K,    KC_M,    KC_COMM, KC_DOT,      KC_SLSH,        SFT_T(KC_ENT),  KC_PGUP,    \
+    CTLALTDEL,    KC_LCTL,          KC_LEFT,  KC_DOWN,    KC_RGHT,          KC_LCTL,    CTRLSFT,  KC_LGUI,  KC_LALT,  RSESPC,   NAVSPC,  NAVSPC,  RSESPC,  KC_RGUI, KC_RALT,    KC_APPLICATION, KC_RCTL,        KC_PGDN \
+),
+[_RAISE] = LAYOUT( \
+XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,    KC_PAUSE,       KC_NUMLOCK, XXXXXXX,      XXXXXXX,    XXXXXXX,    XXXXXXX,        XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,        XXXXXXX,    XXXXXXX,    XXXXXXX,    \
+XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,        XXXXXXX,    XXXXXXX,      XXXXXXX,    XXXXXXX,    XXXXXXX,        XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,        XXXXXXX,    _______,    _______,    \
+XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,        _______,    KC_EXLM,      KC_AT,      KC_HASH,    KC_DLR,         KC_PERC,    KC_CIRC,    KC_AMPR,    KC_ASTR,    KC_LPRN,        KC_RPRN,    _______,    XXXXXXX,    \
+XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,    _______,        KC_DEL,     KC_1,         KC_2,       KC_3,       KC_4,           KC_5,       KC_6,       KC_7,       KC_8,       KC_9,           KC_0,       _______,    _______,    \
+XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,    _______,        _______,    XXXXXXX,      XXXXXXX,    XXXXXXX,    XXXXXXX,        XXXXXXX,    XXXXXXX,    XXXXXXX,    _______,    _______,        _______,    _______,    XXXXXXX,    \
+XXXXXXX,    XXXXXXX,    XXXXXXX,    _______,    _______,        _______,    _______,      _______,    _______,    _______,        XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,    _______,        XXXXXXX,    _______,    XXXXXXX    \
+),
+[_NAVIGATION] = LAYOUT( \
+XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,    KC_PAUSE,       KC_NUMLOCK, XXXXXXX,      XXXXXXX,    XXXXXXX,    XXXXXXX,        XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,        XXXXXXX,    XXXXXXX,    XXXXXXX,    \
+XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,        XXXXXXX,    XXXXXXX,      XXXXXXX,    XXXXXXX,    XXXXXXX,        XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,        XXXXXXX,    _______,    _______,    \
+XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,        _______,    XXXXXXX,      XXXXXXX,    XXXXXXX,    XXXXXXX,        XXXXXXX,    XXXXXXX,    KC_HOME,    KC_PGDN,    KC_PGUP,        KC_END,     _______,    XXXXXXX,    \
+XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,    _______,        KC_DEL,     _______,      XXXXXXX,    KC_LSFT,    KC_LCTL,        XXXXXXX,    XXXXXXX,    KC_LEFT,    KC_DOWN,    KC_UP,          KC_RIGHT,   _______,    _______,    \
+XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,    _______,        _______,    _______,      XXXXXXX,    XXXXXXX,    XXXXXXX,        XXXXXXX,    XXXXXXX,    XXXXXXX,    _______,    _______,        _______,    _______,    XXXXXXX,    \
+XXXXXXX,    XXXXXXX,    XXXXXXX,    _______,    _______,        _______,    _______,      _______,    _______,    _______,        XXXXXXX,    XXXXXXX,    XXXXXXX,    XXXXXXX,    _______,        XXXXXXX,    _______,    XXXXXXX    \
+)
+// ),
+/// [_NAVIGATION] = {
+//   {XXXXXXX,             XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_HOME, KC_PGDN, KC_PGUP, KC_END, LCTL(KC_BSPC) },
+//   {KC_DEL,              LCTL(KC_A), XXXXXXX, KC_LSFT, KC_LCTL, XXXXXXX, XXXXXXX, KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT,  KC_DEL},
+//   {LCTL(KC_LSFT),       XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_RSFT, KC_RSFT, KC_RSFT, KC_ENT},
+//   {LCTL(LALT(KC_LSFT)),LCTL(KC_Z),  LCTL(KC_X), LCTL(KC_C),  LCTL(KC_V), _______, _______, _______, LCTL(KC_LEFT), LCTL(KC_DOWN), LCTL(KC_UP),   LCTL(KC_RGHT)}
+// }
+
+};

keyboards/bigswitch/README.md

@@ -3,6 +3,10 @@ Big Switch PCB by flehrad
 
 Designed by Don of the Board Podcast and sold as a kit by [keeb.io](https://keeb.io/collections/frontpage/products/big-switch-pcb?variant=7507922845726)
 
+### PCB Files
+
+https://github.com/flehrad/Big-Switch-PCB
+
 ### Technical Specifications
 
  * Uses a atmega32u4 pro micro or pin compatible MCU

keyboards/canoe/canoe.c

@@ -42,24 +42,55 @@ void backlight_init_ports(void) {
 
 #endif
 
+// for keyboard subdirectory level init functions
+// @Override
+void matrix_init_kb(void) {
+  // call user level keymaps, if any
+  matrix_init_user();
+}
+
 #ifdef RGBLIGHT_ENABLE
 extern rgblight_config_t rgblight_config;
 
+// custom RGB driver
 void rgblight_set(void) {
-    if (!rgblight_config.enable) {
-        for (uint8_t i = 0; i < RGBLED_NUM; i++) {
-            led[i].r = 0;
-            led[i].g = 0;
-            led[i].b = 0;
-        }
+  if (!rgblight_config.enable) {
+    for (uint8_t i=0; i<RGBLED_NUM; i++) {
+      led[i].r = 0;
+      led[i].g = 0;
+      led[i].b = 0;
     }
+  }
 
+  i2c_init();
+  i2c_send(0xb0, (uint8_t*)led, 3 * RGBLED_NUM);
+}
+
+bool rgb_init = false;
+
+void matrix_scan_kb(void) {
+  // if LEDs were previously on before poweroff, turn them back on
+  if (rgb_init == false && rgblight_config.enable) {
     i2c_init();
     i2c_send(0xb0, (uint8_t*)led, 3 * RGBLED_NUM);
+    rgb_init = true;
+  }
+
+  rgblight_task();
+#else
+void matrix_scan_kb(void) {
+#endif
+  matrix_scan_user();
+  /* Nothing else for now. */
 }
 
-__attribute__ ((weak))
-void matrix_scan_user(void) {
-    rgblight_task();
+__attribute__((weak)) // overridable
+void matrix_init_user(void) {
+
+}
+
+
+__attribute__((weak)) // overridable
+void matrix_scan_user(void) {
+
 }
-#endif

keyboards/canoe/canoe.h

@@ -20,35 +20,40 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "quantum.h"
 
+#define _x_ KC_NO
+
 #define LAYOUT_iso( \
   K0D, K0C, K0B, K0A, K09, K08, K07, K06, K05, K04, K03, K02, K01, K00, K0E, \
-  K1D, K1C, K1B, K1A, K19, K18, K17, K16, K15, K14, K13, K12, K11, K1E, \
+  K1D, K1C, K1B, K1A, K19, K18, K17, K16, K15, K14, K13, K12, K11,      K1E, \
   K2D, K2C, K2B, K2A, K29, K28, K27, K26, K25, K24, K23, K22, K10, K21, K2E, \
   K3D, K4A, K3C, K3B, K3A, K39, K38, K37, K36, K35, K34, K33, K32, K30, K3E, \
-  K4D, K4C, K4B, K48, K44, K43, K42, K40, K4E \
+  K4D, K4C, K4B,                K48,                K44, K43, K42, K40, K4E  \
 ){ \
   { K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, K0E }, \
   { K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, K1E }, \
-  { KC_NO, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D, K2E }, \
-  { K30, KC_NO, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K3D, K3E }, \
-  { K40, KC_NO, K42, K43, K44, KC_NO, KC_NO, KC_NO, K48, KC_NO, K4A, K4B, K4C, K4D, K4E }, \
-  { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
-  { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
-  { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
+  { _x_, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D, K2E }, \
+  { K30, _x_, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K3D, K3E }, \
+  { K40, _x_, K42, K43, K44, _x_, _x_, _x_, K48, _x_, K4A, K4B, K4C, K4D, K4E }, \
+  { _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_ }, \
+  { _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_ }, \
+  { _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_ }  \
 }
 
 #define LAYOUT( \
-  KD0, KC0, KB0, KA0, K90, K80, K70, K60, K50, K40, K30, K20, K10, K00, KE0, \
-  KD1, KC1, KB1, KA1, K91, K81, K71, K61, K51, K41, K31, K21, K11, K01, KE1, \
-  KD2, KC2, KB2, KA2, K92, K82, K72, K62, K52, K42, K32, K22, K12,      KE2, \
-  KD3, KC3, KB3, KA3, K93, K83, K73, K63, K53, K43, K33, K23,      K03, KE3, \
-  KD4, KC4, KB4,           K84,                     K44, K34, K24, K04, KE4  \
+  K0D, K0C, K0B, K0A, K09, K08, K07, K06, K05, K04, K03, K02, K01, K00, K0E, \
+  K1D, K1C, K1B, K1A, K19, K18, K17, K16, K15, K14, K13, K12, K11, K10, K1E, \
+  K2D, K2C, K2B, K2A, K29, K28, K27, K26, K25, K24, K23, K22,      K21, K2E, \
+  K3D,      K3C, K3B, K3A, K39, K38, K37, K36, K35, K34, K33, K32, K30, K3E, \
+  K4D, K4C, K4B,                K48,                K44, K43, K42, K40, K4E  \
 ){ \
-  { K00, K10, K20, K30, K40, K50, K60, K70, K80, K90, KA0, KB0, KC0, KD0, KE0 }, \
-  { K01, K11, K21, K31, K41, K51, K61, K71, K81, K91, KA1, KB1, KC1, KD1, KE1 }, \
-  { KC_NO, K12, K22, K32, K42, K52, K62, K72, K82, K92, KA2, KB2, KC2, KD2, KE2 }, \
-  { K03, KC_NO, K23, K33, K43, K53, K63, K73, K83, K93, KA3, KB3, KC3, KD3, KE3 }, \
-  { K04, KC_NO, K24, K34, K44, KC_NO, KC_NO, KC_NO, K84, KC_NO, KC_NO, KB4, KC4, KD4, KE4 } \
+  { K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, K0E }, \
+  { K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, K1E }, \
+  { _x_, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D, K2E }, \
+  { K30, _x_, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K3D, K3E }, \
+  { K40, _x_, K42, K43, K44, _x_, _x_, _x_, K48, _x_, _x_, K4B, K4C, K4D, K4E }, \
+  { _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_ }, \
+  { _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_ }, \
+  { _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_, _x_ }  \
 }
 
 #endif

keyboards/canoe/info.json

@@ -1,394 +1,17 @@
 {
-    "keyboard_name": "canoe",
-    "maintainer": "qmk",
-    "url": "",
-    "height": 8,
-    "width": 15,
-    "layouts": {
-        "LAYOUT_iso": {
-            "key_count": 68,
-            "layout": [
-                {
-                    "label": "Esc",
-                    "x": 0,
-                    "y": 0
-                },
-                {
-                    "label": "!",
-                    "x": 1,
-                    "y": 0
-                },
-                {
-                    "label": "@",
-                    "x": 2,
-                    "y": 0
-                },
-                {
-                    "label": "#",
-                    "x": 3,
-                    "y": 0
-                },
-                {
-                    "label": "$",
-                    "x": 4,
-                    "y": 0
-                },
-                {
-                    "label": "%",
-                    "x": 5,
-                    "y": 0
-                },
-                {
-                    "label": "^",
-                    "x": 6,
-                    "y": 0
-                },
-                {
-                    "label": "&",
-                    "x": 7,
-                    "y": 0
-                },
-                {
-                    "label": "*",
-                    "x": 8,
-                    "y": 0
-                },
-                {
-                    "label": "(",
-                    "x": 9,
-                    "y": 0
-                },
-                {
-                    "label": ")",
-                    "x": 10,
-                    "y": 0
-                },
-                {
-                    "label": "_",
-                    "x": 11,
-                    "y": 0
-                },
-                {
-                    "label": "+",
-                    "x": 12,
-                    "y": 0
-                },
-                {
-                    "label": "Backspace",
-                    "w": 2,
-                    "x": 13,
-                    "y": 0
-                },
-                {
-                    "label": "Insert",
-                    "x": 15,
-                    "y": 0
-                },
-                {
-                    "label": "Tab",
-                    "w": 1.5,
-                    "x": 0,
-                    "y": 1
-                },
-                {
-                    "label": "Q",
-                    "x": 1.5,
-                    "y": 1
-                },
-                {
-                    "label": "W",
-                    "x": 2.5,
-                    "y": 1
-                },
-                {
-                    "label": "E",
-                    "x": 3.5,
-                    "y": 1
-                },
-                {
-                    "label": "R",
-                    "x": 4.5,
-                    "y": 1
-                },
-                {
-                    "label": "T",
-                    "x": 5.5,
-                    "y": 1
-                },
-                {
-                    "label": "Y",
-                    "x": 6.5,
-                    "y": 1
-                },
-                {
-                    "label": "U",
-                    "x": 7.5,
-                    "y": 1
-                },
-                {
-                    "label": "I",
-                    "x": 8.5,
-                    "y": 1
-                },
-                {
-                    "label": "O",
-                    "x": 9.5,
-                    "y": 1
-                },
-                {
-                    "label": "P",
-                    "x": 10.5,
-                    "y": 1
-                },
-                {
-                    "label": "{",
-                    "x": 11.5,
-                    "y": 1
-                },
-                {
-                    "label": "}",
-                    "x": 12.5,
-                    "y": 1
-                },
-                {
-                    "ks": [
-                        [
-                            0,
-                            0
-                        ],
-                        [
-                            1.5,
-                            0
-                        ],
-                        [
-                            1.5,
-                            2
-                        ],
-                        [
-                            0.25,
-                            2
-                        ],
-                        [
-                            0.25,
-                            1
-                        ],
-                        [
-                            0,
-                            1
-                        ],
-                        [
-                            0,
-                            0
-                        ]
-                    ],
-                    "label": "Enter",
-                    "x": 13.5,
-                    "y": 1
-                },
-                {
-                    "label": "Delete",
-                    "x": 15,
-                    "y": 1
-                },
-                {
-                    "label": "Caps Lock",
-                    "w": 1.75,
-                    "x": 0,
-                    "y": 2
-                },
-                {
-                    "label": "A",
-                    "x": 1.75,
-                    "y": 2
-                },
-                {
-                    "label": "S",
-                    "x": 2.75,
-                    "y": 2
-                },
-                {
-                    "label": "D",
-                    "x": 3.75,
-                    "y": 2
-                },
-                {
-                    "label": "F",
-                    "x": 4.75,
-                    "y": 2
-                },
-                {
-                    "label": "G",
-                    "x": 5.75,
-                    "y": 2
-                },
-                {
-                    "label": "H",
-                    "x": 6.75,
-                    "y": 2
-                },
-                {
-                    "label": "J",
-                    "x": 7.75,
-                    "y": 2
-                },
-                {
-                    "label": "K",
-                    "x": 8.75,
-                    "y": 2
-                },
-                {
-                    "label": "l",
-                    "x": 9.75,
-                    "y": 2
-                },
-                {
-                    "label": ":",
-                    "x": 10.75,
-                    "y": 2
-                },
-                {
-                    "label": "\"",
-                    "x": 11.75,
-                    "y": 2
-                },
-                {
-                    "label": "\\",
-                    "x": 12.75,
-                    "y": 2
-                },
-                {
-                    "label": "Home",
-                    "x": 15,
-                    "y": 2
-                },
-                {
-                    "label": "Shift",
-                    "w": 1.25,
-                    "x": 0,
-                    "y": 3
-                },
-                {
-                    "label": "~",
-                    "x": 1.25,
-                    "y": 3
-                },
-                {
-                    "label": "Z",
-                    "x": 2.25,
-                    "y": 3
-                },
-                {
-                    "label": "X",
-                    "x": 3.25,
-                    "y": 3
-                },
-                {
-                    "label": "C",
-                    "x": 4.25,
-                    "y": 3
-                },
-                {
-                    "label": "V",
-                    "x": 5.25,
-                    "y": 3
-                },
-                {
-                    "label": "B",
-                    "x": 6.25,
-                    "y": 3
-                },
-                {
-                    "label": "N",
-                    "x": 7.25,
-                    "y": 3
-                },
-                {
-                    "label": "M",
-                    "x": 8.25,
-                    "y": 3
-                },
-                {
-                    "label": "<",
-                    "x": 9.25,
-                    "y": 3
-                },
-                {
-                    "label": ">",
-                    "x": 10.25,
-                    "y": 3
-                },
-                {
-                    "label": "?",
-                    "x": 11.25,
-                    "y": 3
-                },
-                {
-                    "label": "Shift",
-                    "w": 1.75,
-                    "x": 12.25,
-                    "y": 3
-                },
-                {
-                    "label": "Up",
-                    "x": 14,
-                    "y": 3
-                },
-                {
-                    "label": "Page Down",
-                    "x": 14,
-                    "y": 3
-                },
-                {
-                    "label": "Control",
-                    "w": 1.25,
-                    "x": 0,
-                    "y": 4
-                },
-                {
-                    "label": "Win",
-                    "w": 1.25,
-                    "x": 1.25,
-                    "y": 4
-                },
-                {
-                    "label": "Alt",
-                    "w": 1.25,
-                    "x": 2.5,
-                    "y": 4
-                },
-                {
-                    "w": 6.25,
-                    "x": 3.75,
-                    "y": 4
-                },
-                {
-                    "label": "Alt",
-                    "w": 1.25,
-                    "x": 10,
-                    "y": 4
-                },
-                {
-                    "label": "Fn0",
-                    "w": 1.25,
-                    "x": 11.25,
-                    "y": 4
-                },
-                {
-                    "label": "Left",
-                    "x": 13,
-                    "y": 4
-                },
-                {
-                    "label": "Down",
-                    "x": 14,
-                    "y": 4
-                },
-                {
-                    "label": "Right",
-                    "x": 15,
-                    "y": 4
-                }
-            ]
-        }
+  "keyboard_name": "Canoe",
+  "maintainer": "qmk",
+  "url": "",
+  "height": 8,
+  "width": 15,
+  "layouts": {
+    "LAYOUT_iso": {
+      "key_count": 68,
+      "layout": [{"label":"K0D", "x":0, "y":0}, {"label":"K0C", "x":1, "y":0}, {"label":"K0B", "x":2, "y":0}, {"label":"K0A", "x":3, "y":0}, {"label":"K09", "x":4, "y":0}, {"label":"K08", "x":5, "y":0}, {"label":"K07", "x":6, "y":0}, {"label":"K06", "x":7, "y":0}, {"label":"K05", "x":8, "y":0}, {"label":"K04", "x":9, "y":0}, {"label":"K03", "x":10, "y":0}, {"label":"K02", "x":11, "y":0}, {"label":"K01", "x":12, "y":0}, {"label":"K00", "x":13, "y":0, "w":2}, {"label":"K0E", "x":15, "y":0}, {"label":"K1D", "x":0, "y":1, "w":1.5}, {"label":"K1C", "x":1.5, "y":1}, {"label":"K1B", "x":2.5, "y":1}, {"label":"K1A", "x":3.5, "y":1}, {"label":"K19", "x":4.5, "y":1}, {"label":"K18", "x":5.5, "y":1}, {"label":"K17", "x":6.5, "y":1}, {"label":"K16", "x":7.5, "y":1}, {"label":"K15", "x":8.5, "y":1}, {"label":"K14", "x":9.5, "y":1}, {"label":"K13", "x":10.5, "y":1}, {"label":"K12", "x":11.5, "y":1}, {"label":"K11", "x":12.5, "y":1}, {"label":"K1E", "x":15, "y":1}, {"label":"K2D", "x":0, "y":2, "w":1.75}, {"label":"K2C", "x":1.75, "y":2}, {"label":"K2B", "x":2.75, "y":2}, {"label":"K2A", "x":3.75, "y":2}, {"label":"K29", "x":4.75, "y":2}, {"label":"K28", "x":5.75, "y":2}, {"label":"K27", "x":6.75, "y":2}, {"label":"K26", "x":7.75, "y":2}, {"label":"K25", "x":8.75, "y":2}, {"label":"K24", "x":9.75, "y":2}, {"label":"K23", "x":10.75, "y":2}, {"label":"K22", "x":11.75, "y":2}, {"label":"K10", "x":12.75, "y":2}, {"label":"K21", "x":13.75, "y":1, "w":1.25, "h":2}, {"label":"K2E", "x":15, "y":2}, {"label":"K3D", "x":0, "y":3, "w":1.25}, {"label":"K4A", "x":1.25, "y":3}, {"label":"K3C", "x":2.25, "y":3}, {"label":"K3B", "x":3.25, "y":3}, {"label":"K3A", "x":4.25, "y":3}, {"label":"K39", "x":5.25, "y":3}, {"label":"K38", "x":6.25, "y":3}, {"label":"K37", "x":7.25, "y":3}, {"label":"K36", "x":8.25, "y":3}, {"label":"K35", "x":9.25, "y":3}, {"label":"K34", "x":10.25, "y":3}, {"label":"K33", "x":11.25, "y":3}, {"label":"K32", "x":12.25, "y":3, "w":1.75}, {"label":"K30", "x":14, "y":3}, {"label":"K3E", "x":15, "y":3}, {"label":"K4D", "x":0, "y":4, "w":1.25}, {"label":"K4C", "x":1.25, "y":4, "w":1.25}, {"label":"K4B", "x":2.5, "y":4, "w":1.25}, {"label":"K48", "x":3.75, "y":4, "w":6.25}, {"label":"K44", "x":10, "y":4, "w":1.25}, {"label":"K43", "x":11.25, "y":4, "w":1.25}, {"label":"K42", "x":13, "y":4}, {"label":"K40", "x":14, "y":4}, {"label":"K4E", "x":15, "y":4}]
+    },
+    "LAYOUT": {
+      "key_count": 67,
+      "layout": [{"label":"K0D", "x":0, "y":0}, {"label":"K0C", "x":1, "y":0}, {"label":"K0B", "x":2, "y":0}, {"label":"K0A", "x":3, "y":0}, {"label":"K09", "x":4, "y":0}, {"label":"K08", "x":5, "y":0}, {"label":"K07", "x":6, "y":0}, {"label":"K06", "x":7, "y":0}, {"label":"K05", "x":8, "y":0}, {"label":"K04", "x":9, "y":0}, {"label":"K03", "x":10, "y":0}, {"label":"K02", "x":11, "y":0}, {"label":"K01", "x":12, "y":0}, {"label":"K00", "x":13, "y":0, "w":2}, {"label":"K0E", "x":15, "y":0}, {"label":"K1D", "x":0, "y":1, "w":1.5}, {"label":"K1C", "x":1.5, "y":1}, {"label":"K1B", "x":2.5, "y":1}, {"label":"K1A", "x":3.5, "y":1}, {"label":"K19", "x":4.5, "y":1}, {"label":"K18", "x":5.5, "y":1}, {"label":"K17", "x":6.5, "y":1}, {"label":"K16", "x":7.5, "y":1}, {"label":"K15", "x":8.5, "y":1}, {"label":"K14", "x":9.5, "y":1}, {"label":"K13", "x":10.5, "y":1}, {"label":"K12", "x":11.5, "y":1}, {"label":"K11", "x":12.5, "y":1}, {"label":"K10", "x":13.5, "y":1, "w":1.5}, {"label":"K1E", "x":15, "y":1}, {"label":"K2D", "x":0, "y":2, "w":1.75}, {"label":"K2C", "x":1.75, "y":2}, {"label":"K2B", "x":2.75, "y":2}, {"label":"K2A", "x":3.75, "y":2}, {"label":"K29", "x":4.75, "y":2}, {"label":"K28", "x":5.75, "y":2}, {"label":"K27", "x":6.75, "y":2}, {"label":"K26", "x":7.75, "y":2}, {"label":"K25", "x":8.75, "y":2}, {"label":"K24", "x":9.75, "y":2}, {"label":"K23", "x":10.75, "y":2}, {"label":"K22", "x":11.75, "y":2}, {"label":"K21", "x":12.75, "y":2, "w":2.25}, {"label":"K2E", "x":15, "y":2}, {"label":"K3D", "x":0, "y":3, "w":2.25}, {"label":"K3C", "x":2.25, "y":3}, {"label":"K3B", "x":3.25, "y":3}, {"label":"K3A", "x":4.25, "y":3}, {"label":"K39", "x":5.25, "y":3}, {"label":"K38", "x":6.25, "y":3}, {"label":"K37", "x":7.25, "y":3}, {"label":"K36", "x":8.25, "y":3}, {"label":"K35", "x":9.25, "y":3}, {"label":"K34", "x":10.25, "y":3}, {"label":"K33", "x":11.25, "y":3}, {"label":"K32", "x":12.25, "y":3, "w":1.75}, {"label":"K30", "x":14, "y":3}, {"label":"K3E", "x":15, "y":3}, {"label":"K4D", "x":0, "y":4, "w":1.25}, {"label":"K4C", "x":1.25, "y":4, "w":1.25}, {"label":"K4B", "x":2.5, "y":4, "w":1.25}, {"label":"K48", "x":3.75, "y":4, "w":6.25}, {"label":"K44", "x":10, "y":4, "w":1.25}, {"label":"K43", "x":11.25, "y":4, "w":1.25}, {"label":"K42", "x":13, "y":4}, {"label":"K40", "x":14, "y":4}, {"label":"K4E", "x":15, "y":4}]
     }
+  }
 }

keyboards/canoe/keymaps/dhertz/keymap.c

@@ -0,0 +1,62 @@
+#include QMK_KEYBOARD_H
+#include "dhertz.h"
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    /* Layer 0: Default Layer
+     * ,---------------------------------------------------------------.
+     * |Esc|  1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =| Backsp|Del|
+     * |---------------------------------------------------------------|
+     * |Tab  |  Q|  W|  E|  R|  T|  Y|  U|  I|  O|  P|  [|  ]|Enter|Hom|
+     * |------------------------------------------------------`    |---|
+     * |SrCtl |  A|  S|  D|  F|  G|  H|  J|  K|  L|  ;|  '|  \|    |End|
+     * |---------------------------------------------------------------|
+     * |Shif|  #|  Z|  X|  C|  V|  B|  N|  M|  ,|  .|  /|Shift |Up |PgD|
+     * |---------------------------------------------------------------|
+     * |NcCtl|  Alt| CTab|       LyrSpc        |  CGv|  Alt|Lef|Dow|Rig|
+     * `---------------------------------------------------------------'
+     */
+  [0] = LAYOUT_iso(
+      KC_ESC, KC_1,  KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_DEL,
+      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_HOME,
+      SRCH_CTL,   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_ENT, KC_END,
+      KC_LSFT, HSH_TLD, 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,
+      NC_CTL, KC_LALT, CMD_TAB_CMD, LYR_SPC, CMD_GRV_CMD, KC_RALT, KC_LEFT, KC_DOWN, KC_RIGHT
+      ),
+    /* Layer 1: Special
+     * ,---------------------------------------------------------------.
+     * |  §| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|       |Iso|
+     * |---------------------------------------------------------------|
+     * |     |   |   |   |   |   |   |   |   |   |   |   |   |     |   |
+     * |------------------------------------------------------`    |---|
+     * |      |   |   |   |   |   |   |   |   |CSL|   |   |  `|    |   |
+     * |---------------------------------------------------------------|
+     * |    |  `|   |   |CAC|   |   |   |   |   |   |   |      |PgU|   |
+     * |---------------------------------------------------------------|
+     * |     |     |     |                     |     |     |Hom|PgD|End|
+     * `---------------------------------------------------------------'
+     */
+  [1] = LAYOUT_iso(
+      KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F10, KC_F11, KC_TRNS, ISO_COUNTRY_CODE,
+      KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+      KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, CMD_SFT_L, KC_TRNS, KC_TRNS, KC_NUBS, KC_TRNS, KC_TRNS,
+      KC_TRNS, KC_NUBS, KC_TRNS, KC_TRNS, CMD_ALT_C, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PGUP, KC_TRNS,
+      KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_HOME, KC_PGDOWN, KC_END
+      ),
+};
+
+void matrix_init_keymap(void) {
+    rgblight_enable_noeeprom();
+    rgblight_sethsv_teal();
+}
+
+uint32_t layer_state_set_keymap(uint32_t state) {
+    switch (biton32(state)) {
+        case 1:
+            rgblight_sethsv_noeeprom_magenta();
+            break;
+        default: //  for any other layers, or the default layer
+            rgblight_sethsv_noeeprom_cyan();
+            break;
+    }
+    return state;
+}

keyboards/canoe/matrix.c

@@ -21,7 +21,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "matrix.h"
 
 #ifndef DEBOUNCE
-#define DEBOUNCE	5
+#   define DEBOUNCE	5
 #endif
 
 static uint8_t debouncing = DEBOUNCE;
@@ -29,6 +29,9 @@ static uint8_t debouncing = DEBOUNCE;
 static matrix_row_t matrix[MATRIX_ROWS];
 static matrix_row_t matrix_debouncing[MATRIX_ROWS];
 
+void matrix_set_row_status(uint8_t row);
+uint8_t bit_reverse(uint8_t x);
+
 void matrix_init(void) {
     // all outputs for rows high
     DDRB = 0xFF;
@@ -47,18 +50,8 @@ void matrix_init(void) {
         matrix[row] = 0x00;
         matrix_debouncing[row] = 0x00;
     }
-}
 
-void matrix_set_row_status(uint8_t row) {
-    DDRB = (1 << row);
-    PORTB = ~(1 << row);
-}
-
-uint8_t bit_reverse(uint8_t x) {
-    x = ((x >> 1) & 0x55) | ((x << 1) & 0xaa);
-    x = ((x >> 2) & 0x33) | ((x << 2) & 0xcc);
-    x = ((x >> 4) & 0x0f) | ((x << 4) & 0xf0);
-    return x;
+    matrix_init_quantum();
 }
 
 uint8_t matrix_scan(void) {
@@ -93,11 +86,24 @@ uint8_t matrix_scan(void) {
         }
     }
 
-    matrix_scan_user();
+    matrix_scan_quantum();
 
     return 1;
 }
 
+// declarations
+void matrix_set_row_status(uint8_t row) {
+    DDRB = (1 << row);
+    PORTB = ~(1 << row);
+}
+
+uint8_t bit_reverse(uint8_t x) {
+    x = ((x >> 1) & 0x55) | ((x << 1) & 0xaa);
+    x = ((x >> 2) & 0x33) | ((x << 2) & 0xcc);
+    x = ((x >> 4) & 0x0f) | ((x << 4) & 0xf0);
+    return x;
+}
+
 inline matrix_row_t matrix_get_row(uint8_t row) {
     return matrix[row];
 }

keyboards/canoe/readme.md

@@ -3,10 +3,8 @@ CANOE
 
 A 65% keyboard with some RGB
 
-Keyboard Maintainer: QMK Community
-
-Hardware Supported: Canoe
-
+Keyboard Maintainer: QMK Community  
+Hardware Supported: Canoe  
 Hardware Availability: https://geekhack.org/index.php?topic=92418.0
 
 Make example for this keyboard (after setting up your build environment):

keyboards/chimera_ergo/chimera_ergo.h

@@ -49,7 +49,7 @@
 // This a shortcut to help you visually see your layout.
 // The first section contains all of the arguements
 // The second converts the arguments into a two-dimensional array
-#define KC_KEYMAP( \
+#define LAYOUT_kc( \
   k00, k01, k02, k03, k04, k05,      k06, k07, k08, k09, k10, k11, \
   k12, k13, k14, k15, k16, k17,      k18, k19, k20, k21, k22, k23, \
   k24, k25, k26, k27, k28, k29,      k30, k31, k32, k33, k34, k35, \
@@ -64,7 +64,7 @@
 	{ KC_##k29, KC_##k41, KC_##k03, KC_##k40, KC_##k37, KC_NO,         KC_##k30, KC_##k43, KC_##k08, KC_##k10, KC_##k46, KC_NO     }, \
 }
 
-#define KEYMAP( \
+#define LAYOUT( \
   k00, k01, k02, k03, k04, k05,      k06, k07, k08, k09, k10, k11, \
   k12, k13, k14, k15, k16, k17,      k18, k19, k20, k21, k22, k23, \
   k24, k25, k26, k27, k28, k29,      k30, k31, k32, k33, k34, k35, \

keyboards/chimera_ergo/info.json

@@ -0,0 +1,13 @@
+{
+  "keyboard_name": "Chimera Ergo",
+  "url": "",
+  "maintainer": "qmk",
+  "width": 13,
+  "height": 6,
+  "layouts": {
+    "LAYOUT": {
+      "key_count": 52,
+      "layout": [{"label":"k00", "x":0, "y":1}, {"label":"k01", "x":1, "y":0.75}, {"label":"k02", "x":2, "y":0.25}, {"label":"k03", "x":3, "y":0}, {"label":"k04", "x":4, "y":0.25}, {"label":"k05", "x":5, "y":0.5}, {"label":"k06", "x":7, "y":0.5}, {"label":"k07", "x":8, "y":0.25}, {"label":"k08", "x":9, "y":0}, {"label":"k09", "x":10, "y":0.25}, {"label":"k10", "x":11, "y":0.75}, {"label":"k11", "x":12, "y":1}, {"label":"k12", "x":0, "y":2}, {"label":"k13", "x":1, "y":1.75}, {"label":"k14", "x":2, "y":1.25}, {"label":"k15", "x":3, "y":1}, {"label":"k16", "x":4, "y":1.25}, {"label":"k17", "x":5, "y":1.5}, {"label":"k18", "x":7, "y":1.5}, {"label":"k19", "x":8, "y":1.25}, {"label":"k20", "x":9, "y":1}, {"label":"k21", "x":10, "y":1.25}, {"label":"k22", "x":11, "y":1.75}, {"label":"k23", "x":12, "y":2}, {"label":"k24", "x":0, "y":3}, {"label":"k25", "x":1, "y":2.75}, {"label":"k26", "x":2, "y":2.25}, {"label":"k27", "x":3, "y":2}, {"label":"k28", "x":4, "y":2.25}, {"label":"k29", "x":5, "y":2.5}, {"label":"k30", "x":7, "y":2.5}, {"label":"k31", "x":8, "y":2.25}, {"label":"k32", "x":9, "y":2}, {"label":"k33", "x":10, "y":2.25}, {"label":"k34", "x":11, "y":2.75}, {"label":"k35", "x":12, "y":3}, {"label":"k36", "x":0, "y":4}, {"label":"k37", "x":1, "y":3.75}, {"label":"k38", "x":2, "y":3.25}, {"label":"k39", "x":3, "y":3}, {"label":"k40", "x":4, "y":3.25}, {"label":"k41", "x":5, "y":3.5}, {"label":"k42", "x":7, "y":3.5}, {"label":"k43", "x":8, "y":3.25}, {"label":"k44", "x":9, "y":3}, {"label":"k45", "x":10, "y":3.25}, {"label":"k46", "x":11, "y":3.75}, {"label":"k47", "x":12, "y":4}, {"label":"k48", "x":4, "y":4.75}, {"label":"k49", "x":5, "y":5}, {"label":"k50", "x":7, "y":5}, {"label":"k51", "x":8, "y":4.75}]
+    }
+  }
+}

keyboards/chimera_ergo/keymaps/default/keymap.c

@@ -1,7 +1,7 @@
 // this is the style you want to emulate.
 // This is the canonical layout file for the Quantum project. If you want to add another keyboard,
 
-#include "chimera_ergo.h"
+#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.
@@ -9,30 +9,29 @@
 // entirely and just use numbers.
 enum chimera_ergo_layers
 {
-	_QWERTY,
-	_CAPS,
-	_NUMPAD,
-	_SYMBOLS,
-	_MACROS,
-	_NAV
+  _QWERTY,
+  _CAPS,
+  _NUMPAD,
+  _SYMBOLS,
+  _MACROS,
+  _NAV
 };
 
-#define KC_NMPD TG(_NUMPAD)
-#define KC_SYMB TG(_SYMBOLS)
-#define KC_SPFN LT(_NAV,KC_EQL)
-#define KC_SCTL MT(MOD_LCTL, KC_LBRC)
-#define KC_SCTR MT(MOD_LCTL, KC_RBRC)
-#define KC_SPLT MT(MOD_LALT, KC_MINS)
-#define KC_SPRT MT(MOD_LALT, KC_1)
-#define KC_GBRC MT(MOD_RGUI, KC_RBRC)
-#define KC_GQOT MT(MOD_LGUI, KC_QUOT)
-#define KC_MESC LT(_MACROS, KC_ESC)
-#define KC_INCL M(0)
-#define KC_PULL M(1)
-#define KC_PUSH M(2)
-#define KC_SCAP M(3)
-#define KC_SCOF M(4)
-#define KC_CAD LALT(LCTL(KC_DEL))
+#define SC_NMPD TG(_NUMPAD)
+#define SC_SYMB TG(_SYMBOLS)
+#define SC_SPFN LT(_NAV,KC_EQL)
+#define SC_SCTL MT(MOD_LCTL, KC_LBRC)
+#define SC_SCTR MT(MOD_LCTL, KC_RBRC)
+#define SC_SPLT MT(MOD_LALT, KC_MINS)
+#define SC_SPRT MT(MOD_LALT, KC_1)
+#define SC_GBRC MT(MOD_RGUI, KC_RBRC)
+#define SC_MESC LT(_MACROS, KC_ESC)
+#define SC_INCL M(0)
+#define SC_PULL M(1)
+#define SC_PUSH M(2)
+#define SC_SCAP M(3)
+#define SC_SCOF M(4)
+#define SC_CAD LALT(LCTL(KC_DEL))
 
 #define LONGPRESS_DELAY 150
 //#define LAYER_TOGGLE_DELAY 300
@@ -40,95 +39,57 @@ enum chimera_ergo_layers
 // Fillers to make layering more clear
 #define _______ KC_TRNS
 #define XXXXXXX KC_NO
-#define KC_ KC_TRNS 
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
-  [_QWERTY] = KC_KEYMAP(
-  //,----+----+----+----+----+----.     ,----+----+----+----+----+----.
-     LBRC, 1  ,SCTL,SPLT,SPFN, 5  ,       6  ,GBRC,SPRT,SCTR, 0  ,RBRC,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-     MESC, Q  , W  , E  , R  , T  ,       Y  , U  , I  , O  , P  ,QUOT,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-     TAB , A  , S  , D  , F  , G  ,       H  , J  , K  , L  ,SCLN,ENT ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-     LSPO, Z  , X  , C  , V  , B  ,       N  , M  ,COMM,DOT ,SLSH,RSPC,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-                         NMPD,BSPC,      SPC ,SYMB
-  // \------------------+----+----/      \---+----+----+--------------/
+  [_QWERTY] = LAYOUT(
+     KC_LBRC, KC_1,    SC_SCTL, SC_SPLT, SC_SPFN, KC_5,          KC_6,    SC_GBRC, SC_SPRT, SC_SCTR, KC_0,    KC_RBRC,
+     SC_MESC, KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,          KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_QUOT,
+     KC_TAB,  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,          KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_ENT,
+     KC_LSPO, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,          KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSPC,
+                                         SC_NMPD, KC_BSPC,       KC_SPC,  SC_SYMB
   ),
 
-  [_CAPS] = KC_KEYMAP(
-  //,----+----+----+----+----+----.     ,----+----+----+----+----+----.
-         ,UNDS,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-         ,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-         ,    ,    ,    ,    ,    ,          ,    ,    ,    ,COLN,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-     SCOF,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,SCOF,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-                             ,    ,          ,
-  // \------------------+----+----/      \---+----+----+--------------/
+  [_CAPS] = LAYOUT(
+     _______, KC_UNDS, _______, _______, _______, _______,       _______, _______, _______, _______, _______, _______,
+     _______, _______, _______, _______, _______, _______,       _______, _______, _______, _______, _______, _______,
+     _______, _______, _______, _______, _______, _______,       _______, _______, _______, _______, KC_COLN, _______,
+     SC_SCOF, _______, _______, _______, _______, _______,       _______, _______, _______, _______, _______, SC_SCOF,
+                                         _______, _______,       _______, _______
   ),
 
-  [_NUMPAD] = KC_KEYMAP(
-  //,----+----+----+----+----+----.     ,----+----+----+----+----+----.
-         ,    ,    ,    ,    ,    ,          ,    ,    ,    ,MINS,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-         ,    ,COLN,    ,    ,    ,          , 7  , 8  , 9  ,ASTR,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-         ,    ,DOT ,    ,    ,    ,          , 4  , 5  , 6  ,PLUS,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-         ,    ,    ,    ,    ,    ,          , 1  , 2  , 3  ,SLSH,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-                             ,    ,          , 0
-  // \------------------+----+----/      \---+----+----+--------------/
+  [_NUMPAD] = LAYOUT(
+     _______, _______, _______, _______, _______, _______,       _______, _______, _______, _______, KC_MINS, _______,
+     _______, _______, KC_COLN, _______, _______, _______,       _______, KC_7,    KC_8,    KC_9,    KC_ASTR, _______,
+     _______, _______, KC_DOT , _______, _______, _______,       _______, KC_4,    KC_5,    KC_6,    KC_PLUS, _______,
+     _______, _______, _______, _______, _______, _______,       _______, KC_1,    KC_2,    KC_3,    KC_SLSH, _______,
+                                         _______, _______,       _______, KC_0
   ),
 
-  [_SYMBOLS] = KC_KEYMAP(
-  //,----+----+----+----+----+----.     ,----+----+----+----+----+----.
-         ,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-         ,EXLM, AT ,HASH,DLR ,PERC,      CIRC,AMPR,ASTR,LPRN,RPRN,BSLS,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-      F1 , F2 , F3 , F4 , F5 , F6 ,      TILD,EQL ,UNDS,LCBR,RCBR,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-      F7 , F8 , F9 ,F10 ,F11 ,F12 ,      GRV ,PLUS,MINS,LBRC,RBRC,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-                         PIPE,    ,          ,
-  // \------------------+----+----/      \---+----+----+--------------/
+  [_SYMBOLS] = LAYOUT(
+     _______, _______, _______, _______, _______, _______,       _______, _______, _______, _______, _______, _______,
+     _______, KC_EXLM, KC_AT,   KC_HASH, KC_DLR,  KC_PERC,       KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSLS,
+     KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,         KC_TILD, KC_EQL,  KC_UNDS, KC_LCBR, KC_RCBR, _______,
+     KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,        KC_GRV,  KC_PLUS, KC_MINS, KC_LBRC, KC_RBRC, _______,
+                                         KC_PIPE, _______,       _______, _______
   ),
 
-  [_MACROS] = KC_KEYMAP(  
-  //,----+----+----+----+----+----.     ,----+----+----+----+----+----.
-         ,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-         ,    ,    ,    ,    ,    ,          ,    ,INCL,    ,    ,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-         ,    ,    ,CAD ,    ,    ,          ,    ,    ,    ,    ,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-     SCAP,    ,    ,    ,    ,    ,          ,    ,PULL,PUSH,    ,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-                             ,    ,          ,    
-  // \------------------+----+----/      \---+----+----+--------------/
+  [_MACROS] = LAYOUT(
+     _______, _______, _______, _______, _______, _______,       _______, _______, _______, _______, _______, _______,
+     _______, _______, _______, _______, _______, _______,       _______, _______, SC_INCL, _______, _______, _______,
+     _______, _______, _______, SC_CAD,  _______, _______,       _______, _______, _______, _______, _______, _______,
+     SC_SCAP, _______, _______, _______, _______, _______,       _______, _______, SC_PULL, SC_PUSH, _______, _______,
+                                         _______, _______,       _______, _______
   ),
 
-  [_NAV] = KC_KEYMAP(  
-  //,----+----+----+----+----+----.     ,----+----+----+----+----+----.
-         ,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-         ,    ,    ,    ,    ,    ,          ,PGUP, UP ,PGDN,PSCR,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-         ,    ,    ,    ,    ,    ,          ,LEFT,DOWN,RGHT,    ,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-         ,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,
-  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
-                             ,DEL ,          ,    
-  // \------------------+----+----/      \---+----+----+--------------/
+  [_NAV] = LAYOUT(
+     _______, _______, _______, _______, _______, _______,       _______, _______, _______, _______, _______, _______,
+     _______, _______, _______, _______, _______, _______,       _______, KC_PGUP, KC_UP,   KC_PGDN, KC_PSCR, _______,
+     _______, _______, _______, _______, _______, _______,       _______, KC_LEFT, KC_DOWN, KC_RGHT, _______, _______,
+     _______, _______, _______, _______, _______, _______,       _______, _______, _______, _______, _______, _______,
+                                         _______, KC_DEL,        _______, _______
   ),
 
-
 };
 
 
@@ -175,18 +136,18 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
   }
   return MACRO_NONE;
 };
- 
+
 
 void matrix_scan_user(void) {
     uint8_t layer = biton32(layer_state);
-    
+
     switch (layer) {
-    	case _QWERTY:
-    	    set_led_green;
-    	    break;
+      case _QWERTY:
+          set_led_green;
+          break;
         case _CAPS:
-	    set_led_white;
-	    break;
+      set_led_white;
+      break;
         case _NUMPAD:
             set_led_blue;
             break;
@@ -194,11 +155,11 @@ void matrix_scan_user(void) {
             set_led_red;
             break;
         case _NAV:
-	    set_led_magenta;
-	    break;
+      set_led_magenta;
+      break;
         case _MACROS:
-	    set_led_cyan;
-	    break;
+      set_led_cyan;
+      break;
        default:
             set_led_green;
             break;

keyboards/chimera_ergo/readme.md

@@ -5,10 +5,7 @@
 A split wireless 40% ergonomic keyboard 
 
 Keyboard Maintainer: [William Wilson](https://github.com/GlenPickle)  
-
-
-Hardware Supported: Chimera Ergo PCB, WaveShare core nRF51822
-
+Hardware Supported: Chimera Ergo PCB, WaveShare core nRF51822  
 Hardware Availability: [Gerbers](https://github.com/GlenPickle/Chimera/tree/master/ergo/gerbers)
 
 Make example for this keyboard (after setting up your build environment):

keyboards/chimera_ortho/keymaps/dcompact/README.md

@@ -0,0 +1,45 @@
+# DCompact Layout
+
+**Dvorak, Layered, Mouse-Enabled, Compact -- Plover coming soon!?!~**
+
+_See [the layout source](keymap.c) for the actual layout_
+
+## Goals
+
+The following are the goals kept in mind when designing the DCompact
+layout:
+
+- Provide minimal travel distance when typing English or coding
+- Consistent muscle memory translation from standard QWERTY
+- Stateless typing experience
+- OS-agnostic features, macros, and key placement
+- Minimize dependence on mouse usage
+
+These are generally all met or balanced within reason. This layout is
+not intended at all to be a familiar layout for much of anyone (except
+maybe those who already type in Dvorak) -- this is meant to amplify the
+best parts of having limited, ortholinear keys with layering.
+
+## As Reference Material
+
+If you're reading this hoping to find reference material to implement
+your own layout, then please feel free to copy over this layout and
+make edits where you see fit. I removed a lot of the features I felt
+extraneous to my usage and simplified style where I felt needed. This
+would hopefully mean that my code should feel like a good base to
+develop from for those new to QMK.
+
+_Remember that settings defined in the layout directory override and
+merge with those in the keyboard folder_
+
+## Relevant Links
+
+- ![Online Dvorak Layout Trainer](https://learn.dvorak.nl/)
+- ![Dvorak Wikipedia Page](https://en.wikipedia.org/wiki/Dvorak_Simplified_Keyboard)
+- ![QMK Docs](https://docs.qmk.fm/#/)
+- ![QMK KeyCode Reference](https://docs.qmk.fm/#/keycodes)
+
+## Contact
+
+Maintainer: [Dan](https://github.com/loksonarius)
+

keyboards/chimera_ortho/keymaps/dcompact/config.h

@@ -0,0 +1,9 @@
+#define TAPPING_TERM 150
+#define TAPPING_TOGGLE 2
+
+#define MOUSEKEY_DELAY             200
+#define MOUSEKEY_INTERVAL          60
+#define MOUSEKEY_MAX_SPEED         50
+#define MOUSEKEY_TIME_TO_MAX       80
+#define MOUSEKEY_WHEEL_MAX_SPEED   8
+#define MOUSEKEY_WHEEL_TIME_TO_MAX 15

keyboards/chimera_ortho/keymaps/dcompact/keymap.c

@@ -0,0 +1,119 @@
+#include "chimera_ortho.h"
+
+enum chimera_ortho_layers
+{
+	_BASE,
+	_NAV,
+	_SYM,
+	_FUNC,
+	_MOUSE
+};
+
+#define KC_NAV MO(_NAV)
+#define KC_SYM MO(_SYM)
+#define KC_FUNC MO(_FUNC)
+#define KC_MOUSE TT(_MOUSE)
+
+#define KC_DELSHFT SFT_T(KC_DEL)
+#define KC_CTLENT CTL_T(KC_ENT)
+#define KC_SYMSPC LT(_SYM, KC_SPC)
+
+#define KC_WK_LEFT LCA(KC_LEFT)
+#define KC_WK_DOWN LCA(KC_DOWN)
+#define KC_WK_UP LCA(KC_UP)
+#define KC_WK_RGHT LCA(KC_RGHT)
+
+#define KC_QUAKE LCTL(KC_GRAVE)
+
+#define LONGPRESS_DELAY 150
+
+// These are needed because of the 'KC_'-adding macro
+// This macro can be found in ../../chimera_ortho.h
+#define KC_RESET RESET
+#define KC_ KC_TRNS 
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+  [_BASE] = KC_KEYMAP(
+      //,-------+-------+-------+-------+-------+-------+-------.    ,-------+-------+-------+-------+-------+-------+-------.
+         LALT   ,TAB    ,QUOT   ,COMM   ,DOT    ,P      ,Y           ,F      ,G      ,C      ,R      ,L      ,SLSH   ,FUNC   
+      //|-------+-------+-------+-------+-------+-------+-------|    |-------+-------+-------+-------+-------+-------+-------|
+        ,LGUI   ,ESC    ,A      ,O      ,E      ,U      ,I           ,D      ,H      ,T      ,N      ,S      ,MINS   ,MOUSE  
+      //|-------+-------+-------+-------+-------+-------+-------|    |-------+-------+-------+-------+-------+-------+-------|
+        ,LCTL   ,DELSHFT,SCLN   ,Q      ,J      ,K      ,X           ,B      ,M      ,W      ,V      ,Z      ,BSPC   ,ENTER
+      //|-------+-------+-------+-------+-------+-------+-------|    |-------+-------+-------+-------+-------+-------+-------|
+                                        ,LSHIFT ,NAV                         ,SYMSPC ,CTLENT
+      //\-------------------------------+-------+-------+-------/    \-------+-------+---------------------------------------/
+  ),
+
+  [_NAV] = KC_KEYMAP(
+      //,-------+-------+-------+-------+-------+-------+-------.    ,-------+-------+-------+-------+-------+-------+-------.
+                ,       ,       ,       ,       ,       ,            ,       ,HOME   ,PGDOWN ,PGUP   ,END    ,       ,       
+      //|-------+-------+-------+-------+-------+-------+-------|    |-------+-------+-------+-------+-------+-------+-------|
+        ,       ,PSCR   ,MENU   ,       ,       ,       ,            ,       ,LEFT   ,DOWN   ,UP     ,RIGHT  ,       ,       
+      //|-------+-------+-------+-------+-------+-------+-------|    |-------+-------+-------+-------+-------+-------+-------|
+        ,       ,CAPS   ,NLCK   ,INS    ,       ,       ,            ,       ,WK_LEFT,WK_DOWN,WK_UP  ,WK_RGHT,       ,     
+      //|-------+-------+-------+-------+-------+-------+-------|    |-------+-------+-------+-------+-------+-------+-------|
+                                        ,       ,                            ,       ,    
+      //\-------------------------------+-------+-------+-------/    \-------+-------+---------------------------------------/
+  ),
+
+  [_SYM] = KC_KEYMAP(
+      //,-------+-------+-------+-------+-------+-------+-------.    ,-------+-------+-------+-------+-------+-------+-------.
+                ,QUAKE  ,GRAVE  ,TILDE  ,BSLASH ,PIPE   ,LPRN        ,RPRN   ,7      ,8      ,9      ,SLSH   ,EQUAL  ,       
+      //|-------+-------+-------+-------+-------+-------+-------|    |-------+-------+-------+-------+-------+-------+-------|
+        ,       ,       ,EXLM   ,AT     ,HASH   ,DLR    ,LCBR        ,RCBR   ,4      ,5      ,6      ,ASTR   ,PLUS   ,       
+      //|-------+-------+-------+-------+-------+-------+-------|    |-------+-------+-------+-------+-------+-------+-------|
+        ,       ,       ,PERC   ,CIRC   ,AMPR   ,ASTR   ,LBRC        ,RBRC   ,1      ,2      ,3      ,MINUS  ,       ,     
+      //|-------+-------+-------+-------+-------+-------+-------|    |-------+-------+-------+-------+-------+-------+-------|
+                                        ,       ,                            ,       ,0
+      //\-------------------------------+-------+-------+-------/    \-------+-------+---------------------------------------/
+  ),
+
+  [_FUNC] = KC_KEYMAP(
+      //,-------+-------+-------+-------+-------+-------+-------.    ,-------+-------+-------+-------+-------+-------+-------.
+                ,RESET  ,SLEP   ,MRWD   ,MPLY   ,MFFD   ,            ,       ,F9     ,F10    ,F11    ,F12    ,       ,       
+      //|-------+-------+-------+-------+-------+-------+-------|    |-------+-------+-------+-------+-------+-------+-------|
+        ,       ,       ,PWR    ,MUTE   ,VOLD   ,VOLU   ,            ,       ,F5     ,F6     ,F7     ,F8     ,       ,       
+      //|-------+-------+-------+-------+-------+-------+-------|    |-------+-------+-------+-------+-------+-------+-------|
+        ,       ,       ,WAKE   ,MPRV   ,MPLY   ,MNXT   ,            ,       ,F1     ,F2     ,F3     ,F4     ,       ,     
+      //|-------+-------+-------+-------+-------+-------+-------|    |-------+-------+-------+-------+-------+-------+-------|
+                                        ,       ,                            ,       ,    
+      //\-------------------------------+-------+-------+-------/    \-------+-------+---------------------------------------/
+  ),
+
+  [_MOUSE] = KC_KEYMAP(
+      //,-------+-------+-------+-------+-------+-------+-------.    ,-------+-------+-------+-------+-------+-------+-------.
+                ,       ,       ,       ,       ,       ,            ,       ,       ,       ,       ,       ,       ,       
+      //|-------+-------+-------+-------+-------+-------+-------|    |-------+-------+-------+-------+-------+-------+-------|
+        ,       ,       ,       ,BTN1   ,BTN3   ,BTN2   ,            ,       ,MS_L   ,MS_D   ,MS_U   ,MS_R   ,       ,       
+      //|-------+-------+-------+-------+-------+-------+-------|    |-------+-------+-------+-------+-------+-------+-------|
+        ,       ,       ,       ,ACL0   ,ACL1   ,ACL2   ,            ,       ,WH_L   ,WH_D   ,WH_U   ,WH_R   ,       ,     
+      //|-------+-------+-------+-------+-------+-------+-------|    |-------+-------+-------+-------+-------+-------+-------|
+                                        ,       ,                            ,       ,    
+      //\-------------------------------+-------+-------+-------/    \-------+-------+---------------------------------------/
+  ),
+};
+
+// These control the color of the LED on the receiver
+// For color reference, see ../../chimera_ortho.h
+void matrix_scan_user(void) {
+    uint8_t layer = biton32(layer_state);
+    
+    switch (layer) {
+        case _BASE:
+            set_led_cyan;
+            break;
+        case _NAV:
+            set_led_blue;
+            break;
+        case _SYM:
+            set_led_magenta;
+            break;
+        case _FUNC:
+            set_led_yellow;
+        default:
+            set_led_white;
+            break;
+    }
+};

keyboards/chimera_ortho/keymaps/dcompact/rules.mk

@@ -0,0 +1 @@
+MOUSEKEY_ENABLE = yes

keyboards/chocopad/chocopad.h

@@ -3,7 +3,7 @@
 
 #include "quantum.h"
 
-#define KEYMAP( \
+#define LAYOUT_ortho_4x4( \
     A1, A2, A3, A4, \
     B1, B2, B3, B4, \
     C1, C2, C3, C4, \
@@ -16,13 +16,13 @@
 }
 
 // Used to create a keymap using only KC_ prefixed keys
-#define KC_KEYMAP( \
+#define LAYOUT_kc( \
     A1, A2, A3, A4, \
     B1, B2, B3, B4, \
     C1, C2, C3, C4, \
     D1, D2, D3, D4 \
 ) \
-    KEYMAP( \
+    LAYOUT_ortho_4x4( \
         KC_##A1, KC_##A2, KC_##A3, KC_##A4, \
         KC_##B1, KC_##B2, KC_##B3, KC_##B4, \
         KC_##C1, KC_##C2, KC_##C3, KC_##C4, \

keyboards/chocopad/info.json

@@ -0,0 +1,12 @@
+{
+  "keyboard_name": "Chocopad",
+  "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}]
+    }
+  }
+}

keyboards/chocopad/keymaps/default/keymap.c

@@ -1,61 +1,30 @@
-#include "chocopad.h"
+#include QMK_KEYBOARD_H
 
 #define _BASE 0
 #define _FN1 1
 #define _FN2 2
 
-#define KC_ KC_TRNS
 #define _______ KC_TRNS
 
-#define KC_X1 MO(_FN1)
-#define KC_X2 MO(_FN2)
-#define KC_RST RESET
-#define KC_BSTP BL_STEP
-#define KC_RTOG RGB_TOG
-#define KC_RMOD RGB_MOD
-#define KC_RHUI RGB_HUI
-#define KC_RHUD RGB_HUD
-#define KC_RSAI RGB_SAI
-#define KC_RSAD RGB_SAD
-#define KC_RVAI RGB_VAI
-#define KC_RVAD RGB_VAD
-
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
-  [_BASE] = KC_KEYMAP(
-  //,----+----+----+----.
-     PGUP,HOME, UP ,END ,
-  //|----+----+----+----|
-     PGDN,LEFT,DOWN,RGHT,
-  //|----+----+----+----|
-      X2 ,VOLU,MPLY,MPRV,
-  //|----+----+----+----|
-      X1 ,VOLD,MUTE,MNXT
-  //`----+----+----+----'
+  [_BASE] = LAYOUT_ortho_4x4(
+    KC_PGUP,  KC_HOME,  KC_UP,    KC_END , \
+    KC_PGDN,  KC_LEFT,  KC_DOWN,  KC_RGHT, \
+    MO(_FN2), KC_VOLU,  KC_MPLY,  KC_MPRV, \
+    MO(_FN1), KC_VOLD,  KC_MUTE,  KC_MNXT  \
   ),
-
-  [_FN1] = KC_KEYMAP(
-  //,----+----+----+----.
-     ESC , P7 , P8 , P9 ,
-  //|----+----+----+----|
-     TAB , P4 , P5 , P6 ,
-  //|----+----+----+----|
-     ENT , P1 , P2 , P3 ,
-  //|----+----+----+----|
-         , P0 , P0 ,DOT 
-  //`----+----+----+----'
+  [_FN1] = LAYOUT_ortho_4x4(
+    KC_ESC,   KC_P7,    KC_P8,    KC_P9,   \
+    KC_TAB,   KC_P4,    KC_P5,    KC_P6,   \
+    KC_ENT,   KC_P1,    KC_P2,    KC_P3,   \
+    _______,  KC_P0,    KC_P0,    KC_DOT   \
   ),
-
-  [_FN2] = KC_KEYMAP(
-  //,----+----+----+----.
-     RTOG,RHUI,RSAI,RVAI,
-  //|----+----+----+----|
-     RMOD,RHUD,RSAD,RVAD,
-  //|----+----+----+----|
-         ,    ,    ,RST ,
-  //|----+----+----+----|
-     BSTP,    ,    ,    
-  //`----+----+----+----'
+  [_FN2] = LAYOUT_ortho_4x4(
+    RGB_TOG,  RGB_HUI,  RGB_SAI,  RGB_VAI, \
+    RGB_MOD,  RGB_HUD,  RGB_SAD,  RGB_VAD, \
+    _______,  _______,  _______,  RESET,  \
+    BL_STEP,  _______,  _______,  _______  \
   )
 
 };

keyboards/chocopad/rules.mk

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

keyboards/christmas_tree/christmas_tree.h

@@ -3,7 +3,7 @@
 #include "quantum.h"
 
 
-#define KEYMAP( \
+#define LAYOUT( \
 	k00, k01, k02, k03, k04, k05 \
 ) \
 { \

keyboards/christmas_tree/info.json

@@ -1,13 +1,14 @@
 {
-    "keyboard_name": "Christmas Tree",
-    "keyboard_folder": "christmas_tree",
-    "url": "https://www.reddit.com/r/MechanicalKeyboards/comments/7cqxpf/gb_christmas_tree_pcb_gb_now_live/",
-    "maintainer": "That-Canadian",
-    "width": 3,
-    "height": 3,
-    "layouts": {
-        "2017": {
-            "key_count": 6
-        }
+  "keyboard_name": "Christmas Tree",
+  "keyboard_folder": "christmas_tree",
+  "url": "https://www.reddit.com/r/MechanicalKeyboards/comments/7cqxpf/gb_christmas_tree_pcb_gb_now_live/",
+  "maintainer": "That-Canadian",
+  "width": 3,
+  "height": 3,
+  "layouts": {
+    "LAYOUT": {
+      "key_count": 6,
+      "layout": [{"x":1, "y":0}, {"x":0.5, "y":1}, {"x":1.5, "y":1}, {"x":0, "y":2}, {"x":1, "y":2}, {"x":2, "y":2}]
     }
+  }
 }

keyboards/christmas_tree/keymaps/default/keymap.c

@@ -14,7 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "christmas_tree.h"
+#include QMK_KEYBOARD_H
 
 extern keymap_config_t keymap_config;
 
@@ -32,27 +32,35 @@ enum custom_keycodes {
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
-/* Base
- *         ,------.
- *         |   1  |
- *     ,------+------.
- *     |   2  |   3  |
- * ,------+------+------.
- * |   4  | FUNC |   6  |
- * `--------------------'
- */
-[_BASE] = KEYMAP(KC_1, KC_2, KC_3, KC_4, MO(_FUNC), KC_6),
+  /* Base
+   *         ,------.
+   *         |   1  |
+   *     ,------+------.
+   *     |   2  |   3  |
+   * ,------+------+------.
+   * |   4  | FUNC |   6  |
+   * `--------------------'
+   */
+  [_BASE] = LAYOUT(
+            KC_1,
+         KC_2, KC_3,
+    KC_4, MO(_FUNC), KC_6
+  ),
 
-/* Func
- *         ,------.
- *         |BCKLIT|
- *     ,------+------.
- *     |   8  |   9  |
- * ,------+------+------.
- * |   0  | FUNC | RESET|
- * `--------------------'
- */
-[_FUNC] = KEYMAP(BACKLIT, KC_8, KC_9, KC_0, _______, RESET)
+  /* Func
+   *         ,------.
+   *         |BCKLIT|
+   *     ,------+------.
+   *     |   8  |   9  |
+   * ,------+------+------.
+   * |   0  | FUNC | RESET|
+   * `--------------------'
+   */
+  [_FUNC] = LAYOUT(
+            BACKLIT,
+         KC_8, KC_9,
+    KC_0, _______, RESET
+  )
 
 
 };

keyboards/clueboard/2x1800/2x1800.h

@@ -44,7 +44,7 @@
     { kb0, kb1, kb2, kb3, kb4, kb5, kb6, kb7, kb8, kb9, KC_NO } \
 }
 
-#define LAYOUT_4U_SPACE( \
+#define LAYOUT_4u_space( \
       k00, k01, k02, k03,    k04,   k06, k07, k08, k09,   k0a, k60, k61, k62,   k63, k64, k65, k66,    k67, k68, k69, k6a, \
       k10, k11, k12, k13,   k14, k15, k16, k17, k18, k19, k1a, k70, k71, k72, k73, k74, k75,    k76,   k77, k78, k79, k7a, \
       k20, k21, k22, k23,    k24,  k25, k26, k27, k28, k29, k2a, k80, k81, k82, k83, k84, k85,   k86,  k87, k88, k89, k8a, \
@@ -67,7 +67,7 @@
     { kb0, KC_NO, kb2, kb3, kb4, kb5, kb6, kb7, kb8, kb9, KC_NO } \
 }
 
-#define LAYOUT_7U_SPACE( \
+#define LAYOUT_7u_space( \
       k00, k01, k02, k03,    k04,   k06, k07, k08, k09,   k0a, k60, k61, k62,   k63, k64, k65, k66,    k67, k68, k69, k6a, \
       k10, k11, k12, k13,   k14, k15, k16, k17, k18, k19, k1a, k70, k71, k72, k73, k74, k75,    k76,   k77, k78, k79, k7a, \
       k20, k21, k22, k23,    k24,  k25, k26, k27, k28, k29, k2a, k80, k81, k82, k83, k84, k85,   k86,  k87, k88, k89, k8a, \

keyboards/clueboard/2x1800/keymaps/default/keymap.c

@@ -13,7 +13,7 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include "2x1800.h"
+#include QMK_KEYBOARD_H
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 [0] = LAYOUT(

keyboards/clueboard/2x1800/keymaps/default_4u/keymap.c

@@ -13,10 +13,10 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include "2x1800.h"
+#include QMK_KEYBOARD_H
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-[0] = LAYOUT_4U_SPACE(
+[0] = LAYOUT_4u_space(
       KC_HOME, KC_END,  KC_PGUP, KC_PGDN,       KC_ESC,    KC_F1,   KC_F2,   KC_F3,   KC_F4,     KC_F5,   KC_F6,   KC_F7,   KC_F8,     KC_F9,   KC_F10,   KC_F11,  KC_F12,        KC_PSCR, KC_SLCK, KC_PAUS, KC_INS,  \
                                                                                                                                                                                                                       \
       KC_PMNS, KC_NLCK, KC_PSLS, KC_PAST,      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_NLCK, KC_PSLS, KC_PAST, KC_PMNS, \

keyboards/clueboard/2x1800/keymaps/default_7u/keymap.c

@@ -13,10 +13,10 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include "2x1800.h"
+#include QMK_KEYBOARD_H
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-[0] = LAYOUT_7U_SPACE(
+[0] = LAYOUT_7u_space(
       KC_HOME, KC_END,  KC_PGUP, KC_PGDN,       KC_ESC,    KC_F1,   KC_F2,   KC_F3,   KC_F4,     KC_F5,   KC_F6,   KC_F7,   KC_F8,     KC_F9,   KC_F10,   KC_F11,  KC_F12,        KC_PSCR, KC_SLCK, KC_PAUS, KC_DEL,  \
                                                                                                                                                                                                                       \
       KC_PMNS, KC_NLCK, KC_PSLS, KC_PAST,      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_NLCK, KC_PSLS, KC_PAST, KC_PMNS, \

keyboards/clueboard/2x1800/keymaps/macroboard/keymap.c

@@ -13,7 +13,7 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include "2x1800.h"
+#include QMK_KEYBOARD_H
 
 enum custom_keycodes {
     MACRO01 = SAFE_RANGE,

keyboards/clueboard/2x1800/keymaps/mouseboard_left/keymap.c

@@ -13,7 +13,7 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include "2x1800.h"
+#include QMK_KEYBOARD_H
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 [0] = LAYOUT(

keyboards/clueboard/2x1800/keymaps/mouseboard_right/keymap.c

@@ -13,7 +13,7 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include "2x1800.h"
+#include QMK_KEYBOARD_H
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 [0] = LAYOUT(

keyboards/clueboard/2x1800/readme.md

@@ -2,9 +2,9 @@
 
 Clueboard Double 1800 All The Way
 
-* Keyboard Maintainer: [Zach White](https://github.com/skullydazed)
-* Hardware Supported: Clueboard 2x1800 PCB
-* Hardware Availability: 2018 Apr 1 Group Buy
+Keyboard Maintainer: [Zach White](https://github.com/skullydazed)  
+Hardware Supported: Clueboard 2x1800 PCB  
+Hardware Availability: 2018 Apr 1 Group Buy
 
 Make example for this keyboard (after setting up your build environment):
 

keyboards/clueboard/66/keymaps/xyverz/config.h

@@ -0,0 +1,3 @@
+#include "../config.h"
+
+#define TAPPING_TERM 600 // ms	

keyboards/cod67/cod67.c

@@ -0,0 +1,43 @@
+/* Copyright 2018 MechMerlin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * 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 "cod67.h"
+
+void matrix_init_kb(void) {
+	// put your keyboard start-up code here
+	// runs once when the firmware starts up
+
+	matrix_init_user();
+}
+
+void matrix_scan_kb(void) {
+	// put your looping keyboard code here
+	// runs every cycle (a lot)
+
+	matrix_scan_user();
+}
+
+bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
+	// put your per-action keyboard code here
+	// runs for every action, just before processing by the firmware
+
+	return process_record_user(keycode, record);
+}
+
+void led_set_kb(uint8_t usb_led) {
+	// put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
+
+	led_set_user(usb_led);
+}

keyboards/cod67/cod67.h

@@ -0,0 +1,36 @@
+/* Copyright 2018 MechMerlin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef COD67_H
+#define COD67_H
+
+#include "quantum.h"
+
+#define LAYOUT( \
+  K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, \
+  K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, \
+  K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D, \
+  K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K3D, \
+  K40, K41, K42, K43, K44, K45, K46, K47, K48, K49, K4A, K4B, K4C, K4D \
+) \
+{ \
+    { K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D }, \
+    { K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D }, \
+    { K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D }, \
+    { K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K3D }, \
+    { K40, K41, K42, K43, K44, K45, K46, K47, K48, K49, K4A, K4B, K4C, K4D }, \
+}
+
+#endif

keyboards/cod67/config.h

@@ -0,0 +1,189 @@
+/*
+Copyright 2018 MechMerlin
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x0000
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    Gray
+#define PRODUCT         cod67
+#define DESCRIPTION     60% Custom Keyboard
+
+/* key matrix size */
+#define MATRIX_ROWS 5
+#define MATRIX_COLS 14
+
+/*
+ * Keyboard Matrix Assignments
+ *
+ * Change this to how you wired your keyboard
+ * COLS: AVR pins used for columns, left to right
+ * ROWS: AVR pins used for rows, top to bottom
+ * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode)
+ *                  ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
+ *
+*/
+#define MATRIX_ROW_PINS { C7, C6, B6, B5, B4 }
+#define MATRIX_COL_PINS { D7, F7, F6, F5, F4, F1, F0, E6, B0, B7, D0, D1, D2, D3 }
+#define UNUSED_PINS
+
+/* COL2ROW, ROW2COL, or CUSTOM_MATRIX */
+#define DIODE_DIRECTION COL2ROW
+
+#define BACKLIGHT_PIN D4
+#define BACKLIGHT_LEVELS 3
+
+
+/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
+#define DEBOUNCING_DELAY 5
+
+/* define if matrix has ghost (lacks anti-ghosting diodes) */
+//#define MATRIX_HAS_GHOST
+
+/* number of backlight levels */
+
+/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
+#define LOCKING_SUPPORT_ENABLE
+/* Locking resynchronize hack */
+#define LOCKING_RESYNC_ENABLE
+
+/* If defined, GRAVE_ESC will always act as ESC when CTRL is held.
+ * This is userful for the Windows task manager shortcut (ctrl+shift+esc).
+ */
+// #define GRAVE_ESC_CTRL_OVERRIDE
+
+/*
+ * Force NKRO
+ *
+ * Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved
+ * state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the
+ * makefile for this to work.)
+ *
+ * If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N)
+ * until the next keyboard reset.
+ *
+ * NKRO may prevent your keystrokes from being detected in the BIOS, but it is
+ * fully operational during normal computer usage.
+ *
+ * For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N)
+ * or via bootmagic (hold SPACE+N while plugging in the keyboard). Once set by
+ * bootmagic, NKRO mode will always be enabled until it is toggled again during a
+ * power-up.
+ *
+ */
+//#define FORCE_NKRO
+
+/*
+ * Magic Key Options
+ *
+ * Magic keys are hotkey commands that allow control over firmware functions of
+ * the keyboard. They are best used in combination with the HID Listen program,
+ * found here: https://www.pjrc.com/teensy/hid_listen.html
+ *
+ * The options below allow the magic key functionality to be changed. This is
+ * useful if your keyboard/keypad is missing keys and you want magic key support.
+ *
+ */
+
+/* key combination for magic key command */
+#define IS_COMMAND() ( \
+    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
+)
+
+/* control how magic key switches layers */
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS  true
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS  true
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM false
+
+/* override magic key keymap */
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM
+//#define MAGIC_KEY_HELP1          H
+//#define MAGIC_KEY_HELP2          SLASH
+//#define MAGIC_KEY_DEBUG          D
+//#define MAGIC_KEY_DEBUG_MATRIX   X
+//#define MAGIC_KEY_DEBUG_KBD      K
+//#define MAGIC_KEY_DEBUG_MOUSE    M
+//#define MAGIC_KEY_VERSION        V
+//#define MAGIC_KEY_STATUS         S
+//#define MAGIC_KEY_CONSOLE        C
+//#define MAGIC_KEY_LAYER0_ALT1    ESC
+//#define MAGIC_KEY_LAYER0_ALT2    GRAVE
+//#define MAGIC_KEY_LAYER0         0
+//#define MAGIC_KEY_LAYER1         1
+//#define MAGIC_KEY_LAYER2         2
+//#define MAGIC_KEY_LAYER3         3
+//#define MAGIC_KEY_LAYER4         4
+//#define MAGIC_KEY_LAYER5         5
+//#define MAGIC_KEY_LAYER6         6
+//#define MAGIC_KEY_LAYER7         7
+//#define MAGIC_KEY_LAYER8         8
+//#define MAGIC_KEY_LAYER9         9
+//#define MAGIC_KEY_BOOTLOADER     PAUSE
+//#define MAGIC_KEY_LOCK           CAPS
+//#define MAGIC_KEY_EEPROM         E
+//#define MAGIC_KEY_NKRO           N
+//#define MAGIC_KEY_SLEEP_LED      Z
+
+/*
+ * Feature disable options
+ *  These options are also useful to firmware size reduction.
+ */
+
+/* disable debug print */
+//#define NO_DEBUG
+
+/* disable print */
+//#define NO_PRINT
+
+/* disable action features */
+//#define NO_ACTION_LAYER
+//#define NO_ACTION_TAPPING
+//#define NO_ACTION_ONESHOT
+//#define NO_ACTION_MACRO
+//#define NO_ACTION_FUNCTION
+
+/*
+ * MIDI options
+ */
+
+/* Prevent use of disabled MIDI features in the keymap */
+//#define MIDI_ENABLE_STRICT 1
+
+/* enable basic MIDI features:
+   - MIDI notes can be sent when in Music mode is on
+*/
+//#define MIDI_BASIC
+
+/* enable advanced MIDI features:
+   - MIDI notes can be added to the keymap
+   - Octave shift and transpose
+   - Virtual sustain, portamento, and modulation wheel
+   - etc.
+*/
+//#define MIDI_ADVANCED
+
+/* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
+//#define MIDI_TONE_KEYCODE_OCTAVES 1
+
+#endif

keyboards/cod67/info.json

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

keyboards/cod67/keymaps/default/keymap.c

@@ -0,0 +1,63 @@
+/* Copyright 2018 MechMerlin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+	LAYOUT(
+		KC_GESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC,
+		KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS)
+
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+  // MACRODOWN only works in this function
+      switch(id) {
+        case 0:
+          if (record->event.pressed) {
+            register_code(KC_RSFT);
+          } else {
+            unregister_code(KC_RSFT);
+          }
+        break;
+      }
+    return MACRO_NONE;
+};
+
+
+void matrix_init_user(void) {
+
+}
+
+void matrix_scan_user(void) {
+
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  return true;
+}
+
+void led_set_user(uint8_t usb_led) {
+
+}

keyboards/cod67/keymaps/default/readme.md

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

keyboards/cod67/readme.md

@@ -0,0 +1,32 @@
+# Gray COD67
+
+![cod67](imgur.com image replace me!)
+
+The Gray COD67 is a 60% keyboard with a modern and bold design. It features 20 RGB Underglow LED lights and a unique diffuser placement. The COD67 has the most stunning RGB light strip for a custom mechanical keyboard. It also features a center mounted USB C port. 
+
+There were only 75 units made worldwide. 
+
+Keyboard Maintainer: [MechMerlin](https://github.com/mechmerlin)  
+Hardware Supported: Gray COD67 
+Hardware Availability: [Zfrontier](https://en.zfrontier.com/products/cod67)  
+
+At this time, flashing ONLY works on Windows systems. 
+
+To put in bootloader mode, hold the `Esc` key while plugging in the USB cable. 
+
+The COD67 will show up as a drive. 
+
+Make example for this keyboard (after setting up your build environment):
+
+    make cod67:default:bin
+
+See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
+
+Rename the resulting `.bin` file to `cod67.bin`.
+
+Drag and drop `cod67.bin` to the drive, overwriting the previous `cod67.bin` stored on it. 
+
+Press the `Esc` key again to reset the board. You are now ready to type!
+
+## Notes
+The backlight pin is attached to a non PWM pin `D4` so backlight is only on/off. 

keyboards/cod67/rules.mk

@@ -0,0 +1,68 @@
+# MCU name
+#MCU = at90usb1286
+MCU = atmega32u4
+
+# Processor frequency.
+#     This will define a symbol, F_CPU, in all source code files equal to the
+#     processor frequency in Hz. You can then use this symbol in your source code to
+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#     automatically to create a 32-bit value in your source code.
+#
+#     This will be an integer division of F_USB below, as it is sourced by
+#     F_USB after it has run through any CPU prescalers. Note that this value
+#     does not *change* the processor frequency - it should merely be updated to
+#     reflect the processor speed set externally so that the code can use accurate
+#     software delays.
+F_CPU = 16000000
+
+
+#
+# LUFA specific
+#
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+# Input clock frequency.
+#     This will define a symbol, F_USB, in all source code files equal to the
+#     input clock frequency (before any prescaling is performed) in Hz. This value may
+#     differ from F_CPU if prescaling is used on the latter, and is required as the
+#     raw input clock is fed directly to the PLL sections of the AVR for high speed
+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
+#     at the end, this will be done automatically to create a 32-bit value in your
+#     source code.
+#
+#     If no clock division is performed on the input clock inside the AVR (via the
+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
+F_USB = $(F_CPU)
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+
+# 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 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 = no            # USB Nkey Rollover
+BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality on B7 by default
+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

keyboards/comet46/comet46.c

@@ -0,0 +1,30 @@
+#include "comet46.h"
+
+void uart_init(void) {
+	SERIAL_UART_INIT();
+}
+
+void led_init(void) {
+	DDRD  |= (1<<1);
+	PORTD |= (1<<1);
+	DDRF  |= (1<<4) | (1<<5);
+	PORTF |= (1<<4) | (1<<5);
+}
+
+void matrix_init_kb(void) {
+	// put your keyboard start-up code here
+	// runs once when the firmware starts up
+	matrix_init_user();
+	uart_init();
+	led_init();
+}
+
+void matrix_scan_kb(void) {
+	// put your looping keyboard code here
+	// runs every cycle (a lot)
+	matrix_scan_user();
+}
+
+void led_set_kb(uint8_t usb_led) {
+
+}

keyboards/comet46/comet46.h

@@ -0,0 +1,79 @@
+#ifndef COMET46_H
+#define COMET46_H
+
+#include "quantum.h"
+#include "matrix.h"
+#include "backlight.h"
+#include <stddef.h>
+
+#define red_led_off   PORTF |= (1<<5)
+#define red_led_on    PORTF &= ~(1<<5)
+#define blu_led_off   PORTF |= (1<<4)
+#define blu_led_on    PORTF &= ~(1<<4)
+#define grn_led_off   PORTD |= (1<<1)
+#define grn_led_on    PORTD &= ~(1<<1)
+
+#define set_led_off     red_led_off; grn_led_off; blu_led_off
+#define set_led_red     red_led_on;  grn_led_off; blu_led_off
+#define set_led_blue    red_led_off; grn_led_off; blu_led_on
+#define set_led_green   red_led_off; grn_led_on;  blu_led_off
+#define set_led_yellow  red_led_on;  grn_led_on;  blu_led_off
+#define set_led_magenta red_led_on;  grn_led_off; blu_led_on
+#define set_led_cyan    red_led_off; grn_led_on;  blu_led_on
+#define set_led_white   red_led_on;  grn_led_on;  blu_led_on
+
+/*
+#define LED_B 5
+#define LED_R 6
+#define LED_G 7
+
+#define all_leds_off PORTF &= ~(1<<LED_B) & ~(1<<LED_R) & ~(1<<LED_G)
+
+#define red_led_on   PORTF |= (1<<LED_R)
+#define red_led_off  PORTF &= ~(1<<LED_R)
+#define grn_led_on   PORTF |= (1<<LED_G)
+#define grn_led_off  PORTF &= ~(1<<LED_G)
+#define blu_led_on   PORTF |= (1<<LED_B)
+#define blu_led_off  PORTF &= ~(1<<LED_B)
+
+#define set_led_off     PORTF &= ~(1<<LED_B) & ~(1<<LED_R) & ~(1<<LED_G)
+#define set_led_red     PORTF = PORTF & ~(1<<LED_B) & ~(1<<LED_G) | (1<<LED_R)
+#define set_led_blue    PORTF = PORTF & ~(1<<LED_G) & ~(1<<LED_R) | (1<<LED_B)
+#define set_led_green   PORTF = PORTF & ~(1<<LED_B) & ~(1<<LED_R) | (1<<LED_G)
+#define set_led_yellow  PORTF = PORTF & ~(1<<LED_B) | (1<<LED_R) | (1<<LED_G)
+#define set_led_magenta PORTF = PORTF & ~(1<<LED_G) | (1<<LED_R) | (1<<LED_B)
+#define set_led_cyan    PORTF = PORTF & ~(1<<LED_R) | (1<<LED_B) | (1<<LED_G)
+#define set_led_white   PORTF |= (1<<LED_B) | (1<<LED_R) | (1<<LED_G)
+*/
+
+// This a shortcut to help you visually see your layout.
+// The first section contains all of the arguements
+// The second converts the arguments into a two-dimensional array
+#define LAYOUT_kc( \
+  k00, k01, k02, k03, k04, k05,                k06, k07, k08, k09, k10, k11,\
+  k12, k13, k14, k15, k16, k17, k18,      k19, k20, k21, k22, k23, k24, k25,\
+  k26, k27, k28, k29, k31, k32, k33,      k34, k35, k36, k37, k38, k41, k42,\
+                      k43, k44, k45,      k46, k47, k48     \
+) \
+{ \
+	{ KC_##k13, KC_##k01, KC_##k26, KC_##k12, KC_##k00,      KC_##k11, KC_##k25, KC_##k42, KC_##k10, KC_##k24}, \
+	{ KC_##k03, KC_##k28, KC_##k14, KC_##k02, KC_##k27,      KC_##k41, KC_##k09, KC_##k23, KC_##k38, KC_##k08}, \
+	{ KC_##k31, KC_##k16, KC_##k04, KC_##k29, KC_##k15,      KC_##k22, KC_##k37, KC_##k07, KC_##k21, KC_##k36}, \
+	{ KC_NO,    KC_##k32, KC_##k17, KC_##k05, KC_##k43,      KC_##k48, KC_##k06, KC_##k20, KC_##k35, KC_NO   },  \
+	{ KC_NO,    KC_##k45, KC_##k33, KC_##k18, KC_##k44,      KC_##k47, KC_##k19, KC_##k34, KC_##k46, KC_NO   }, \
+}
+
+#define LAYOUT( \
+  k00, k01, k02, k03, k04, k05,                k06, k07, k08, k09, k10, k11,\
+  k12, k13, k14, k15, k16, k17, k18,      k19, k20, k21, k22, k23, k24, k25,\
+  k26, k27, k28, k29, k31, k32, k33,      k34, k35, k36, k37, k38, k41, k42,\
+                      k43, k44, k45,      k46, k47, k48     \
+) \
+{ \
+	{ k13,   k01, k26, k12, k00,      k11, k25, k42, k10, k24}, \
+	{ k03,   k28, k14, k02, k27,      k41, k09, k23, k38, k08}, \
+	{ k31,   k16, k04, k29, k15,      k22, k37, k07, k21, k36}, \
+	{ KC_NO, k32, k17, k05, k43,      k48, k06, k20, k35, KC_NO },  \
+	{ KC_NO, k45, k33, k18, k44,      k47, k19, k34, k46, KC_NO }, \
+}
+#endif

keyboards/comet46/config.h

@@ -0,0 +1,87 @@
+/*
+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/>.
+*/
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x6060
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    SatT
+#define PRODUCT         Comet46
+#define DESCRIPTION     qmk keyboard firmware for Comet46
+
+/* key matrix size */
+#define MATRIX_ROWS 5
+#define MATRIX_COLS 10
+
+/* define if matrix has ghost */
+//#define MATRIX_HAS_GHOST
+
+/* number of backlight levels */
+//#define BACKLIGHT_LEVELS 3
+
+#define ONESHOT_TIMEOUT 500
+
+
+/* key combination for command */
+#define IS_COMMAND() ( \
+    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
+)
+
+/*
+ * Feature disable options
+ *  These options are also useful to firmware size reduction.
+ */
+
+#define PREVENT_STUCK_MODIFIERS
+
+/* 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
+
+//UART settings for communication with the RF microcontroller
+#define SERIAL_UART_BAUD 1000000
+#define SERIAL_UART_DATA UDR1
+#define SERIAL_UART_UBRR (F_CPU / (16UL * SERIAL_UART_BAUD) - 1)
+#define SERIAL_UART_TXD_READY (UCSR1A & _BV(UDRE1))
+#define SERIAL_UART_RXD_PRESENT (UCSR1A & _BV(RXC1))
+#define SERIAL_UART_INIT() do { \
+    	/* baud rate */ \
+    	UBRR1L = SERIAL_UART_UBRR; \
+    	/* baud rate */ \
+    	UBRR1H = SERIAL_UART_UBRR >> 8; \
+    	/* enable TX and RX */ \
+    	UCSR1B = _BV(TXEN1) | _BV(RXEN1); \
+    	/* 8-bit data */ \
+    	UCSR1C = _BV(UCSZ11) | _BV(UCSZ10); \
+  	} while(0)
+
+#endif

keyboards/comet46/keymaps/default/keymap.c

@@ -0,0 +1,103 @@
+// this is the style you want to emulate.
+// This is the canonical layout file for the Quantum project. If you want to add another keyboard,
+
+#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 comet46_layers
+{
+    _QWERTY,
+    _LOWER,
+    _RAISE,
+};
+
+enum custom_keycodes {
+  QWERTY = SAFE_RANGE,
+  LOWER,
+  RAISE,
+};
+
+// Fillers to make layering more clear
+#define _______ KC_TRNS
+#define XXXXXXX KC_NO
+#define LOWER MO(_LOWER)
+#define RAISE MO(_RAISE)
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+  /* Qwerty
+   * ,-----------------------------------------+                    +-----------------------------------------.
+   * | Tab  |   Q  |   W  |   E  |   R  |   T  |                    |   Y  |   U  |   I  |   O  |   P  | Bksp |
+   * |------+------+------+------+------+------+------+      +------+------+------+------+------+------+------|
+   * | Ctl  |   A  |   S  |   D  |   F  |   G  | Esc  |      | Del  |   H  |   J  |   K  |   L  |   ;  |   "  |
+   * |------+------+------+------+------+------+------+      +------+------+------+------+------+------+------|
+   * | Shift|   Z  |   X  |   C  |   V  |   B  |   {  |      |   }  |   N  |   M  |   ,  |   .  |   /  | Shift|
+   * |------+------+------+------+------+------+------+      +------+------+------+------+------+-------------|
+   *                             | GUI  | Lower| Space|      | Enter| Raise| Alt  |
+   *                             +--------------------/      \--------------------+
+   */
+  [_QWERTY] = LAYOUT(
+    KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,                             KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_BSPC,
+    KC_LCTL, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_ESC,         KC_DEL,  KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT,
+    KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_LCBR,        KC_RCBR, KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,
+                                        KC_LGUI, LOWER,   KC_SPC,         KC_ENT,  RAISE,   KC_LALT
+  ),
+
+  /* Lower
+   * ,-----------------------------------------+                    +-----------------------------------------.
+   * |      |   !  |   @  |   #  |   $  |   %  |                    |   ^  |   &  |   *  |   (  |   )  |      |
+   * |------+------+------+------+------+------+------+      +------+------+------+------+------+------+------|
+   * |      |      |      |      |      |      |      |      |   `  |   \  |   -  |   =  |   [  |   ]  |      |
+   * |------+------+------+------+------+------+------+      +------+------+------+------+------+------+------|
+   * |      |      |      |      |      |      |      |      |   ~  |   |  |   _  |   +  |   {  |   }  |      |
+   * |------+------+------+------+------+------+------+      +------+------+------+------+------+-------------|
+   *                             |      |      |      |      |      |      |      |
+   *                             +--------------------/      \--------------------+
+   */
+  [_LOWER] = LAYOUT(
+    _______, KC_EXLM, KC_AT,   KC_HASH, KC_DLR,  KC_PERC,                          KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, _______,
+    _______, _______, _______, _______, _______, _______, _______,        KC_GRV,  KC_BSLS, KC_MINS, KC_EQL,  KC_LBRC, KC_RBRC, _______,
+    _______, _______, _______, _______, _______, _______, _______,        KC_TILD, KC_PIPE, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, _______,
+                                        _______, _______, _______,        _______, _______, _______
+  ),
+
+  /* Raise
+   * ,-----------------------------------------+                    +-----------------------------------------.
+   * |      |   1  |   2  |   3  |   4  |   5  |                    |      |      |      |      |      |      |
+   * |------+------+------+------+------+------+------+      +------+------+------+------+------+------+------|
+   * |      |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |      |      | Left | Down |  Up  |Right | End  |      |
+   * |------+------+------+------+------+------+------+      +------+------+------+------+------+------+------|
+   * |      |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 |      | Home |      |      |      |      |      |      |
+   * |------+------+------+------+------+------+------+      +------+------+------+------+------+-------------|
+   *                             |      |      |      |      |      |      |      |
+   *                             +--------------------/      \--------------------+
+   */
+  [_RAISE] = LAYOUT(
+    _______, KC_1,    KC_2,    KC_3,    KC_4,    KC_5,                             KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    _______,
+    _______, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,          XXXXXXX, KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT, KC_END,  _______,
+    _______, KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,         KC_HOME, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______,
+                                        _______, _______, _______,        _______, _______, _______
+  )
+};
+
+
+void matrix_scan_user(void) {
+    uint8_t layer = biton32(layer_state);
+    switch (layer) {
+    	case _QWERTY:
+    	    set_led_green;
+    	    break;
+        case _RAISE:
+            set_led_blue;
+            break;
+        case _LOWER:
+            set_led_red;
+            break;
+        default:
+            set_led_green;
+            break;
+    }
+}

keyboards/comet46/keymaps/satt/action_pseudo_lut.c

@@ -0,0 +1,142 @@
+#include "quantum.h"
+#include "action_pseudo_lut.h"
+
+static uint8_t send_key_shift_bit[SHIFT_BIT_SIZE];
+
+/*
+ * Pseudo layout action.
+ * This action converts a keycode in order to output the character according to the keymap you specified
+ * still your keyboard layout recognized wrongly on your OS.
+ * Memo: Using other layer keymap to get keycode
+ */
+void action_pseudo_lut(keyrecord_t *record, uint8_t base_keymap_id, const uint16_t (*keymap)[2]) {
+    uint8_t prev_shift;
+    uint16_t keycode;
+    uint16_t pseudo_keycode;
+
+    /* get keycode from keymap you specified */
+    keycode = keymap_key_to_keycode(base_keymap_id, record->event.key);
+
+    prev_shift = keyboard_report->mods & (MOD_BIT(KC_LSFT) | MOD_BIT(KC_RSFT));
+
+    if (record->event.pressed) {
+        /* when magic commands entered, keycode does not converted */
+        if (IS_COMMAND()) {
+            if (prev_shift) {
+                add_shift_bit(keycode);
+            }
+            register_code(keycode);
+            return;
+        }
+
+        if (prev_shift) {
+            pseudo_keycode = convert_keycode(keymap, keycode, true);
+            dprintf("pressed: %02X, converted: %04X\n", keycode, pseudo_keycode);
+            add_shift_bit(keycode);
+
+            if (IS_LSFT(pseudo_keycode)) {
+                register_code(QK_LSFT ^ pseudo_keycode);
+            } else {
+                /* delete shift mod temporarily */
+                del_mods(prev_shift);
+                send_keyboard_report();
+                register_code(pseudo_keycode);
+                add_mods(prev_shift);
+                send_keyboard_report();
+            }
+        } else {
+            pseudo_keycode = convert_keycode(keymap, keycode, false);
+            dprintf("pressed: %02X, converted: %04X\n", keycode, pseudo_keycode);
+
+            if (IS_LSFT(pseudo_keycode)) {
+                add_weak_mods(MOD_BIT(KC_LSFT));
+                send_keyboard_report();
+                register_code(QK_LSFT ^ pseudo_keycode);
+                /* on Windows, prevent key repeat to avoid unintended output */
+                unregister_code(QK_LSFT ^ pseudo_keycode);
+                del_weak_mods(MOD_BIT(KC_LSFT));
+                send_keyboard_report();
+            } else {
+                register_code(pseudo_keycode);
+            }
+        }
+    } else {
+        if (get_shift_bit(keycode)) {
+            del_shift_bit(keycode);
+            pseudo_keycode = convert_keycode(keymap, keycode, true);
+        } else {
+            pseudo_keycode = convert_keycode(keymap, keycode, false);
+        }
+        dprintf("released: %02X, converted: %04X\n", keycode, pseudo_keycode);
+
+        if (IS_LSFT(pseudo_keycode)) {
+            unregister_code(QK_LSFT ^ pseudo_keycode);
+        } else {
+            unregister_code(pseudo_keycode);
+        }
+    }
+}
+
+uint16_t convert_keycode(const uint16_t (*keymap)[2], uint16_t keycode, bool shift_modded)
+{
+    uint16_t pseudo_keycode;
+
+    switch (keycode) {
+        case KC_A ... KC_CAPSLOCK:
+#if defined(__AVR__)
+            if (shift_modded) {
+                pseudo_keycode = pgm_read_word(&keymap[keycode][1]);
+            } else {
+                pseudo_keycode = pgm_read_word(&keymap[keycode][0]);
+            }
+#else
+            if (shift_modded) {
+                pseudo_keycode = keymap[keycode][1];
+            } else {
+                pseudo_keycode = keymap[keycode][0];
+            }
+#endif
+            /* if undefined, use got keycode as it is */
+            if (pseudo_keycode == 0x00) {
+                if (shift_modded) {
+                    pseudo_keycode = S(keycode);
+                } else {
+                    pseudo_keycode = keycode;
+                }
+            }
+            break;
+        default:
+            if (shift_modded) {
+                pseudo_keycode = S(keycode);
+            } else {
+                pseudo_keycode = keycode;
+            }
+            break;
+    }
+    return pseudo_keycode;
+}
+
+uint8_t get_shift_bit(uint16_t keycode) {
+    if ((keycode >> 3) < SHIFT_BIT_SIZE) {
+        return send_key_shift_bit[keycode >> 3] & (1 << (keycode & 7));
+    } else {
+        dprintf("get_shift_bit: Can't get shift bit. keycode: %02X\n", keycode);
+        return 0;
+    }
+}
+
+void add_shift_bit(uint16_t keycode) {
+    if ((keycode >> 3) < SHIFT_BIT_SIZE) {
+        send_key_shift_bit[keycode >> 3] |= (1 << (keycode & 7));
+    } else {
+        dprintf("add_shift_bit: Can't add shift bit. keycode: %02X\n", keycode);
+    }
+}
+
+void del_shift_bit(uint16_t keycode) {
+    if ((keycode >> 3) < SHIFT_BIT_SIZE) {
+        send_key_shift_bit[keycode >> 3] &= ~(1 << (keycode & 7));
+    } else {
+        dprintf("del_shift_bit: Can't delete shift bit. keycode: %02X\n", keycode);
+    }
+}

keyboards/comet46/keymaps/satt/action_pseudo_lut.h

@@ -0,0 +1,15 @@
+#ifndef ACTION_PSEUDO_LUT_H
+#define ACTION_PSEUDO_LUT_H
+
+#define SHIFT_BIT_SIZE (0xE7 / 8 + 1) // 1bit per 1key
+
+#define IS_LSFT(kc) ((QK_LSFT & (kc)) == QK_LSFT)
+
+void action_pseudo_lut(keyrecord_t *, uint8_t, const uint16_t (*)[2]);
+uint16_t convert_keycode(const uint16_t (*)[2], uint16_t, bool);
+
+uint8_t get_shift_bit(uint16_t);
+void add_shift_bit(uint16_t);
+void del_shift_bit(uint16_t);
+
+#endif