Merge pull request #1269 from ryanmaclean/patch-6

Cleaning Up Dockerfile Layers Per Official Docs

Dockerfile

@@ -1,8 +1,7 @@
 FROM debian:jessie
 MAINTAINER Erik Dasque <[email protected]>
 
-RUN apt-get update
+RUN apt-get update && apt-get install --no-install-recommends -y build-essential \
-RUN apt-get install --no-install-recommends -y build-essential \
     gcc \
     unzip \
     wget \
@@ -15,10 +14,8 @@ RUN apt-get install --no-install-recommends -y build-essential \
     gcc-arm-none-eabi \
     binutils-arm-none-eabi \
     libnewlib-arm-none-eabi \
-    git
+    git \
-
+    && rm -rf /var/lib/apt/lists/*
-RUN apt-get clean
-RUN rm -rf /var/lib/apt/lists/*
 
 ENV keyboard=ergodox
 ENV subproject=ez

Makefile

@@ -21,6 +21,8 @@ override SILENT := false
 
 ON_ERROR := error_occurred=1
 
+BREAK_ON_ERRORS = no
+
 STARTING_MAKEFILE := $(firstword $(MAKEFILE_LIST))
 ROOT_MAKEFILE := $(lastword $(MAKEFILE_LIST))
 ROOT_DIR := $(dir $(ROOT_MAKEFILE))
@@ -462,20 +464,25 @@ endef
 
 include $(ROOT_DIR)/message.mk
 
+ifeq ($(strip $(BREAK_ON_ERRORS)), yes)
+HANDLE_ERROR = exit 1
+else
+HANDLE_ERROR = echo $$error_occurred > $(ERROR_FILE)
+endif
+
 # The empty line is important here, as it will force a new shell to be created for each command
 # Otherwise the command line will become too long with a lot of keyboards and keymaps
 define RUN_COMMAND
 +error_occurred=0;\
 $(COMMAND_$(SILENT_MODE)_$(COMMAND))\
-if [ $$error_occurred -gt 0 ]; then echo $$error_occurred > $(ERROR_FILE); fi;
+if [ $$error_occurred -gt 0 ]; then $(HANDLE_ERROR); fi;
 
 
 endef
 define RUN_TEST
 +error_occurred=0;\
 $($(TEST)_COMMAND)\
-if [ $$error_occurred -gt 0 ]; then echo $$error_occurred > $(ERROR_FILE); fi;
+if [ $$error_occurred -gt 0 ]; then $(HANDLE_ERROR); fi;
-
 endef
 
 # Allow specifying just the subproject, in the keyboard directory, which will compile all keymaps
@@ -527,14 +534,22 @@ test: test-all
 .PHONY: test-clean
 test-clean: test-all-clean
 
+ifdef SKIP_VERSION
+SKIP_GIT := yes
+endif
+
 # Generate the version.h file
 ifndef SKIP_GIT
     GIT_VERSION := $(shell git describe --abbrev=6 --dirty --always --tags 2>/dev/null || date +"%Y-%m-%d-%H:%M:%S")
 else
     GIT_VERSION := NA
 endif
+ifndef SKIP_VERSION
 BUILD_DATE := $(shell date +"%Y-%m-%d-%H:%M:%S")
 $(shell echo '#define QMK_VERSION "$(GIT_VERSION)"' > $(ROOT_DIR)/quantum/version.h)
 $(shell echo '#define QMK_BUILDDATE "$(BUILD_DATE)"' >> $(ROOT_DIR)/quantum/version.h)
+else
+BUILD_DATE := NA
+endif
 
 include $(ROOT_DIR)/testlist.mk

build_keyboard.mk

@@ -7,11 +7,11 @@ endif
 include common.mk
 
 ifneq ($(SUBPROJECT),)
-	TARGET ?= $(KEYBOARD)_$(SUBPROJECT)_$(KEYMAP)
+    TARGET ?= $(KEYBOARD)_$(SUBPROJECT)_$(KEYMAP)
-	KEYBOARD_OUTPUT := $(BUILD_DIR)/obj_$(KEYBOARD)_$(SUBPROJECT)
+    KEYBOARD_OUTPUT := $(BUILD_DIR)/obj_$(KEYBOARD)_$(SUBPROJECT)
 else
-	TARGET ?= $(KEYBOARD)_$(KEYMAP)
+    TARGET ?= $(KEYBOARD)_$(KEYMAP)
-	KEYBOARD_OUTPUT := $(BUILD_DIR)/obj_$(KEYBOARD)
+    KEYBOARD_OUTPUT := $(BUILD_DIR)/obj_$(KEYBOARD)
 endif
 
 # Force expansion
@@ -20,15 +20,15 @@ TARGET := $(TARGET)
 
 MASTER ?= left
 ifdef master
-	MASTER = $(master)
+    MASTER = $(master)
 endif
 
 ifeq ($(MASTER),right)
-	OPT_DEFS += -DMASTER_IS_ON_RIGHT
+    OPT_DEFS += -DMASTER_IS_ON_RIGHT
 else
-	ifneq ($(MASTER),left)
+    ifneq ($(MASTER),left)
 $(error MASTER does not have a valid value(left/right))
-	endif
+    endif
 endif
 
 
@@ -56,31 +56,31 @@ endif
 
 # We can assume a ChibiOS target When MCU_FAMILY is defined, since it's not used for LUFA
 ifdef MCU_FAMILY
-	PLATFORM=CHIBIOS
+    PLATFORM=CHIBIOS
 else
-	PLATFORM=AVR
+    PLATFORM=AVR
 endif
 
 ifeq ($(PLATFORM),CHIBIOS)
-	include $(TMK_PATH)/protocol/chibios.mk
+    include $(TMK_PATH)/protocol/chibios.mk
-	include $(TMK_PATH)/chibios.mk
+    include $(TMK_PATH)/chibios.mk
-	OPT_OS = chibios
+    OPT_OS = chibios
-	ifneq ("$(wildcard $(SUBPROJECT_PATH)/bootloader_defs.h)","")
+    ifneq ("$(wildcard $(SUBPROJECT_PATH)/bootloader_defs.h)","")
-		OPT_DEFS += -include $(SUBPROJECT_PATH)/bootloader_defs.h
+        OPT_DEFS += -include $(SUBPROJECT_PATH)/bootloader_defs.h
-	else ifneq ("$(wildcard $(SUBPROJECT_PATH)/boards/$(BOARD)/bootloader_defs.h)","")
+    else ifneq ("$(wildcard $(SUBPROJECT_PATH)/boards/$(BOARD)/bootloader_defs.h)","")
-		OPT_DEFS += -include $(SUBPROJECT_PATH)/boards/$(BOARD)/bootloader_defs.h
+        OPT_DEFS += -include $(SUBPROJECT_PATH)/boards/$(BOARD)/bootloader_defs.h
-	else ifneq ("$(wildcard $(KEYBOARD_PATH)/bootloader_defs.h)","")
+    else ifneq ("$(wildcard $(KEYBOARD_PATH)/bootloader_defs.h)","")
-		OPT_DEFS += -include $(KEYBOARD_PATH)/bootloader_defs.h
+        OPT_DEFS += -include $(KEYBOARD_PATH)/bootloader_defs.h
-	else ifneq ("$(wildcard $(KEYBOARD_PATH)/boards/$(BOARD)/bootloader_defs.h)","")
+    else ifneq ("$(wildcard $(KEYBOARD_PATH)/boards/$(BOARD)/bootloader_defs.h)","")
-		OPT_DEFS += -include $(KEYBOARD_PATH)/boards/$(BOARD)/bootloader_defs.h
+        OPT_DEFS += -include $(KEYBOARD_PATH)/boards/$(BOARD)/bootloader_defs.h
-	endif
+    endif
 endif
 
 CONFIG_H = $(KEYBOARD_PATH)/config.h
 ifneq ($(SUBPROJECT),)
-	ifneq ("$(wildcard $(SUBPROJECT_C))","")
+    ifneq ("$(wildcard $(SUBPROJECT_C))","")
-		CONFIG_H = $(SUBPROJECT_PATH)/config.h
+        CONFIG_H = $(SUBPROJECT_PATH)/config.h
-	endif
+    endif
 endif
 
 # Save the defines and includes here, so we don't include any keymap specific ones
@@ -112,30 +112,30 @@ KEYMAP_OUTPUT := $(BUILD_DIR)/obj_$(TARGET)
 
 
 ifneq ("$(wildcard $(KEYMAP_PATH)/config.h)","")
-	CONFIG_H = $(KEYMAP_PATH)/config.h
+    CONFIG_H = $(KEYMAP_PATH)/config.h
 endif
 
 # # project specific files
 SRC += $(KEYBOARD_C) \
-	$(KEYMAP_C) \
+    $(KEYMAP_C) \
-	$(QUANTUM_DIR)/quantum.c \
+    $(QUANTUM_DIR)/quantum.c \
-	$(QUANTUM_DIR)/keymap_common.c \
+    $(QUANTUM_DIR)/keymap_common.c \
-	$(QUANTUM_DIR)/keycode_config.c \
+    $(QUANTUM_DIR)/keycode_config.c \
-	$(QUANTUM_DIR)/process_keycode/process_leader.c
+    $(QUANTUM_DIR)/process_keycode/process_leader.c
 
 ifneq ($(SUBPROJECT),)
-	SRC += $(SUBPROJECT_C)
+    SRC += $(SUBPROJECT_C)
 endif
 
 ifndef CUSTOM_MATRIX
-	SRC += $(QUANTUM_DIR)/matrix.c
+    SRC += $(QUANTUM_DIR)/matrix.c
 endif
 
 ifeq ($(strip $(API_SYSEX_ENABLE)), yes)
-	OPT_DEFS += -DAPI_SYSEX_ENABLE
+    OPT_DEFS += -DAPI_SYSEX_ENABLE
-	SRC += $(QUANTUM_DIR)/api/api_sysex.c
+    SRC += $(QUANTUM_DIR)/api/api_sysex.c
-	OPT_DEFS += -DAPI_ENABLE
+    OPT_DEFS += -DAPI_ENABLE
-	SRC += $(QUANTUM_DIR)/api.c
+    SRC += $(QUANTUM_DIR)/api.c
     MIDI_ENABLE=yes
 endif
 
@@ -144,25 +144,25 @@ MUSIC_ENABLE := 0
 ifeq ($(strip $(AUDIO_ENABLE)), yes)
     OPT_DEFS += -DAUDIO_ENABLE
     MUSIC_ENABLE := 1
-	SRC += $(QUANTUM_DIR)/process_keycode/process_audio.c
+    SRC += $(QUANTUM_DIR)/process_keycode/process_audio.c
-	SRC += $(QUANTUM_DIR)/audio/audio.c
+    SRC += $(QUANTUM_DIR)/audio/audio.c
-	SRC += $(QUANTUM_DIR)/audio/voices.c
+    SRC += $(QUANTUM_DIR)/audio/voices.c
-	SRC += $(QUANTUM_DIR)/audio/luts.c
+    SRC += $(QUANTUM_DIR)/audio/luts.c
 endif
 
 ifeq ($(strip $(MIDI_ENABLE)), yes)
     OPT_DEFS += -DMIDI_ENABLE
-	MUSIC_ENABLE := 1
+    MUSIC_ENABLE := 1
-	SRC += $(QUANTUM_DIR)/process_keycode/process_midi.c
+    SRC += $(QUANTUM_DIR)/process_keycode/process_midi.c
 endif
 
 ifeq ($(MUSIC_ENABLE), 1)
-	SRC += $(QUANTUM_DIR)/process_keycode/process_music.c
+    SRC += $(QUANTUM_DIR)/process_keycode/process_music.c
 endif
 
 ifeq ($(strip $(COMBO_ENABLE)), yes)
     OPT_DEFS += -DCOMBO_ENABLE
-	SRC += $(QUANTUM_DIR)/process_keycode/process_combo.c
+    SRC += $(QUANTUM_DIR)/process_keycode/process_combo.c
 endif
 
 ifeq ($(strip $(VIRTSER_ENABLE)), yes)
@@ -171,65 +171,93 @@ endif
 
 ifeq ($(strip $(FAUXCLICKY_ENABLE)), yes)
     OPT_DEFS += -DFAUXCLICKY_ENABLE
-	SRC += $(QUANTUM_DIR)/fauxclicky.c
+    SRC += $(QUANTUM_DIR)/fauxclicky.c
 endif
 
 ifeq ($(strip $(UCIS_ENABLE)), yes)
-	OPT_DEFS += -DUCIS_ENABLE
+    OPT_DEFS += -DUCIS_ENABLE
-	SRC += $(QUANTUM_DIR)/process_keycode/process_unicode_common.c
+    UNICODE_COMMON = yes
-	SRC += $(QUANTUM_DIR)/process_keycode/process_ucis.c
+    SRC += $(QUANTUM_DIR)/process_keycode/process_ucis.c
 endif
 
 ifeq ($(strip $(UNICODEMAP_ENABLE)), yes)
-	OPT_DEFS += -DUNICODEMAP_ENABLE
+    OPT_DEFS += -DUNICODEMAP_ENABLE
-	SRC += $(QUANTUM_DIR)/process_keycode/process_unicode_common.c
+    UNICODE_COMMON = yes
-	SRC += $(QUANTUM_DIR)/process_keycode/process_unicodemap.c
+    SRC += $(QUANTUM_DIR)/process_keycode/process_unicodemap.c
 endif
 
 ifeq ($(strip $(UNICODE_ENABLE)), yes)
     OPT_DEFS += -DUNICODE_ENABLE
-	SRC += $(QUANTUM_DIR)/process_keycode/process_unicode_common.c
+    UNICODE_COMMON = yes
-	SRC += $(QUANTUM_DIR)/process_keycode/process_unicode.c
+    SRC += $(QUANTUM_DIR)/process_keycode/process_unicode.c
+endif
+
+ifeq ($(strip $(UNICODE_COMMON)), yes)
+    SRC += $(QUANTUM_DIR)/process_keycode/process_unicode_common.c
 endif
 
 ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
-	OPT_DEFS += -DRGBLIGHT_ENABLE
+    OPT_DEFS += -DRGBLIGHT_ENABLE
-	SRC += $(QUANTUM_DIR)/light_ws2812.c
+    SRC += $(QUANTUM_DIR)/light_ws2812.c
-	SRC += $(QUANTUM_DIR)/rgblight.c
+    SRC += $(QUANTUM_DIR)/rgblight.c
+    CIE1931_CURVE = yes
+    LED_BREATHING_TABLE = yes
 endif
 
 ifeq ($(strip $(TAP_DANCE_ENABLE)), yes)
-	OPT_DEFS += -DTAP_DANCE_ENABLE
+    OPT_DEFS += -DTAP_DANCE_ENABLE
-	SRC += $(QUANTUM_DIR)/process_keycode/process_tap_dance.c
+    SRC += $(QUANTUM_DIR)/process_keycode/process_tap_dance.c
 endif
 
 ifeq ($(strip $(PRINTING_ENABLE)), yes)
-	OPT_DEFS += -DPRINTING_ENABLE
+    OPT_DEFS += -DPRINTING_ENABLE
-	SRC += $(QUANTUM_DIR)/process_keycode/process_printer.c
+    SRC += $(QUANTUM_DIR)/process_keycode/process_printer.c
-	SRC += $(TMK_DIR)/protocol/serial_uart.c
+    SRC += $(TMK_DIR)/protocol/serial_uart.c
 endif
 
 ifeq ($(strip $(SERIAL_LINK_ENABLE)), yes)
-	SRC += $(patsubst $(QUANTUM_PATH)/%,%,$(SERIAL_SRC))
+    SRC += $(patsubst $(QUANTUM_PATH)/%,%,$(SERIAL_SRC))
-	OPT_DEFS += $(SERIAL_DEFS)
+    OPT_DEFS += $(SERIAL_DEFS)
-	VAPTH += $(SERIAL_PATH)
+    VAPTH += $(SERIAL_PATH)
 endif
 
 ifneq ($(strip $(VARIABLE_TRACE)),)
-	SRC += $(QUANTUM_DIR)/variable_trace.c
+    SRC += $(QUANTUM_DIR)/variable_trace.c
-	OPT_DEFS += -DNUM_TRACED_VARIABLES=$(strip $(VARIABLE_TRACE))
+    OPT_DEFS += -DNUM_TRACED_VARIABLES=$(strip $(VARIABLE_TRACE))
 ifneq ($(strip $(MAX_VARIABLE_TRACE_SIZE)),)
-	OPT_DEFS += -DMAX_VARIABLE_TRACE_SIZE=$(strip $(MAX_VARIABLE_TRACE_SIZE))
+    OPT_DEFS += -DMAX_VARIABLE_TRACE_SIZE=$(strip $(MAX_VARIABLE_TRACE_SIZE))
 endif
 endif
 
+ifeq ($(strip $(LCD_ENABLE)), yes)
+    CIE1931_CURVE = yes
+endif
+
+ifeq ($(strip $(LED_ENABLE)), yes)
+    CIE1931_CURVE = yes
+endif
+
+ifeq ($(strip $(CIE1931_CURVE)), yes)
+    OPT_DEFS += -DUSE_CIE1931_CURVE
+    LED_TABLES = yes
+endif
+
+ifeq ($(strip $(LED_BREATHING_TABLE)), yes)
+    OPT_DEFS += -DUSE_LED_BREATHING_TABLE
+    LED_TABLES = yes
+endif
+
+ifeq ($(strip $(LED_TABLES)), yes)
+    SRC += $(QUANTUM_DIR)/led_tables.c
+endif
+
 # Optimize size but this may cause error "relocation truncated to fit"
 #EXTRALDFLAGS = -Wl,--relax
 
 # Search Path
 VPATH += $(KEYMAP_PATH)
 ifneq ($(SUBPROJECT),)
-	VPATH += $(SUBPROJECT_PATH)
+    VPATH += $(SUBPROJECT_PATH)
 endif
 VPATH += $(KEYBOARD_PATH)
 VPATH += $(COMMON_VPATH)
@@ -243,27 +271,27 @@ EXTRALDFLAGS += $(TMK_COMMON_LDFLAGS)
 
 ifeq ($(PLATFORM),AVR)
 ifeq ($(strip $(PROTOCOL)), VUSB)
-	include $(TMK_PATH)/protocol/vusb.mk
+    include $(TMK_PATH)/protocol/vusb.mk
 else
-	include $(TMK_PATH)/protocol/lufa.mk
+    include $(TMK_PATH)/protocol/lufa.mk
 endif
-	include $(TMK_PATH)/avr.mk
+    include $(TMK_PATH)/avr.mk
 endif
 
 ifeq ($(strip $(VISUALIZER_ENABLE)), yes)
-	VISUALIZER_DIR = $(QUANTUM_DIR)/visualizer
+    VISUALIZER_DIR = $(QUANTUM_DIR)/visualizer
-	VISUALIZER_PATH = $(QUANTUM_PATH)/visualizer
+    VISUALIZER_PATH = $(QUANTUM_PATH)/visualizer
-	include $(VISUALIZER_PATH)/visualizer.mk
+    include $(VISUALIZER_PATH)/visualizer.mk
 endif
 
 OUTPUTS := $(KEYMAP_OUTPUT) $(KEYBOARD_OUTPUT)
 $(KEYMAP_OUTPUT)_SRC := $(SRC)
-$(KEYMAP_OUTPUT)_DEFS := $(OPT_DEFS) -DQMK_KEYBOARD=\"$(KEYBOARD)\" -DQMK_KEYMAP=\"$(KEYMAP)\"
+$(KEYMAP_OUTPUT)_DEFS := $(OPT_DEFS) $(GFXDEFS) -DQMK_KEYBOARD=\"$(KEYBOARD)\" -DQMK_KEYMAP=\"$(KEYMAP)\"
 $(KEYMAP_OUTPUT)_INC :=  $(VPATH) $(EXTRAINCDIRS)
 $(KEYMAP_OUTPUT)_CONFIG := $(CONFIG_H)
-$(KEYBOARD_OUTPUT)_SRC := $(CHIBISRC)
+$(KEYBOARD_OUTPUT)_SRC := $(CHIBISRC) $(GFXSRC)
-$(KEYBOARD_OUTPUT)_DEFS := $(PROJECT_DEFS)
+$(KEYBOARD_OUTPUT)_DEFS := $(PROJECT_DEFS) $(GFXDEFS)
-$(KEYBOARD_OUTPUT)_INC := $(PROJECT_INC)
+$(KEYBOARD_OUTPUT)_INC := $(PROJECT_INC) $(GFXINC)
 $(KEYBOARD_OUTPUT)_CONFIG  := $(PROJECT_CONFIG)
 
 # Default target.

doc/BUILD_GUIDE.md

@@ -96,7 +96,7 @@ The keyboard `config.h` is included only if the keymap one doesn't exist. The fo
 ```
 #undef MY_SETTING
 #define MY_SETTING 4
-```c
+```
 
 For a value of `4` for this imaginary setting. So we `undef` it first, then `define` it.
 

doc/keymap.md

@@ -6,12 +6,12 @@ QMK is based on TMK.   Understanding the essential changes made should help you
 
 ## TMK vs. QMK
 
-| Firmware                                        |TMK                    |QMK                      |
+| Firmware                  |TMK                    |QMK                      |
-|-------------------------------------------------|-----------------------|-------------------------|
+|---------------------------|-----------------------|-------------------------|
-| Maintainer                                      |hasu                   |Jack Humbert et al.      |
+| Maintainer                |hasu                   |Jack Humbert et al.      |
-| Build path customization                        | `TMK_DIR = ...`       | `include .../Makefile`  |
+| Build path customization  | `TMK_DIR = ...`       | `include .../Makefile`  |
-| `keymaps` data                                  | 3D array of `uint8_t`  holding **keycode**      | 3D array of `uint16_t` holding **action code**  |
+| `keymaps` data            | 3D array of `uint8_t` holding **keycode**      | 3D array of `uint16_t` holding **action code**  |
-| `fn_actions` data                               | 1D array of `uint16_t`  holding **action code** | 3D array of `uint16_t` holding **action code**  |
+| `fn_actions` data         | 1D array of `uint16_t` holding **action code** | 1D array of `uint16_t` holding **action code**  |
 
 Since QMK is based on TMK and uses major portion of TMK code as is, understanding the essential changes made should help you understand the code.
 
@@ -45,7 +45,7 @@ Keymap layer has its state in two 32 bit parameters:
 * **`default_layer_state`** indicates a base keymap layer(0-31) which is always valid and to be referred.
 * **`layer_state`** () has current on/off status of the layer on its each bit.
 
-Keymap has its state in two parameter**`default_layer`** indicates a base keymap layer(0-31) which is always valid and to be referred, **`keymap_stat`** is 16bit variable which has current on/off status of layers on its each bit.
+Keymap has its state in two parameter **`default_layer`** indicates a base keymap layer(0-31) which is always valid and to be referred, **`keymap_stat`** is 16bit variable which has current on/off status of layers on its each bit.
 Keymap layer '0' is usually `default_layer` and which is the only valid layer and other layers is initially off after boot up firmware, though, you can configured them in `config.h`.
 To change `default_layer` will be useful when you switch key layout completely, say you want Colmak instead of Qwerty.
 

keyboards/M10A/M10A.c

@@ -0,0 +1,5 @@
+#include "M10A.h"
+
+void matrix_init_kb(void) {
+	matrix_init_user();
+}

keyboards/M10A/M10A.h

@@ -0,0 +1,19 @@
+#ifndef M10A_H
+#define M10A_H
+
+#include "quantum.h"
+
+#define M10A( \
+      k00, k01, k02, \
+      k10, k11, k12, \
+      k20, k21, k22, \
+      k30, k31, k32  \
+) \
+{ \
+    { k00, k01, k02 }, \
+    { k10, k11, k12 }, \
+    { k20, k21, k22 }, \
+    { k30, k31, k32 } \
+} 
+
+#endif

keyboards/M10A/config.h

@@ -0,0 +1,82 @@
+/*
+Copyright 2012 Jun Wako <[email protected]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x0007
+#define DEVICE_VER 		0x0001
+#define MANUFACTURER    Machine Industries
+#define PRODUCT         M10-A
+#define DESCRIPTION     RAMA x Machine Industries M10-A
+
+/* key matrix size */
+#define MATRIX_ROWS 4
+#define MATRIX_COLS 3
+
+/* Planck PCB default pin-out */
+#define MATRIX_ROW_PINS { B6, F7, F6, D6 }
+#define MATRIX_COL_PINS { F5, F1, F0 }
+#define UNUSED_PINS
+
+#define BACKLIGHT_PIN B7
+
+/* COL2ROW or ROW2COL */
+#define DIODE_DIRECTION ROW2COL
+
+/* define if matrix has ghost */
+//#define MATRIX_HAS_GHOST
+
+/* number of backlight levels */
+#define BACKLIGHT_LEVELS 6
+
+/* Set 0 if debouncing isn't needed */
+#define DEBOUNCING_DELAY 5
+
+/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
+#define LOCKING_SUPPORT_ENABLE
+/* Locking resynchronize hack */
+#define LOCKING_RESYNC_ENABLE
+
+/* 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.
+ */
+
+/* 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
+
+#endif

keyboards/M10A/keymaps/default/Makefile

@@ -0,0 +1,3 @@
+ifndef QUANTUM_DIR
+	include ../../../../Makefile
+endif

keyboards/M10A/keymaps/default/keymap.c

@@ -0,0 +1,49 @@
+// This is the canonical layout file for the Quantum project. If you want to add another keyboard,
+// this is the style you want to emulate.
+
+#include "M10A.h"
+#include "action_layer.h"
+#include "eeconfig.h"
+
+extern keymap_config_t keymap_config;
+
+// 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 layers {
+  _LAYER0,
+  _LAYER1,
+  _LAYER2,
+  _LAYER3,
+  _LAYER4,
+  _LAYER5,
+  _LAYER6,
+  _LAYER7,
+  _LAYER8,
+  _LAYER9
+};
+
+// // Fillers to make layering more clear
+// #define _______ KC_TRNS
+// #define XXXXXXX KC_NO
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [_LAYER0] = {{KC_A, KC_B, KC_C}, {KC_D, KC_E, KC_F}, {KC_G, KC_H, KC_I}, {KC_NO, KC_NO, KC_J}},
+  [_LAYER1] = {{KC_A, KC_B, KC_C}, {KC_D, KC_E, KC_F}, {KC_G, KC_H, KC_I}, {KC_NO, KC_NO, KC_J}},
+  [_LAYER2] = {{KC_A, KC_B, KC_C}, {KC_D, KC_E, KC_F}, {KC_G, KC_H, KC_I}, {KC_NO, KC_NO, KC_J}},
+  [_LAYER3] = {{KC_A, KC_B, KC_C}, {KC_D, KC_E, KC_F}, {KC_G, KC_H, KC_I}, {KC_NO, KC_NO, KC_J}},
+  [_LAYER4] = {{KC_A, KC_B, KC_C}, {KC_D, KC_E, KC_F}, {KC_G, KC_H, KC_I}, {KC_NO, KC_NO, KC_J}},
+  [_LAYER5] = {{KC_A, KC_B, KC_C}, {KC_D, KC_E, KC_F}, {KC_G, KC_H, KC_I}, {KC_NO, KC_NO, KC_J}},
+  [_LAYER6] = {{KC_A, KC_B, KC_C}, {KC_D, KC_E, KC_F}, {KC_G, KC_H, KC_I}, {KC_NO, KC_NO, KC_J}},
+  [_LAYER7] = {{KC_A, KC_B, KC_C}, {KC_D, KC_E, KC_F}, {KC_G, KC_H, KC_I}, {KC_NO, KC_NO, KC_J}},
+  [_LAYER8] = {{KC_A, KC_B, KC_C}, {KC_D, KC_E, KC_F}, {KC_G, KC_H, KC_I}, {KC_NO, KC_NO, KC_J}},
+  [_LAYER9] = {{KC_A, KC_B, KC_C}, {KC_D, KC_E, KC_F}, {KC_G, KC_H, KC_I}, {KC_NO, KC_NO, KC_J}}
+};
+
+void matrix_init_user(void) {
+  #ifdef BACKLIGHT_ENABLE
+    backlight_level(0);
+  #endif
+}

keyboards/M10A/rules.mk

@@ -0,0 +1,68 @@
+# MCU name
+#MCU = at90usb1287
+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 to "no" to disable the options, or define them in the Makefile in 
+#   the appropriate keymap folder that will get included automatically
+#
+BOOTMAGIC_ENABLE ?= no       # Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE ?= yes       # Mouse keys(+4700)
+EXTRAKEY_ENABLE ?= yes       # Audio control and System control(+450)
+CONSOLE_ENABLE ?= no         # Console for debug(+400)
+COMMAND_ENABLE ?= no        # Commands for debug and configuration
+NKRO_ENABLE ?= yes            # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+BACKLIGHT_ENABLE ?= yes      # Enable keyboard backlight functionality
+MIDI_ENABLE ?= no            # MIDI controls
+AUDIO_ENABLE ?= no           # Audio output on port C6
+UNICODE_ENABLE ?= yes         # Unicode
+BLUETOOTH_ENABLE ?= no       # Enable Bluetooth with the Adafruit EZ-Key HID
+RGBLIGHT_ENABLE ?= no        # Enable WS2812 RGB underlight.
+API_SYSEX_ENABLE = yes
+
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+SLEEP_LED_ENABLE ?= no    # Breathing sleep LED during USB suspend

keyboards/amj60/amj60.h

@@ -147,6 +147,21 @@
     {k40, k41, k42, XXX, XXX, k45, XXX, XXX, XXX, XXX, k4a, k4b, k4c, k4d}  \
 }
 
+#define KEYMAP_MAX( \
+    k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b, k0c, k0d, k49,\
+    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,      k2d, \
+    k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3a, k3b, k3d, k3c, \
+    k40, k41, k42,           k45,                     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, XXX, k2d}, \
+    {k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3a, k3b, k3c, k3d}, \
+    {k40, k41, k42, XXX, XXX, k45, XXX, XXX, XXX, k49, k4a, k4b, k4c, k4d}  \
+}
+
 void matrix_init_user(void);
 void matrix_scan_user(void);
 

keyboards/amj60/keymaps/maximized/keymap.c

@@ -0,0 +1,61 @@
+// This is the canonical layout file for the Quantum project. If you want to add another keyboard,
+// this is the style you want to emulate.
+
+#include "amj60.h"
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+#define _DEF 0
+#define _SPC 1
+
+// dual-role shortcuts
+#define SPACEDUAL LT(_SPC, KC_SPACE)
+
+
+// increase readability 
+#define _______ KC_TRNS
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    /* Keymap _DEF: Default Layer
+     * ,-----------------------------------------------------------.
+     * |Esc|  1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =| \ | ~ |
+     * |-----------------------------------------------------------|
+     * |Tab  |  Q|  W|  E|  R|  T|  Y|  U|  I|  O|  P|  [|  ]| bspc|
+     * |-----------------------------------------------------------|
+     * |Caps   | A|  S|  D|  F|  G|  H|  J|  K|  L|  ;|  '| Return |
+     * |-----------------------------------------------------------|
+     * |Sft | Fn0|  Z|  X|  C|  V|  B|  N|  M|  ,|  .|  /| Sft |Fn2|
+     * |-----------------------------------------------------------|
+     * |Ctrl|Win |Alt |      Space/Fn0         |Alt |Win |Menu|RCtl|
+     * `-----------------------------------------------------------'
+     */
+    [_DEF] = KEYMAP_MAX(
+        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_BSLS, KC_GRV, \
+        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_BSPC,  \
+        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_LSFT,  F(0),    KC_Z,    KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,    F(1),     \
+        KC_LCTL,  KC_LALT, KC_LGUI,             SPACEDUAL,                       KC_RGUI, KC_RALT, KC_RCTL,    F(2)),
+
+    /* Keymap 1: F-and-vim Layer, modified with Space (by holding space)
+     * ,-----------------------------------------------------------.
+     * |PrSc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|   |  |
+     * |-----------------------------------------------------------|
+     * |    |Paus| Up| [ | ] |   |   |   | ( | ) |   |   |   | Del |
+     * |-----------------------------------------------------------|
+     * |      |Lft|Dwn|Rgt|   |   |Left|Down|Right|Up|  |   | PLAY |
+     * |-----------------------------------------------------------|
+     * |    |   |   |   | < | > |   |M0 |   |   |   |   | Vol+ |   |
+     * |-----------------------------------------------------------|
+     * |    |    |    |                        |Alt |Prev|Vol-|Next|
+     * `-----------------------------------------------------------'
+     */
+    [_SPC] = KEYMAP_MAX(
+        KC_PSCR, 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_PAUS, KC_UP,   _______,  _______, _______, _______,  _______, _______, _______, _______, _______, _______, KC_DEL, \
+        _______, KC_LEFT, KC_DOWN, KC_RIGHT, _______, _______, KC_LEFT,  KC_DOWN,   KC_UP,     KC_RGHT, _______, _______, KC_MPLY, \
+        _______, _______, _______, _______,  _______, _______, KC_SPACE, M(0),      _______,   _______, _______, _______, KC_VOLU, _______, \
+        _______, _______, _______,                                  _______,                                 _______, KC_MPRV, KC_VOLD, KC_MNXT),
+
+};

keyboards/amjpad/amjpad.h

@@ -39,7 +39,22 @@
 	{k40, k41, k42, k43}, \
 	{k50, XXX, k52, XXX} \
 }
-
+#define MAXKEYMAP( \
+    k00, k01, k02, k03, \
+	k10, k11, k12, k13, \
+	k20, k21, k22, k23, \
+	k30, k31, k32, k33, \
+	k40, k41, k42, k43, \
+	k50, k51, k52, k53\
+) \
+{ \
+	{k00, k01, k02, k03}, \
+	{k10, k11, k12, k13}, \
+	{k20, k21, k22, k23}, \
+	{k30, k31, k32, k33}, \
+	{k40, k41, k42, k43}, \
+	{k50, k51, k52, k53} \
+}
 void matrix_init_user(void);
 void matrix_scan_user(void);
 

keyboards/amjpad/keymaps/max/keymap.c

@@ -0,0 +1,102 @@
+#include "amjpad.h"
+
+#ifdef RGBLIGHT_ENABLE
+#include "rgblight.h"
+#endif
+
+// Used for SHIFT_ESC
+#define MODS_CTRL_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+#define _BL 0
+#define _FL 1
+
+#define _______ KC_TRNS
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  /* Keymap _BL: (Base Layer) Default Layer
+   * ,-------------------.
+   * |Esc |Setp| -  | =  |
+   * |----|----|----|----|
+   * | F1 | F2 | F3 | F4 |
+   * |----|----|----|----|
+   * | 7  | 8  | 9  |  - |
+   * |----|----|----|----|
+   * | 4  | 5  | 6  | LF |
+   * |----|----|----|----|
+   * | 1  | 2  | 3  | \  |
+   * |----|----|----|----|
+   * |Left|Down| Up |Rght|
+   * `-------------------'
+   */
+
+[_BL] = MAXKEYMAP(
+
+  KC_ESC,  KC_TAB,  KC_MINS,KC_EQL,  \
+  KC_F1,   KC_F2,   KC_F3,  KC_F4,   \
+  KC_P7,   KC_P8,   KC_P9,  KC_PMNS, \
+  KC_P4,   KC_P5,   KC_P6,  KC_PENT, \
+  KC_P1,   KC_P2,   KC_P3,  KC_BSLS, \
+  KC_LEFT, KC_DOWN, KC_UP,  KC_RIGHT),
+
+  /* Keymap _FL: Function Layer
+   * ,-------------------.
+   * |Esc |TAB |BS  | =  |
+   * |----|----|----|----|
+   * | NL | /  | *  | -  |
+   * |----|----|----|----|
+   * | 7  | 8  | 9  |    |
+   * |----|----|----|RST |
+   * | 4  | 5  | 6  |    |
+   * |----|----|----|----|
+   * | 1  | 2  | 3  |    |
+   * |----|----|----| En |
+   * |   0     |./FN|    |
+   * `-------------------'
+   */
+[_FL] = MAXKEYMAP(
+
+  KC_ESC,KC_TAB,KC_BSPC,KC_PEQL, \
+  KC_NLCK, KC_PSLS, KC_PAST, KC_PMNS, \
+  KC_P7, KC_P8, KC_P9, RESET,  \
+  KC_P4, KC_P5, KC_P6, KC_PENT, \
+  KC_P1, KC_P2, KC_P3, KC_PENT, \
+  KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT),
+};
+
+enum function_id {
+    SHIFT_ESC,
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+  [0]  = ACTION_FUNCTION(SHIFT_ESC),
+};
+
+void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
+  static uint8_t shift_esc_shift_mask;
+  switch (id) {
+    case SHIFT_ESC:
+      shift_esc_shift_mask = get_mods()&MODS_CTRL_MASK;
+      if (record->event.pressed) {
+        if (shift_esc_shift_mask) {
+          add_key(KC_GRV);
+          send_keyboard_report();
+        } else {
+          add_key(KC_ESC);
+          send_keyboard_report();
+        }
+      } else {
+        if (shift_esc_shift_mask) {
+          del_key(KC_GRV);
+          send_keyboard_report();
+        } else {
+          del_key(KC_ESC);
+          send_keyboard_report();
+        }
+      }
+      break;
+  }
+}

keyboards/amjpad/keymaps/ortho_left/keymap.c

@@ -0,0 +1,65 @@
+#include "amjpad.h"
+
+#ifdef RGBLIGHT_ENABLE
+#include "rgblight.h"
+#endif
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+#define _BL 0
+#define _FL 1
+
+#define _______ KC_TRNS
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  /* Keymap _BL: (Base Layer) Default Layer
+   * ,-------------------.
+   * | T  | G  | B  |Spac|
+   * |----|----|----|----|
+   * | R  | F  | V  | Fn |
+   * |----|----|----|----|
+   * | E  | D  | C  | OS |
+   * |----|----|----|----|
+   * | W  | S  | X  | Alt|
+   * |----|----|----|----|
+   * | Q  | A  | Z  | Ctl|
+   * |----|----|----|----|
+   * | Esc| Tab|Shft| Fn2|
+   * `-------------------'
+   */
+
+[_BL] = MAXKEYMAP(
+
+  KC_T,   KC_G,   KC_B,      KC_SPACE,\
+  KC_R,   KC_F,   KC_V,      MO(1),    \
+  KC_E,   KC_D,   KC_C,      KC_LGUI, \
+  KC_W,   KC_S,   KC_X,      KC_LALT, \
+  KC_Q,   KC_A,   KC_Z,      KC_LCTL, \
+  KC_TAB, KC_ESC, KC_LSHIFT, MO(1)),
+
+  /* Keymap _FL: Function Layer
+   * ,-------------------.
+   * | 5  | F5 | F11|Spac|
+   * |----|----|----|----|
+   * | 4  | F4 | F10|    |
+   * |----|----|----|----|
+   * | 3  | F3 | F9 | OS |
+   * |----|----|----|----|
+   * | 2  | F2 | F8 | Alt|
+   * |----|----|----|----|
+   * | 1  | F1 | F7 | Ctl|
+   * |----|----|----|----|
+   * | `  | Del|Shft|    |
+   * `-------------------'
+   */
+[_FL] = MAXKEYMAP(
+
+  KC_5,  KC_F5,  KC_F11,  _______, \
+  KC_4,  KC_F4,  KC_F10,  _______, \
+  KC_3,  KC_F3,  KC_F9,   _______, \
+  KC_2,  KC_F2,  KC_F8,   _______, \
+  KC_1,  KC_F1,  KC_F7,   _______, \
+  KC_GRV,KC_DEL, _______, _______),
+};

keyboards/amjpad/keymaps/ortho_right/keymap.c

@@ -0,0 +1,65 @@
+#include "amjpad.h"
+
+#ifdef RGBLIGHT_ENABLE
+#include "rgblight.h"
+#endif
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+#define _BL 0
+#define _FL 1
+
+#define _______ KC_TRNS
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  /* Keymap _BL: (Base Layer) Default Layer
+   * ,-------------------.
+   * |Spac| N  | H  | Y  |
+   * |----|----|----|----|
+   * | Fn | M  | J  | U  |
+   * |----|----|----|----|
+   * |Left| ,  | K  | I  |
+   * |----|----|----|----|
+   * |Down| .  | L  | O  |
+   * |----|----|----|----|
+   * | Up | /  | ;  | P  |
+   * |----|----|----|----|
+   * |Rght| Ret| "  |Bspc|
+   * `-------------------'
+   */
+
+[_BL] = MAXKEYMAP(
+
+  KC_SPACE, KC_N,     KC_H,      KC_Y, \
+  MO(1),    KC_M,     KC_J,      KC_U, \
+  KC_LEFT,  KC_COMM,  KC_K,      KC_I, \
+  KC_DOWN,  KC_DOT,   KC_L,      KC_O, \
+  KC_UP,    KC_SLASH, KC_SCLN,   KC_P, \
+  KC_RIGHT, KC_ENT,   KC_QUOT,   KC_BSPC),
+
+  /* Keymap _FL: Function Layer
+   * ,-------------------.
+   * |Esc | F12| F6 | 6  |
+   * |----|----|----|----|
+   * | NL | M  | -  | 7  |
+   * |----|----|----|----|
+   * |Left| ,  | =  | 8  |
+   * |----|----|----|----|
+   * |Down| .  | [  | 9  |
+   * |----|----|----|----|
+   * | Up | /  | ]  | 0  |
+   * |----|----|----|----|
+   * |Rght| Ret| \  | Del|
+   * `-------------------'
+   */
+[_FL] = MAXKEYMAP(
+
+  _______, KC_F12,  KC_F6,   KC_6, \
+  _______, _______, KC_MINS, KC_7, \
+  _______, _______, KC_EQL,  KC_8, \
+  _______, _______, KC_LBRC, KC_9, \
+  _______, _______, KC_RBRC, KC_0, \
+  _______, _______, KC_BSLS, KC_DEL),
+};

keyboards/atomic/keymaps/twolayer.c

@@ -0,0 +1,72 @@
+#include "atomic.h"
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+/* QWERTY - MIT ENHANCED / GRID COMPATIBLE
+ * .---------------------------------------------------------------------------------------------------------------------- 2u ------------.
+ * | ESC    | 1      | 2      | 3      | 4      | 5      | 6      | 7      | 8      | 9      | 0      | -      | =      | XXXXXX . BACKSP |
+ * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
+ * | TAB    | Q      | W      | E      | R      | T      | Y      | U      | I      | O      | P      | [      | ]      | \      | DEL    |
+ * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+- 2u ------------+--------|
+ * | LCTRL1 | A      | S      | D      | F      | G      | H      | J      | K      | L      | ;      | '      | XXXXXX . ENTER  | PG UP  |
+ * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+- 2u ---------------------+--------|
+ * | LSHIFT | Z      | X      | C      | V      | B      | N      | M      | ,      | .      | /      | XXXXXX . RSHIFT | UP     | PG DN  |
+ * |--------+--------+--------+--------+--------+- 6.25u ---------+--------+--------+--------+--------+-----------------+--------+--------|
+ * | BRITE  | LALT   |  FN    |               XXXXXX . SPACE                        | RCTRL  | RALT   | FN     | LEFT   | DOWN   | RIGHT  |
+ * '--------------------------------------------------------------------------------------------------------------------------------------'
+ */
+	
+ [0] = { /* QWERTY */
+  { 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_BSPC  },
+  { KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_BSLS, KC_DEL   },
+  { KC_LCTL,  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_ENT,  KC_ENT,  KC_PGUP  },
+  { KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT, KC_RSFT, KC_UP,   KC_PGDN  },
+  { M(0),    KC_ALT, MO(1), KC_SPC, KC_SPC, KC_SPC,  KC_SPC,  KC_SPC,  KC_SPC, KC_RCTL, KC_RALT, MO(1), KC_LEFT, KC_DOWN, KC_RGHT  },
+ },
+
+
+/* FUNCTION
+ * .---------------------------------------------------------------------------------------------------------------------- 2u ------------.
+ * | GRV    | F1     | F2     | F3     | F4     | F5     | F6     | F7     | F8     | F9     | F10    | F11    | F12    | XXXXXX .        |
+ * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
+ * | SCR LK | F13    | F14    | F15    | F16    | F17    | F18    | F19    | F20    | F21    | F22    | F23    | F24    | PAUSE  | PR SCR |
+ * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+- 2u ------------+--------|
+ * | CAP LK | MS BT5 | MS BT4 | MS BT3 | MS BT2 | SLOW M | FAST M | NEXT   | VOL+   | VOL-   | PLAY   |        | XXXXXX .        | WHEEL+ |
+ * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+- 2u ---------------------+--------|
+ * | NUM LK |        |        |        |        |        |        |        | INSERT |   END1 |  HOME  | XXXXXX .        | MOUS U | WHEEL- |
+ * |--------+--------+--------+--------+--------+- 6.25 ------------+--------+--------+------+--------+-----------------+--------+--------|
+ * |        |        |   FN   |                  XXXXXX . MS BT1                      |      |        |   FN   | MOUS L | MOUS D | MOUS R |
+ * '--------------------------------------------------------------------------------------------------------------------------------------'
+ */
+ 
+ [1] = { /* FUNCTION LAYER*/
+  { KC_GRV, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  ___T___, ___T___  },
+  { KC_SLCK, KC_F13,  KC_F14,  KC_F15,  KC_F16,  KC_F17,  KC_F18,  KC_F19,  KC_F20,  KC_F21,  KC_F22,  KC_F23,  KC_F24,  KC_PAUS, KC_PSCR  },
+  { KC_CAPS, KC_BTN5, KC_BTN4, KC_BTN3, KC_BTN2, KC_ACL0, KC_ACL2, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY, _______, ___T___, ___T___, KC_WH_U  },
+  { KC_NLCK, _______, _______, _______, _______, _______, _______, _______, KC_INSERT, KC_END, KC_HOME, ___T___, ___T___, KC_MS_U, KC_WH_D  },
+  { _______, _______, MO(1), _______, _______, KC_BTN1, KC_BTN1, _______, _______, _______, _______, MO(1), KC_MS_L, KC_MS_D, KC_MS_R  },
+ },
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+    [1] = ACTION_LAYER_MOMENTARY(1),
+    [2] = ACTION_LAYER_MOMENTARY(1),
+};
+
+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);
+            #ifdef BACKLIGHT_ENABLE
+              backlight_step();
+            #endif
+          } else {
+            unregister_code(KC_RSFT);
+          }
+        break;
+      }
+    return MACRO_NONE;
+};

keyboards/atreus/keymaps/default/keymap.c

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

keyboards/atreus/keymaps/xyverz/keymap.c

@@ -12,49 +12,156 @@ extern keymap_config_t keymap_config;
 // The underscores don't mean anything - you can have a layer called STUFF or any other name.
 // Layer names don't all need to be of the same length, obviously, and you can also skip them
 // entirely and just use numbers.
-#define _DV 0
+#define _DVORAK 0
-#define _QW 1
+#define _QWERTY 1
-#define _CM 2
+#define _COLEMAK 2
-#define _L1 3
+#define _DVORMAC 3
-#define _L2 4
+#define _LOWER 4
+#define _RAISE 5
+#define _ADJUST 16
 
-// Macro name shortcuts
+enum planck_keycodes {
-#define DVORAK M(_DV)
+  DVORAK = SAFE_RANGE,
-#define QWERTY M(_QW)
+  QWERTY,
-#define COLEMAK M(_CM)
+  COLEMAK,
+  DVORMAC,
+  LOWER,
+  RAISE,
+  BACKLIT
+};
 
+// Adding macros to make the keymaps below much easier to read.
+#define SFTSCLN SFT_T(KC_SCLN)
+#define SFTSLSH SFT_T(KC_SLSH)
+#define SFTZED SFT_T(KC_Z)
+#define ALTENT ALT_T(KC_ENT)
+#define ESCTRL CTL_T(KC_ESC)
+#define TABALT ALT_T(KC_TAB)
+
+// Fillers to make layering more clear
+#define _______ KC_TRNS
+#define XXXXXXX KC_NO
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-  [_DV] = { /* Dvorak */
+/* Dvorak Layer
-    {KC_QUOT, KC_COMM, KC_DOT,  KC_P,    KC_Y,    KC_NO,   KC_F,    KC_G,    KC_C,    KC_R,    KC_L   },
+	,----------------------------------.              ,----------------------------------.
-    {KC_A,    KC_O,    KC_E,    KC_U,    KC_I,    KC_NO,   KC_D,    KC_H,    KC_T,    KC_N,    KC_S   },
+	|   '  |   ,  |   .  |   P  |   Y  |              |   F  |   G  |   C  |   R  |   L  |
-    {SFT_T(KC_SCLN), KC_Q, KC_J, KC_K, KC_X, CTL_T(KC_DEL),  KC_B,  KC_M,  KC_W,  KC_V,   SFT_T(KC_Z) },
+	|------+------+------+------+------|              |------+------+------+------+------|
-    {KC_ESC, KC_TAB, KC_LGUI, MO(_L2), KC_BSPC, ALT_T(KC_ENT), KC_SPC, MO(_L1), KC_MINS, KC_SLSH, KC_EQL}
+	|   A  |   O  |   E  |   U  |   I  |              |   D  |   H  |   T  |   N  |   S  |
+	|------+------+------+------+------|------.,------|------+------+------+------+------|
+	|SFT/ ;|   Q  |   J  |   K  |   X  | CTRL ||Alt / |   B  |   M  |   W  |   V  |SFT/ Z|
+	|------+------+------+------+------|      ||Enter |------+------+------+------+------|
+	|  Esc |  Tab |  GUI | LOWER| BkSp |------'`------|  Spc | RAISE|   -  |   /  |   \  |
+	`----------------------------------'              `----------------------------------' */
+  [_DVORAK] = {
+    {KC_QUOT, KC_COMM, KC_DOT,  KC_P,    KC_Y,    XXXXXXX, KC_F,    KC_G,    KC_C,    KC_R,    KC_L   },
+    {KC_A,    KC_O,    KC_E,    KC_U,    KC_I,    XXXXXXX, KC_D,    KC_H,    KC_T,    KC_N,    KC_S   },
+    {SFTSCLN, KC_Q,    KC_J,    KC_K,    KC_X,    KC_LCTL, KC_B,    KC_M,    KC_W,    KC_V,    SFTZED },
+    {ESCTRL,  TABALT,  KC_LGUI, LOWER,   KC_BSPC, ALTENT,  KC_SPC,  RAISE,   KC_MINS, KC_SLSH, KC_BSLS}
   },
-  [_QW] = { /* Qwerty */
+
-    {KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_NO,   KC_Y,    KC_U,    KC_I,    KC_O,    KC_P   },
+/* QWERTY Layer
-    {KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_NO,   KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN},
+	,----------------------------------.              ,----------------------------------.
-    {SFT_T(KC_Z), KC_X, KC_C, KC_V, KC_B, CTL_T(KC_DEL), KC_N, KC_M, KC_COMM, KC_DOT, SFT_T(KC_SLSH)  },
+	|   Q  |   W  |   E  |   R  |   T  |              |   Y  |   U  |   I  |   O  |   P  |
-    {KC_ESC, KC_TAB, KC_LGUI, MO(_L2), KC_BSPC, ALT_T(KC_ENT), KC_SPC, MO(_L1), KC_MINS, KC_QUOT, KC_ENT}
+	|------+------+------+------+------|              |------+------+------+------+------|
+	|   A  |   S  |   D  |   F  |   G  |              |   H  |   J  |   K  |   L  |   ;  |
+	|------+------+------+------+------|------.,------|------+------+------+------+------|
+	|SFT/ Z|   X  |   C  |   V  |   B  | CTRL ||Alt / |   N  |   M  |   ,  |   .  |SFT/ /|
+	|------+------+------+------+------|      ||Enter |------+------+------+------+------|
+	|  Esc |  Tab |  GUI | LOWER| BkSp |------'`------|  Spc | RAISE|   -  |   '  |   \  |
+	`----------------------------------'              `----------------------------------' */
+  [_QWERTY] = {
+    {KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    XXXXXXX, KC_Y,    KC_U,    KC_I,    KC_O,    KC_P   },
+    {KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    XXXXXXX, KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN},
+    {SFTZED,  KC_X,    KC_C,    KC_V,    KC_B,    KC_LCTL, KC_N,    KC_M,    KC_COMM, KC_DOT,  SFTSLSH},
+    {ESCTRL,  TABALT,  KC_LGUI, LOWER,   KC_BSPC, ALTENT,  KC_SPC,  RAISE,   KC_MINS, KC_QUOT, KC_BSLS}
   },
-  [_CM] = { /* Colemak */
+
-    {KC_Q,    KC_W,    KC_F,    KC_P,    KC_G,    KC_NO,   KC_J,    KC_L,    KC_U,    KC_Y,    KC_SCLN},
+/* Colemak Layer
-    {KC_A,    KC_R,    KC_S,    KC_T,    KC_D,    KC_NO,   KC_H,    KC_N,    KC_E,    KC_I,    KC_O   },
+	,----------------------------------.              ,----------------------------------.
-    {SFT_T(KC_Z), KC_X, KC_C, KC_V, KC_B, CTL_T(KC_DEL), KC_K, KC_M, KC_COMM, KC_DOT, SFT_T(KC_SLSH)  },
+	|   Q  |   W  |   F  |   P  |   G  |              |   J  |   L  |   U  |   Y  |   L  |
-    {KC_ESC, KC_TAB, KC_LGUI, MO(_L2), KC_BSPC, ALT_T(KC_ENT), KC_SPC, MO(_L1), KC_MINS, KC_QUOT, KC_ENT}
+	|------+------+------+------+------|              |------+------+------+------+------|
+	|   A  |   R  |   S  |   T  |   D  |              |   H  |   N  |   E  |   I  |   S  |
+	|------+------+------+------+------|------.,------|------+------+------+------+------|
+	|SFT/ Z|   X  |   C  |   V  |   B  | CTRL ||Alt / |   K  |   M  |   ,  |   .  |SFT/ /|
+	|------+------+------+------+------|      ||Enter |------+------+------+------+------|
+	|  Esc |  Tab |  GUI | LOWER| BkSp |------'`------|  Spc | RAISE|   -  |   '  |   \  |
+	`----------------------------------'              `----------------------------------'*/
+  [_COLEMAK] = {
+    {KC_Q,    KC_W,    KC_F,    KC_P,    KC_G,    XXXXXXX, KC_J,    KC_L,    KC_U,    KC_Y,    KC_SCLN},
+    {KC_A,    KC_R,    KC_S,    KC_T,    KC_D,    XXXXXXX, KC_H,    KC_N,    KC_E,    KC_I,    KC_O   },
+    {SFTZED,  KC_X,    KC_C,    KC_V,    KC_B,    KC_LCTL, KC_K,    KC_M,    KC_COMM, KC_DOT,  SFTSLSH},
+    {ESCTRL,  TABALT,  KC_LGUI, LOWER,   KC_BSPC, ALTENT,  KC_SPC,  RAISE,   KC_MINS, KC_QUOT, KC_BSLS}
   },
-  [_L1] = { /* LAYER 1 */
+
-    {KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_NO,   KC_6,    KC_7,    KC_8,    KC_9,    KC_0   },
+/* Dvorak Layer with Command key on left thumb instead of Control
-    {KC_TAB,  KC_INS,  KC_UP,   KC_DEL,  KC_HOME, KC_NO,   KC_PGUP, KC_MUTE, KC_VOLD, KC_VOLU, KC_EQL },
+	,----------------------------------.              ,----------------------------------.
-    {KC_TRNS, KC_LEFT, KC_DOWN, KC_RGHT, KC_END,  KC_LCTL, KC_PGDN, KC_MPRV, KC_MPLY, KC_MNXT, KC_BSLS},
+	|   '  |   ,  |   .  |   P  |   Y  |              |   F  |   G  |   C  |   R  |   L  |
-    {KC_TRNS, KC_GRV,  KC_LGUI, KC_TRNS, KC_DEL,  KC_LALT, KC_SPC,  KC_TRNS, KC_LBRC, KC_RBRC, KC_ENT }
+	|------+------+------+------+------|              |------+------+------+------+------|
+	|   A  |   O  |   E  |   U  |   I  |              |   D  |   H  |   T  |   N  |   S  |
+	|------+------+------+------+------|------.,------|------+------+------+------+------|
+	|SFT/ ;|   Q  |   J  |   K  |   X  | CMD  ||Alt / |   B  |   M  |   W  |   V  |SFT/ Z|
+	|------+------+------+------+------|      ||Enter |------+------+------+------+------|
+	|  Esc |  Tab |  GUI | LOWER| BkSp |------'`------|  Spc | RAISE|   -  |   /  |   \  |
+	`----------------------------------'              `----------------------------------' */
+  [_DVORMAC] = {
+    {KC_QUOT, KC_COMM, KC_DOT,  KC_P,    KC_Y,    XXXXXXX, KC_F,    KC_G,    KC_C,    KC_R,    KC_L   },
+    {KC_A,    KC_O,    KC_E,    KC_U,    KC_I,    XXXXXXX, KC_D,    KC_H,    KC_T,    KC_N,    KC_S   },
+    {SFTSCLN, KC_Q,    KC_J,    KC_K,    KC_X,    KC_LGUI, KC_B,    KC_M,    KC_W,    KC_V,    SFTZED },
+    {ESCTRL,  TABALT,  KC_LGUI, LOWER,   KC_BSPC, ALTENT,  KC_SPC,  RAISE,   KC_MINS, KC_SLSH, KC_BSLS}
   },
-  [_L2] = { /* LAYER 2 */
+
-    {KC_EXLM, KC_AT,   KC_HASH, KC_DLR,  KC_PERC, KC_NO,   KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN},
+/* LOWER Layer
-    {KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_NO,   KC_TRNS, KC_F6,   KC_F7,   KC_F8,   KC_PLUS},
+	,----------------------------------.              ,----------------------------------.
-    {KC_TRNS, KC_TRNS, DVORAK,  QWERTY,  COLEMAK, KC_LCTL, KC_TRNS, KC_F9,   KC_F10,  KC_F11,  KC_F12 },
+	|   !  |   @  |   #  |   $  |   %  |              |   ^  |   &  |   *  |   (  |   )  |
-    {KC_TRNS, KC_TRNS, KC_LGUI, KC_TRNS, KC_BSPC, KC_LALT, KC_SPC,  KC_TRNS, LSFT(KC_LBRC), LSFT(KC_RBRC), RESET}
+	|------+------+------+------+------|              |------+------+------+------+------|
+	| CAPS |      |  UP  |      | Home |              | PgDn |      |   +  |   {  |   }  |
+	|------+------+------+------+------|------.,------|------+------+------+------+------|
+	|      | Left | Down | Right| End  |      ||      | PgUp | Mute | Vol- | Vol+ |      |
+	|------+------+------+------+------|      ||      |------+------+------+------+------|
+	|   ~  |      |      |      | Del  |------'`------| Ins  |      |      |      |      |
+	`----------------------------------'              `----------------------------------'*/
+  [_LOWER] = {
+    {KC_EXLM, KC_AT,   KC_HASH, KC_DLR,  KC_PERC, XXXXXXX, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN},
+    {KC_CAPS, _______, KC_UP,   _______, KC_HOME, XXXXXXX, KC_PGUP, _______, KC_PLUS, KC_LCBR, KC_RCBR},
+    {_______, KC_LEFT, KC_DOWN, KC_RGHT, KC_END,  _______, KC_PGDN, KC_MUTE, KC_VOLD, KC_VOLU, _______},
+    {KC_TILD, _______, _______, _______, KC_DEL,  _______, KC_INS,  _______, _______, _______, _______}
+  },
+
+/* RAISE Layer
+	,----------------------------------.              ,----------------------------------.
+	|   1  |   2  |   3  |   4  |   5  |              |   6  |   7  |   8  |   9  |   0  |
+	|------+------+------+------+------|              |------+------+------+------+------|
+	| CAPS |      |  UP  |      | Home |              | PgDn |      |   =  |   [  |   ]  |
+	|------+------+------+------+------|------.,------|------+------+------+------+------|
+	|      | Left | Down | Right| End  |      ||      | PgUp | Prev | Play | Next |      |
+	|------+------+------+------+------|      ||      |------+------+------+------+------|
+	|   `  |      |      |      | Del  |------'`------| Ins  |      |      |      |      |
+	`----------------------------------'              `----------------------------------'*/
+  [_RAISE] = {
+    {KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    XXXXXXX, KC_6,    KC_7,    KC_8,    KC_9,    KC_0   },
+    {KC_CAPS, _______, KC_UP,   _______, KC_HOME, XXXXXXX, KC_PGUP, _______, KC_EQL,  KC_LBRC, KC_RBRC},
+    {_______, KC_LEFT, KC_DOWN, KC_RGHT, KC_END,  _______, KC_PGDN, KC_MPRV, KC_MPLY, KC_MNXT, _______},
+    {KC_GRV,  _______, _______, _______, KC_DEL,  _______, KC_INS,  _______, _______, _______, _______}
+  },
+
+/* ADJUST Layer
+	,----------------------------------.              ,----------------------------------.
+	|  F1  |  F2  |  F3  |  F4  |  F5  |              |  F6  |  F7  |  F8  |  F9  | F10  |
+	|------+------+------+------+------|              |------+------+------+------+------|
+	|  F11 |      |      |      |      |              |      | PrSc | ScLk | Paus | F12  |
+	|------+------+------+------+------|------.,------|------+------+------+------+------|
+	|      |QWERTY|COLEMK|DVORAK|DVORMC|      ||      |      |      |      |      |      |
+	|------+------+------+------+------|      ||      |------+------+------+------+------|
+	|      |      |      |      |      |------'`------|      |      |      |      | RESET|
+	`----------------------------------'              `----------------------------------'*/
+  [_ADJUST] = {
+    {KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   XXXXXXX, KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10 },
+    {KC_F11,  _______, _______, _______, _______, XXXXXXX, _______, KC_PSCR, KC_SLCK, KC_PAUS, KC_F12 },
+    {_______, QWERTY,  COLEMAK, DVORAK,  DVORMAC, _______, _______, _______, _______, _______, _______},
+    {_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, RESET  }
   }
+
 };
 
 const uint16_t PROGMEM fn_actions[] = {
@@ -66,24 +173,52 @@ void persistant_default_layer_set(uint16_t default_layer) {
   default_layer_set(default_layer);
 }
 
-const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-{
+  switch (keycode) {
-      switch(id) {
+        case QWERTY:
-        case _DV:
           if (record->event.pressed) {
-            persistant_default_layer_set(1UL<<_DV);
+            persistant_default_layer_set(1UL<<_QWERTY);
           }
+          return false;
           break;
-        case _QW:
+        case COLEMAK:
           if (record->event.pressed) {
-            persistant_default_layer_set(1UL<<_QW);
+            persistant_default_layer_set(1UL<<_COLEMAK);
           }
+          return false;
           break;
-        case _CM:
+        case DVORAK:
           if (record->event.pressed) {
-            persistant_default_layer_set(1UL<<_CM);
+            persistant_default_layer_set(1UL<<_DVORAK);
           }
+          return false;
+          break;
+        case DVORMAC:
+          if (record->event.pressed) {
+            persistant_default_layer_set(1UL<<_DVORMAC);
+          }
+          return false;
+          break;
+        case LOWER:
+          if (record->event.pressed) {
+            layer_on(_LOWER);
+            update_tri_layer(_LOWER, _RAISE, _ADJUST);
+          } else {
+            layer_off(_LOWER);
+            update_tri_layer(_LOWER, _RAISE, _ADJUST);
+          }
+          return false;
+          break;
+        case RAISE:
+          if (record->event.pressed) {
+            layer_on(_RAISE);
+            update_tri_layer(_LOWER, _RAISE, _ADJUST);
+          } else {
+            layer_off(_RAISE);
+            update_tri_layer(_LOWER, _RAISE, _ADJUST);
+          }
+          return false;
           break;
       }
-    return MACRO_NONE;
+    return true;
 };

keyboards/atreus/keymaps/xyverz/readme.md

@@ -0,0 +1,107 @@
+# Xyverz's Atreus Keymap
+
+## About this keymap:
+
+This is the second iteration of my Atreus keymap. The first one was as close to the planck as I could get at the
+time, but still very much like the original Atreus keymap. I've managed to get things working better now and have
+implemented (more like copied) the RAISE/LOWER/ADJUST layers. This is a work in progress, but I think I'm closer
+to a final go with this.
+
+I'm using MOD_TAP quite a bit in this keymap. On all layers, R4 pinky keys use mod-tap and are SHIFT when held
+and their normal keys when tapped. In addition, ESC and TAB are also set as Ctrl and ALT respectively when held,
+and Enter/ALT on the right thumb key for all layers.
+
+I've enabled persistent keymaps for Qwerty, Dvorak and Colemak layers, similar to the default Planck layouts.
+
+Recently added: Documentation, Formatting, and another Dvorak layer that has Command on the left thumb, instead of
+Control.
+
+## Still to do:
+
+ * Enjoy this revision; figure out new things later.
+
+### Layer 0: Dvorak layer
+
+	,----------------------------------.              ,----------------------------------.
+	|   '  |   ,  |   .  |   P  |   Y  |              |   F  |   G  |   C  |   R  |   L  |
+	|------+------+------+------+------|              |------+------+------+------+------|
+	|   A  |   O  |   E  |   U  |   I  |              |   D  |   H  |   T  |   N  |   S  |
+	|------+------+------+------+------|------.,------|------+------+------+------+------|
+	|Shft ;|   Q  |   J  |   K  |   X  | CTRL ||Alt / |   B  |   M  |   W  |   V  |Shft Z|
+	|------+------+------+------+------|      ||Enter |------+------+------+------+------|
+	|  Esc |  Tab |  GUI | LOWER| BkSp |------'`------|  Spc | RAISE|   -  |   /  |   \  |
+	`----------------------------------'              `----------------------------------'
+
+### Layer 1: QWERTY layer
+
+	,----------------------------------.              ,----------------------------------.
+	|   Q  |   W  |   E  |   R  |   T  |              |   Y  |   U  |   I  |   O  |   P  |
+	|------+------+------+------+------|              |------+------+------+------+------|
+	|   A  |   S  |   D  |   F  |   G  |              |   H  |   J  |   K  |   L  |   ;  |
+	|------+------+------+------+------|------.,------|------+------+------+------+------|
+	|Shft Z|   X  |   C  |   V  |   B  | CTRL ||Alt / |   N  |   M  |   ,  |   .  |Shft /|
+	|------+------+------+------+------|      ||Enter |------+------+------+------+------|
+	|  Esc |  Tab |  GUI | LOWER| BkSp |------'`------|  Spc | RAISE|   -  |   '  |   \  |
+	`----------------------------------'              `----------------------------------'
+	 
+### Keymap 2: Colemak layer
+
+	,----------------------------------.              ,----------------------------------.
+	|   Q  |   W  |   F  |   P  |   G  |              |   J  |   L  |   U  |   Y  |   L  |
+	|------+------+------+------+------|              |------+------+------+------+------|
+	|   A  |   R  |   S  |   T  |   D  |              |   H  |   N  |   E  |   I  |   S  |
+	|------+------+------+------+------|------.,------|------+------+------+------+------|
+	|Shft Z|   X  |   C  |   V  |   B  | CTRL ||Alt / |   K  |   M  |   ,  |   .  |Shft /|
+	|------+------+------+------+------|      ||Enter |------+------+------+------+------|
+	|  Esc |  Tab |  GUI | LOWER| BkSp |------'`------|  Spc | RAISE|   -  |   '  |   \  |
+	`----------------------------------'              `----------------------------------'
+
+### Keymap 3: Dvorak for Mac layout
+
+	,----------------------------------.              ,----------------------------------.
+	|   '  |   ,  |   .  |   P  |   Y  |              |   F  |   G  |   C  |   R  |   L  |
+	|------+------+------+------+------|              |------+------+------+------+------|
+	|   A  |   O  |   E  |   U  |   I  |              |   D  |   H  |   T  |   N  |   S  |
+	|------+------+------+------+------|------.,------|------+------+------+------+------|
+	|SFT/ ;|   Q  |   J  |   K  |   X  | CMD  ||Alt / |   B  |   M  |   W  |   V  |SFT/ Z|
+	|------+------+------+------+------|      ||Enter |------+------+------+------+------|
+	|  Esc |  Tab |  GUI | LOWER| BkSp |------'`------|  Spc | RAISE|   -  |   /  |   \  |
+	`----------------------------------'              `----------------------------------'
+
+### Keymap 4: LOWER layer
+
+	,----------------------------------.              ,----------------------------------.
+	|   !  |   @  |   #  |   $  |   %  |              |   ^  |   &  |   *  |   (  |   )  |
+	|------+------+------+------+------|              |------+------+------+------+------|
+	| CAPS |      |  UP  |      | Home |              | PgDn |      |   +  |   {  |   }  |
+	|------+------+------+------+------|------.,------|------+------+------+------+------|
+	|      | Left | Down | Right| End  |      ||      | PgUp | Mute | Vol- | Vol+ |      |
+	|------+------+------+------+------|      ||      |------+------+------+------+------|
+	|   ~  |      |      |      | Del  |------'`------| Ins  |      |      |      |      |
+	`----------------------------------'              `----------------------------------'
+
+
+### Keymap 5: RAISE layer
+
+	,----------------------------------.              ,----------------------------------.
+	|   1  |   2  |   3  |   4  |   5  |              |   6  |   7  |   8  |   9  |   0  |
+	|------+------+------+------+------|              |------+------+------+------+------|
+	| CAPS |      |  UP  |      | Home |              | PgDn |      |   =  |   [  |   ]  |
+	|------+------+------+------+------|------.,------|------+------+------+------+------|
+	|      | Left | Down | Right| End  |      ||      | PgUp | Prev | Play | Next |      |
+	|------+------+------+------+------|      ||      |------+------+------+------+------|
+	|   `  |      |      |      | Del  |------'`------| Ins  |      |      |      |      |
+	`----------------------------------'              `----------------------------------'
+
+### Keymap 6: ADJUST layer
+
+	,----------------------------------.              ,----------------------------------.
+	|  F1  |  F2  |  F3  |  F4  |  F5  |              |  F6  |  F7  |  F8  |  F9  | F10  |
+	|------+------+------+------+------|              |------+------+------+------+------|
+	|  F11 |      |      |      |      |              |      | PScr | SLck | Paus | F12  |
+	|------+------+------+------+------|------.,------|------+------+------+------+------|
+	|      |QWERTY|COLEMK|DVORAK|DVORMC|      ||      |      |      |      |      |      |
+	|------+------+------+------+------|      ||      |------+------+------+------+------|
+	|      |      |      |      |      |------'`------|      |      |      |      | RESET|
+	`----------------------------------'              `----------------------------------'
+

keyboards/atreus62/keymaps/xyverz/keymap.c

@@ -0,0 +1,175 @@
+/* This is the Atreus62 keyboard layout by Xyverz aka u/Zrevyx on r/mk
+   I've blatantly stolen what works for me from the Planck and Preonic
+   layouts and modified this file to fit me. Initial credet goes to
+   u/profet23 for the doing all the work and adding this keyboard to
+   QMK in the first place.
+
+   I've got Dvorak, Qwerty, and Colemak layouts at this time, with the
+   possibility of adding more in the future.
+
+   The bottom row is fairly Kinesis-ish since the Contour and Advantage
+   keyboards have been my daily drivers for the last 17 years. I hope
+   You can get some enjoyment out of this layout should you chose it!
+
+CHANGELOG:
+
+ 0.1 - Initial commit. Based off of Profet's default keymap.
+ 0.2 - Converted to a more Planck/Preonic keymap style file with 
+       persistent layers enabled. Renamed layers to reflect OLKB maps.
+       Added a TODO list.
+
+TODO:
+
+ * Make the layout more efficient, even if it means changing the RAISE
+   and LOWER functionality.
+ * Add legends in comments for each layer. Maybe.
+ * Add a gaming layer.
+
+*/
+
+// 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 "atreus62.h"
+#include "action_layer.h"
+#include "eeconfig.h"
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+#define _DVORAK 0
+#define _QWERTY 1
+#define _COLEMAK 2
+#define _WOW 3
+#define _LOWER 4
+#define _RAISE 5
+#define _ADJUST 16
+
+enum atreus52_keycodes {
+  DVORAK = SAFE_RANGE,
+  QWERTY,
+  COLEMAK,
+  WOW,
+  LOWER,
+  RAISE
+};
+
+// Fillers to make layering more clear
+#define _______ KC_TRNS
+#define XXXXXXX KC_NO
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    [_DVORAK] = { /* dvorak */
+        { KC_ESC,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    _______, KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSLS },
+        { KC_TAB,  KC_QUOT, KC_COMM, KC_DOT,  KC_P,    KC_Y,    _______, KC_F,    KC_G,    KC_C,    KC_R,    KC_L,    KC_SLSH },
+        { KC_CAPS, KC_A,    KC_O,    KC_E,    KC_U,    KC_I,    _______, KC_D,    KC_H,    KC_T,    KC_N,    KC_S,    KC_MINS },
+        { KC_LSFT, KC_SCLN, KC_Q,    KC_J,    KC_K,    KC_X,    KC_LGUI, KC_B,    KC_M,    KC_W,    KC_V,    KC_Z,    KC_RSFT },
+        { KC_LCTL, KC_LALT, KC_LEFT, KC_RGHT, LOWER,   KC_BSPC, KC_ENT,  KC_SPC,  RAISE,   KC_UP,   KC_DOWN, KC_RGUI, KC_RCTL }
+    },
+    
+    [_QWERTY] = { /* qwerty */
+        { 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_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    _______, KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_DEL  },
+        { KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    _______, KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT },
+        { KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_LGUI, KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT },
+        { KC_LCTL, KC_LALT, KC_LEFT, KC_RGHT, LOWER,   KC_BSPC, KC_ENT,  KC_SPC,  RAISE,   KC_UP,   KC_DOWN, KC_RGUI, KC_RCTL }
+    },
+    
+    [_COLEMAK] = { /* colemak */
+        { 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_TAB,  KC_Q,    KC_W,    KC_F,    KC_P,    KC_G,    _______, KC_J,    KC_L,    KC_U,    KC_Y,    KC_SCLN, KC_DEL  },
+        { KC_BSPC, KC_A,    KC_R,    KC_S,    KC_T,    KC_D,    _______, KC_H,    KC_N,    KC_E,    KC_I,    KC_O,    KC_QUOT },
+        { KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_LGUI, KC_K,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT },
+        { KC_LCTL, KC_LALT, KC_LEFT, KC_RGHT, LOWER,   KC_BSPC, KC_ENT,  KC_SPC,  RAISE,   KC_UP,   KC_DOWN, KC_RGUI, KC_RCTL}
+    },
+
+    [_WOW] = { /* Dvorak with minor modifications for playing World of Warcraft */
+        { KC_ESC,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    _______, KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSLS },
+        { KC_TAB,  KC_QUOT, KC_COMM, KC_DOT,  KC_P,    KC_Y,    _______, KC_F,    KC_G,    KC_C,    KC_R,    KC_L,    KC_SLSH },
+        { KC_CAPS, KC_A,    KC_O,    KC_E,    KC_U,    KC_I,    _______, KC_D,    KC_H,    KC_T,    KC_N,    KC_S,    KC_MINS },
+        { KC_LSFT, KC_SCLN, KC_Q,    KC_J,    KC_K,    KC_X,    KC_LALT, KC_B,    KC_M,    KC_W,    KC_V,    KC_Z,    KC_RSFT },
+        { KC_LCTL, KC_LALT, KC_LEFT, KC_RGHT, LOWER,   KC_BSPC, CTL_T(KC_ENT), KC_SPC,  RAISE,   KC_UP,   KC_DOWN, KC_RGUI, KC_ENT }
+    },
+    
+    [_LOWER] = {
+        { KC_F11,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   _______, KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F12  },
+        { KC_TILD, KC_GRV,  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_PIPE },
+        { _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_PLUS, KC_LCBR, KC_RCBR, _______ },
+        { _______, _______, _______, _______, _______, _______, _______, _______, KC_MUTE, KC_VOLD, KC_VOLU, _______, _______ },
+        { _______, _______, KC_HOME, KC_END,  _______, KC_DEL,  _______, KC_INS,  _______, KC_PGUP, KC_PGDN, _______, _______ }
+    },
+    [_RAISE] = {
+        { KC_F11,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   _______, KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F12  },
+        { KC_TILD, KC_GRV,  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_BSLS },
+        { _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_EQL,  KC_LBRC, KC_RBRC, _______ },
+        { _______, _______, _______, _______, _______, _______, _______, _______, KC_MPRV, KC_MPLY, KC_MNXT, _______, _______ },
+        { _______, _______, KC_HOME, KC_END,  _______, KC_DEL,  _______, KC_INS,  _______, KC_PGUP, KC_PGDN, _______, _______ }
+    },
+    [_ADJUST] = {
+        { _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ },
+        { _______, RESET,   _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ },
+        { _______, _______, _______, _______, _______, _______, _______, _______, QWERTY,  COLEMAK, DVORAK,  _______, WOW     },
+        { _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ },
+        { _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ }
+    },
+
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+
+};
+
+void persistant_default_layer_set(uint16_t default_layer) {
+  eeconfig_update_default_layer(default_layer);
+  default_layer_set(default_layer);
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+        case QWERTY:
+          if (record->event.pressed) {
+            persistant_default_layer_set(1UL<<_QWERTY);
+          }
+          return false;
+          break;
+        case COLEMAK:
+          if (record->event.pressed) {
+            persistant_default_layer_set(1UL<<_COLEMAK);
+          }
+          return false;
+          break;
+        case DVORAK:
+          if (record->event.pressed) {
+            persistant_default_layer_set(1UL<<_DVORAK);
+          }
+          return false;
+          break;
+        case WOW:
+          if (record->event.pressed) {
+            persistant_default_layer_set(1UL<<_WOW);
+          }
+          return false;
+          break;
+        case LOWER:
+          if (record->event.pressed) {
+            layer_on(_LOWER);
+            update_tri_layer(_LOWER, _RAISE, _ADJUST);
+          } else {
+            layer_off(_LOWER);
+            update_tri_layer(_LOWER, _RAISE, _ADJUST);
+          }
+          return false;
+          break;
+        case RAISE:
+          if (record->event.pressed) {
+            layer_on(_RAISE);
+            update_tri_layer(_LOWER, _RAISE, _ADJUST);
+          } else {
+            layer_off(_RAISE);
+            update_tri_layer(_LOWER, _RAISE, _ADJUST);
+          }
+          return false;
+          break;
+      }
+    return true;
+};

keyboards/clueboard/keymaps/serubin/Makefile

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

keyboards/clueboard/keymaps/serubin/keymap.c

@@ -0,0 +1,103 @@
+#include "clueboard.h"
+
+// Helpful defines
+#define GRAVE_MODS  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)|MOD_BIT(KC_LALT)|MOD_BIT(KC_RALT))
+#define _______ KC_TRNS
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+#define _BL 0
+#define _FL 1
+#define _ME 2
+#define _CL 3
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  /* Keymap _BL: Base Layer (Default Layer)
+   */
+[_BL] = KEYMAP(
+  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_GRV,  KC_BSPC,          KC_PGUP, \
+  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_PGDN, \
+  F(1), 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_LSFT, KC_NUBS, KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM, KC_DOT,   KC_SLSH,  KC_RO,    KC_RSFT,          KC_UP,            \
+  KC_LCTL, KC_LGUI, KC_LALT, KC_MHEN,          KC_SPC,KC_SPC,                        KC_HENK,  KC_RGUI,  MO(_FL),  MO(_ME), KC_LEFT, KC_DOWN, KC_RGHT),
+
+  /* Keymap _FL: Function Layer
+   */
+[_FL] = KEYMAP(
+  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_DEL,           KC_HOME, \
+  _______, _______, _______,_______,_______,_______,_______,_______,KC_PSCR,KC_SLCK, KC_PAUS,  _______,  _______,  KC_PSCR,                KC_END,  \
+  _______, _______, MO(_CL),_______,_______,_______,_______,_______,_______,_______, _______,  _______,  _______,  _______,                           \
+  _______, _______, _______,_______,_______,_______,_______,_______,_______,_______, _______,  _______,  _______,  _______,          KC_PGUP,         \
+  _______, _______, _______, _______,        _______,_______,                        _______,  _______,  MO(_FL),  MO(_ME), KC_HOME, KC_PGDN, KC_END),
+
+/* Keymap _FL: Function Layer
+   */
+[_ME] = KEYMAP(
+  _______, _______, _______,_______,_______,_______,_______,_______,_______,_______, _______,  _______, _______,  _______,  KC_MUTE,          KC_VOLU, \
+  _______, _______, _______,_______,_______,_______,_______,_______,KC_PSCR,KC_SLCK, KC_PAUS,  _______,  _______,  _______,                   KC_VOLD, \
+  _______, _______, MO(_CL),_______,_______,_______,_______,_______,_______,_______, _______,  _______,  _______,  _______,                           \
+  _______, _______, _______,_______,_______,_______,_______,_______,_______,_______, _______,  _______, _______ ,  _______,          _______,         \
+  _______, _______, _______, _______,        _______,_______,                        _______,  _______,  MO(_FL),  MO(_ME), KC_MPRV, KC_MPLY, KC_MNXT),
+
+
+  /* Keymap _CL: Control layer
+   */
+[_CL] = KEYMAP(
+  _______, _______, _______,_______,_______,_______,_______,_______,_______,_______, _______,  _______,  _______,  _______, RGB_TOG,             RGB_VAI, \
+  _______, _______, _______,_______,RESET,  _______,_______,_______,_______,_______, _______,  _______,  _______,  _______,                   RGB_VAD, \
+  _______, _______, MO(_CL),_______,_______,_______,_______,_______,_______,_______, _______,  _______,  _______,  _______,                         \
+  MO(_FL), _______, _______,_______,_______,_______,_______,_______,_______,_______, _______,  _______,  MO(_FL),  _______,          RGB_SAI,          \
+  _______, _______, _______,_______,        RGB_MOD,   RGB_MOD,                            _______,  _______,  _______,  _______, RGB_HUD,    RGB_SAD,    RGB_HUI),
+};
+
+/* This is a list of user defined functions. F(N) corresponds to item N
+   of this list.
+ */
+const uint16_t PROGMEM fn_actions[] = {
+  [0] = ACTION_FUNCTION(0),  // Calls action_function()
+  [1] = ACTION_MODS_TAP_KEY(MOD_LCTL, KC_ESC),
+};
+
+void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
+  static uint8_t mods_pressed;
+  static bool mod_flag;
+
+  switch (id) {
+    case 0:
+      /* Handle the combined Grave/Esc key
+       */
+      mods_pressed = get_mods()&GRAVE_MODS; // Check to see what mods are pressed
+
+      if (record->event.pressed) {
+        /* The key is being pressed.
+         */
+        if (mods_pressed) {
+          mod_flag = true;
+          add_key(KC_GRV);
+          send_keyboard_report();
+        } else {
+          add_key(KC_ESC);
+          send_keyboard_report();
+        }
+      } else {
+        /* The key is being released.
+         */
+        if (mod_flag) {
+          mod_flag = false;
+          del_key(KC_GRV);
+          send_keyboard_report();
+        } else {
+          del_key(KC_ESC);
+          send_keyboard_report();
+        }
+      }
+      break;
+    case 1:
+      if(record->event.pressed) {
+        del_key(KC_ESC);
+      }
+    break;
+  }
+}

keyboards/clueboard/keymaps/serubin/readme.md

@@ -0,0 +1,23 @@
+```
+ ___     _____ _            _                         _     __    __ _   __
+|__ \   / ____| |          | |                       | |   / /   / /(_) / /
+ ||) | | |    | |_   _  ___| |__   ___   __ _ _ __ __| |  / /_  / /_   / /
+ |/ /  | |    | | | | |/ _ \ '_ \ / _ \ / _` | '__/ _` | | '_ \| '_ \ / /
+ |_|   | |____| | |_| |  __/ |_) | (_) | (_| | | | (_| | | (_) | (_) / / _
+ (_)    \_____|_|\__,_|\___|_.__/ \___/ \__,_|_|  \__,_|  \___/ \___/_/ (_)
+```
+
+# Serubin's Clueboard Layout
+
+This is the layout based on the clueboard default, modified for development on Mac, PC, and Windows. This layout also handles media and volume keys on all the previously listed platforms. Most importantly, Capslock has been replaced by a dual function Esc/Ctrl key. This is particularly handy for use in Vim. 
+
+#### Base Layer
+![Base Layout Image](layout-base.png)
+
+#### Fn Layer
+![Fn Layout Image](layout-fn.png)
+
+#### Media Layer
+![Media Layer Image](layout-media.png)
+
+

keyboards/clueboard/keymaps/shift_fn/keymap.c

@@ -19,8 +19,8 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   F(0),    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_GRV,  KC_BSPC,          KC_PGUP, \
   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_PGDN, \
   KC_CAPS, KC_A,    KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,    KC_SCLN,  KC_QUOT,  KC_NUHS,  KC_ENT,                             \
-  KC_LSFT, KC_NUBS, KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM, KC_DOT,   KC_SLSH,  KC_RO,    KC_RSFT,          KC_UP,            \
+  MO(_FL), KC_NUBS, KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM, KC_DOT,   KC_SLSH,  KC_RO,    KC_RSFT,          KC_UP,            \
-  KC_LCTL, KC_LGUI, KC_LALT, KC_MHEN,          KC_SPC,KC_SPC,                        KC_HENK,  KC_RALT,  KC_RCTL,  MO(_FL), KC_LEFT, KC_DOWN, KC_RGHT),
+  KC_LCTL, KC_LGUI, KC_LALT,KC_MHEN,          KC_SPC, KC_SPC,                        KC_HENK,  KC_RALT,  KC_RGUI,  KC_RCTL,  KC_LEFT, KC_DOWN, KC_RGHT),
 
   /* Keymap _FL: Function Layer
    */
@@ -29,7 +29,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   S(KC_TAB), S(KC_Q),   S(KC_W),S(KC_E),S(KC_R),S(KC_T),  S(KC_Y),  S(KC_U),S(KC_I),S(KC_O),   S(KC_P),   S(KC_LBRC),S(KC_RBRC),S(KC_BSLS),                  S(KC_PGDN), \
   S(KC_LCTL),S(KC_A),   MO(_CL),S(KC_D),S(KC_F),S(KC_G),  S(KC_H),  S(KC_J),S(KC_K),S(KC_L),   S(KC_SCLN),S(KC_QUOT),S(KC_NUHS),S(KC_ENT),                               \
   MO(_FL),   S(KC_NUBS),S(KC_Z),S(KC_X),S(KC_C),S(KC_V),  S(KC_B),  S(KC_N),S(KC_M),S(KC_COMM),S(KC_DOT), S(KC_SLSH),S(KC_RO),  KC_RSFT,           KC_PGUP,             \
-  KC_LCTL,   KC_LALT,   KC_LGUI,MO(_FL),        S(KC_SPC),S(KC_SPC),                           MO(_FL),   KC_RGUI,   KC_RALT,   KC_RCTL,   KC_HOME, KC_PGDN, KC_END),
+  KC_LCTL,   KC_LALT,   KC_LGUI,KC_MHEN,        S(KC_SPC),S(KC_SPC),                           KC_HENK,   KC_RGUI,   KC_RALT,   KC_RCTL,   KC_HOME, KC_PGDN, KC_END),
 
   /* Keymap _CL: Control layer
    */

keyboards/clueboard/keymaps/skully/keymap.c

@@ -16,33 +16,36 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   /* Keymap _BL: Base Layer (Default Layer)
    */
 [_BL] = KEYMAP(
-  F(0),   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_GRV,  KC_BSPC,          KC_PGUP, \
+  F(0),    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_GRV,  KC_BSPC,          KC_PGUP, \
-  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_PGDN, \
+  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_PGDN, \
-  KC_LCTL,KC_A,   KC_S,   KC_D,   KC_F,  KC_G,   KC_H,   KC_J,   KC_K,   KC_L,    KC_SCLN,  KC_QUOT,  KC_NUHS,  KC_ENT,                             \
+  KC_LCTL, KC_A,    KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,    KC_SCLN,  KC_QUOT,  KC_NUHS,  KC_ENT,                             \
-  KC_LSFT,KC_NUBS,KC_Z,   KC_X,   KC_C,  KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM, KC_DOT,   KC_SLSH,  KC_RO,    KC_RSFT,          KC_UP,            \
+  MO(_FL), KC_NUBS, KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM, KC_DOT,   KC_SLSH,  KC_RO,    KC_RSFT,          KC_UP,            \
-  KC_LCTL,KC_LALT,KC_LGUI,MO(_FL),       KC_SPC, KC_SPC,                          MO(_FL),  KC_RGUI,  KC_RCTL,  MO(_FL), KC_LEFT, KC_DOWN, KC_RGHT),
+  KC_LCTL, KC_LALT, KC_LGUI,KC_MHEN,          KC_SPC, KC_SPC,                        KC_HENK,  KC_RGUI,  KC_RALT,  KC_RCTL,  KC_LEFT, KC_DOWN, KC_RGHT),
 
   /* Keymap _FL: Function Layer
    */
 [_FL] = KEYMAP(
-  KC_GRV, KC_F1,  KC_F2,  KC_F3,  KC_F4,  KC_F5,  KC_F6,  KC_F7,  KC_F8,  KC_F9,  KC_F10, KC_F11, KC_F12, _______,KC_DEL,         BL_STEP, \
+  S(KC_GRV), KC_F1,     KC_F2,  KC_F3,  KC_F4,  KC_F5,    KC_F6,    KC_F7,  KC_F8,  KC_F9,     KC_F10,    KC_F11,    KC_F12,    S(KC_GRV), KC_DEL,           BL_STEP,    \
-  _______,_______,_______,_______,_______,_______,_______,_______,KC_PSCR,KC_SLCK,KC_PAUS,_______,_______,_______,                _______, \
+  S(KC_TAB), S(KC_Q),   S(KC_W),S(KC_E),S(KC_R),S(KC_T),  S(KC_Y),  S(KC_U),S(KC_I),S(KC_O),   S(KC_P),   S(KC_LBRC),S(KC_RBRC),S(KC_BSLS),                  S(KC_PGDN), \
-  _______,_______,MO(_CL),_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,                         \
+  S(KC_LCTL),S(KC_A),   MO(_CL),S(KC_D),S(KC_F),S(KC_G),  S(KC_H),  S(KC_J),S(KC_K),S(KC_L),   S(KC_SCLN),S(KC_QUOT),S(KC_NUHS),S(KC_ENT),                               \
-  _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,        KC_PGUP,         \
+  MO(_FL),   S(KC_NUBS),S(KC_Z),S(KC_X),S(KC_C),S(KC_V),  S(KC_B),  S(KC_N),S(KC_M),S(KC_COMM),S(KC_DOT), S(KC_SLSH),S(KC_RO),  KC_RSFT,           KC_PGUP,             \
-  _______,_______,_______,MO(_FL),        _______,_______,                        MO(_FL),_______,_______,MO(_FL),KC_HOME,KC_PGDN,KC_END),
+  KC_LCTL,   KC_LALT,   KC_LGUI,KC_MHEN,        S(KC_SPC),S(KC_SPC),                           KC_HENK,   KC_RGUI,   KC_RALT,   KC_RCTL,   KC_HOME, KC_PGDN, KC_END),
 
   /* Keymap _CL: Control layer
    */
 [_CL] = KEYMAP(
-  _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,          _______, \
+  _______, _______, _______,_______,_______,_______,_______,_______,_______,_______, _______,  _______,  _______,  _______, RGB_TOG,              RGB_VAI, \
-  _______,_______,_______,_______,RESET,  _______,_______,_______,_______,_______,_______,_______,_______,_______,                  _______, \
+  _______, _______, _______,_______,RESET,  _______,_______,_______,_______,_______, _______,  _______,  _______,  _______,                       RGB_VAD, \
-  _______,_______,MO(_CL),_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,                           \
+  _______, _______, MO(_CL),_______,_______,_______,_______,_______,_______,_______, _______,  _______,  _______,  _______,                                \
-  _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,         _______,          \
+  MO(_FL), _______, _______,_______,_______,_______,_______,_______,_______,_______, _______,  _______,  _______,  MO(_FL),               RGB_SAI,         \
-  _______,_______,_______,_______,        _______,_______,                        _______,_______,_______,MO(_FL),_______, _______, _______),
+  _______, _______, _______,_______,        RGB_MOD,RGB_MOD,                            _______,  _______,  _______,  _______, RGB_HUD,RGB_SAD,RGB_HUI),
 };
 
+/* This is a list of user defined functions. F(N) corresponds to item N
+   of this list.
+ */
 const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(0),
+  [0] = ACTION_FUNCTION(0),  // Calls action_function()
 };
 
 void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {

keyboards/clueboard/keymaps/xyverz/Makefile

@@ -0,0 +1,49 @@
+#----------------------------------------------------------------------------
+# On command line:
+#
+# make all = Make software.
+#
+# make clean = Clean out built project files.
+#
+# make coff = Convert ELF to AVR COFF.
+#
+# make extcoff = Convert ELF to AVR Extended COFF.
+#
+# make program = Download the hex file to the device.
+#                Please customize your programmer settings(PROGRAM_CMD)
+#
+# make teensy = Download the hex file to the device, using teensy_loader_cli.
+#               (must have teensy_loader_cli installed).
+#
+# make dfu = Download the hex file to the device, using dfu-programmer (must
+#            have dfu-programmer installed).
+#
+# make flip = Download the hex file to the device, using Atmel FLIP (must
+#             have Atmel FLIP installed).
+#
+# make dfu-ee = Download the eeprom file to the device, using dfu-programmer
+#               (must have dfu-programmer installed).
+#
+# make flip-ee = Download the eeprom file to the device, using Atmel FLIP
+#                (must have Atmel FLIP installed).
+#
+# make debug = Start either simulavr or avarice as specified for debugging,
+#              with avr-gdb or avr-insight as the front end for debugging.
+#
+# make filename.s = Just compile filename.c into the assembler code only.
+#
+# make filename.i = Create a preprocessed source file for use in submitting
+#                   bug reports to the GCC project.
+#
+# To rebuild project do "make clean" then "make all".
+#----------------------------------------------------------------------------
+
+# Build Options
+#   change to "no" to disable the options, or define them in the makefile.mk in 
+#   the appropriate keymap folder that will get included automatically
+#
+RGBLIGHT_ENABLE = yes        # Enable WS2812 RGB underlight.  Do not enable this with audio at the same time.
+
+ifndef QUANTUM_DIR
+	include ../../../../Makefile
+endif

keyboards/clueboard/keymaps/xyverz/keymap.c

@@ -0,0 +1,111 @@
+// Xyverz' keymap.
+// It's based on the default keymap, but Dvorak!
+
+#include "clueboard.h"
+
+// Used for SHIFT_ESC
+#define MODS_CTRL_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+#define _BL 0
+#define _FL 1
+#define _RS 2
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  /* Keymap _BL: (Base Layer) Default Layer
+   * ,--------------------------------------------------------------------------.  ,----.
+   * |Esc~|   1|   2|   3|   4|   5|   6|   7|   8|   9|   0|   [|   ]|   \|  BS|  |PGUP|
+   * |--------------------------------------------------------------------------|  |----|
+   * |   Tab|   '|   ,|   .|   P|   Y|   F|   G|   C|   R|   L|   /|   =|      \|  |PGDN|
+   * |--------------------------------------------------------------------------|  `----'
+   * |_FL/Caps|   A|   O|   E|   U|   I|   H|   D|   H|   T|   N|   S|  - |  Ent|
+   * |-----------------------------------------------------------------------------.
+   * |Shift|  BS|   ;|   Q|   J|   K|   X|   B|   M|   W|   V|   Z|   BS|Shift|  UP|
+   * |------------------------------------------------------------------------|----|----.
+   * | Ctrl|  Gui|  Alt| MHen|    Space|    Space|  Hen|  Alt| Ctrl|  _FL|LEFT|DOWN|RGHT|
+   * `----------------------------------------------------------------------------------'
+   */
+[_BL] = KEYMAP(
+  F(0),    KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_LBRC, KC_RBRC, KC_GRV,  KC_BSPC,          KC_PGUP, \
+  KC_TAB,  KC_QUOT, KC_COMM, KC_DOT,  KC_P,    KC_Y,    KC_F,    KC_G,    KC_C,    KC_R,    KC_L,    KC_SLSH, KC_EQL,  KC_BSLS,                   KC_PGDN, \
+  LT(_FL, KC_CAPS), KC_A,    KC_O,    KC_E,    KC_U,    KC_I,    KC_D,    KC_H,    KC_T,    KC_N,    KC_S,    KC_MINS, KC_NUHS, KC_ENT,                    \
+  KC_LSFT, KC_RO,   KC_SCLN, KC_Q,    KC_J,    KC_K,    KC_X,    KC_B,    KC_M,    KC_W,    KC_V,    KC_Z,    KC_SLSH, KC_RSFT,          KC_UP,            \
+  KC_LCTL, KC_LALT, KC_LGUI, KC_MHEN,          KC_SPC,  KC_SPC,                             KC_HENK, KC_RGUI, KC_RCTL, MO(_FL), KC_LEFT, KC_DOWN, KC_RGHT),
+
+  /* Keymap _FL: Function Layer
+   * ,--------------------------------------------------------------------------.  ,----.
+   * |   `|  F1|  F2|  F3|  F4|  F5|  F6|  F7|  F8|  F9| F10| F11| F12|    | Del|  |BLIN|
+   * |--------------------------------------------------------------------------|  |----|
+   * |      |    |    |    |    |    |    |    |PScr|SLck|Paus|    |    |       |  |BLDE|
+   * |--------------------------------------------------------------------------|  `----'
+   * |       |    | _RS|    |    |    |    |    |    |    |    |    |     |     |
+   * |-----------------------------------------------------------------------------.
+   * |     |    |    |    |    |    |    |    |    |    |    |    |     |     |PGUP|
+   * |------------------------------------------------------------------------|----|----.
+   * |     |     |     |     |         |         |     |     |     |  _FL|HOME|PGDN| END|
+   * `----------------------------------------------------------------------------------'
+   */
+[_FL] = KEYMAP(
+  KC_GRV,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_TRNS, KC_DEL,           BL_STEP, \
+  KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PSCR, KC_SLCK, KC_PAUS, KC_TRNS, KC_TRNS, KC_TRNS,                   KC_TRNS, \
+  KC_TRNS, KC_TRNS, MO(_RS), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,                            \
+  KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,          KC_PGUP,          \
+  KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,          KC_TRNS, KC_TRNS,                            KC_TRNS, KC_TRNS, KC_TRNS, MO(_FL), KC_HOME, KC_PGDN, KC_END),
+
+  /* Keymap _RS: Reset layer
+   * ,--------------------------------------------------------------------------.  ,----.
+   * |    |    |    |    |    |    |    |    |    |    |    |    |    |    | RGB|  |VAL+|
+   * |--------------------------------------------------------------------------|  |----|
+   * |      |    |    |    |RESET|   |    |    |    |    |    |    |    |       |  |VAL-|
+   * |--------------------------------------------------------------------------|  `----'
+   * |       |    | _RS|    |    |    |    |    |    |    |    |    |     |     |
+   * |-----------------------------------------------------------------------------.
+   * |     |    |    |    |    |    |    |    |    |    |    |    |     |     |SAT+|
+   * |------------------------------------------------------------------------|----|----.
+   * |     |     |     |     |         |         |     |     |     |  _FL|HUE-|SAT-|HUE+|
+   * `----------------------------------------------------------------------------------'
+   */
+[_RS] = KEYMAP(
+  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, RGB_TOG,          RGB_VAI, \
+  KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, RESET,   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,                   RGB_VAD, \
+  KC_TRNS, KC_TRNS, MO(_RS), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,                            \
+  MO(_FL), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(_FL),          RGB_SAI,          \
+  KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,          RGB_MOD, RGB_MOD,                            KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, RGB_HUD, RGB_SAD, RGB_HUI),
+};
+
+enum function_id {
+    SHIFT_ESC,
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+  [0]  = ACTION_FUNCTION(SHIFT_ESC),
+};
+
+void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
+  static uint8_t shift_esc_shift_mask;
+  switch (id) {
+    case SHIFT_ESC:
+      shift_esc_shift_mask = get_mods()&MODS_CTRL_MASK;
+      if (record->event.pressed) {
+        if (shift_esc_shift_mask) {
+          add_key(KC_GRV);
+          send_keyboard_report();
+        } else {
+          add_key(KC_ESC);
+          send_keyboard_report();
+        }
+      } else {
+        if (shift_esc_shift_mask) {
+          del_key(KC_GRV);
+          send_keyboard_report();
+        } else {
+          del_key(KC_ESC);
+          send_keyboard_report();
+        }
+      }
+      break;
+  }
+}

keyboards/ergodox/config.h

@@ -34,4 +34,4 @@
 #endif
 
 
-#endif /* KEYBOARDS_ERGODOX_CONFIG_H_ */
+#endif /* KEYBOARDS_ERGODOX_CONFIG_H_ */

keyboards/ergodox/ez/config.h

@@ -49,6 +49,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define RGBLIGHT_SAT_STEP 255
 #define RGBLIGHT_VAL_STEP 12
 
+/* fix space cadet rollover issue */
+#define DISABLE_SPACE_CADET_ROLLOVER
+
 // #define RGB_MIDI
 #define RGBW_BB_TWI
 

keyboards/ergodox/ez/rules.mk

@@ -74,7 +74,3 @@ OPT_DEFS += -DBOOTLOADER_SIZE=512
 SLEEP_LED_ENABLE = no
 API_SYSEX_ENABLE ?= no
 RGBLIGHT_ENABLE ?= yes
-
-ifndef QUANTUM_DIR
-	include ../../../Makefile
-endif

keyboards/ergodox/infinity/Makefile

@@ -1,3 +1,3 @@
 ifndef MAKEFILE_INCLUDED
 	include ../../../Makefile
-endif
+endif

keyboards/ergodox/infinity/animations.c

@@ -0,0 +1,107 @@
+/* Copyright 2017 Fred Sundvik
+ *
+ * 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/>.
+ */
+
+#if defined(VISUALIZER_ENABLE)
+
+#include "animations.h"
+#include "visualizer.h"
+#ifdef LCD_ENABLE
+#include "lcd_keyframes.h"
+#endif
+#ifdef LCD_BACKLIGHT_ENABLE
+#include "lcd_backlight_keyframes.h"
+#endif
+
+#ifdef LED_ENABLE
+#include "led_keyframes.h"
+#endif
+
+#include "visualizer_keyframes.h"
+
+
+#if defined(LCD_ENABLE) && defined(LCD_BACKLIGHT_ENABLE)
+
+// Don't worry, if the startup animation is long, you can use the keyboard like normal
+// during that time
+keyframe_animation_t default_startup_animation = {
+    .num_frames = 4,
+    .loop = false,
+    .frame_lengths = {0, 0, 0, gfxMillisecondsToTicks(5000), 0},
+    .frame_functions = {
+            lcd_keyframe_enable,
+            backlight_keyframe_enable,
+            lcd_keyframe_draw_logo,
+            backlight_keyframe_animate_color,
+    },
+};
+
+keyframe_animation_t default_suspend_animation = {
+    .num_frames = 4,
+    .loop = false,
+    .frame_lengths = {0, gfxMillisecondsToTicks(1000), 0, 0},
+    .frame_functions = {
+            lcd_keyframe_display_layer_text,
+            backlight_keyframe_animate_color,
+            lcd_keyframe_disable,
+            backlight_keyframe_disable,
+    },
+};
+#endif
+
+#if defined(LED_ENABLE)
+#define CROSSFADE_TIME 1000
+#define GRADIENT_TIME 3000
+
+keyframe_animation_t led_test_animation = {
+    .num_frames = 14,
+    .loop = true,
+    .frame_lengths = {
+        gfxMillisecondsToTicks(1000), // fade in
+        gfxMillisecondsToTicks(1000), // no op (leds on)
+        gfxMillisecondsToTicks(1000), // fade out
+        gfxMillisecondsToTicks(CROSSFADE_TIME), // crossfade
+        gfxMillisecondsToTicks(GRADIENT_TIME), // left to rigt (outside in)
+        gfxMillisecondsToTicks(CROSSFADE_TIME), // crossfade
+        gfxMillisecondsToTicks(GRADIENT_TIME), // top_to_bottom
+        0,           // mirror leds
+        gfxMillisecondsToTicks(CROSSFADE_TIME), // crossfade
+        gfxMillisecondsToTicks(GRADIENT_TIME), // left_to_right (mirrored, so inside out)
+        gfxMillisecondsToTicks(CROSSFADE_TIME), // crossfade
+        gfxMillisecondsToTicks(GRADIENT_TIME), // top_to_bottom
+        0,           // normal leds
+        gfxMillisecondsToTicks(CROSSFADE_TIME), // crossfade
+
+    },
+    .frame_functions = {
+        led_keyframe_fade_in_all,
+        keyframe_no_operation,
+        led_keyframe_fade_out_all,
+        led_keyframe_crossfade,
+        led_keyframe_left_to_right_gradient,
+        led_keyframe_crossfade,
+        led_keyframe_top_to_bottom_gradient,
+        led_keyframe_mirror_orientation,
+        led_keyframe_crossfade,
+        led_keyframe_left_to_right_gradient,
+        led_keyframe_crossfade,
+        led_keyframe_top_to_bottom_gradient,
+        led_keyframe_normal_orientation,
+        led_keyframe_crossfade,
+    },
+};
+#endif
+
+#endif

keyboards/ergodox/infinity/animations.h

@@ -0,0 +1,30 @@
+/* Copyright 2017 Fred Sundvik
+ *
+ * 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 KEYBOARDS_ERGODOX_INFINITY_ANIMATIONS_H_
+#define KEYBOARDS_ERGODOX_INFINITY_ANIMATIONS_H_
+
+#include "visualizer.h"
+
+// You can use these default animations, but of course you can also write your own custom ones instead
+extern keyframe_animation_t default_startup_animation;
+extern keyframe_animation_t default_suspend_animation;
+
+// An animation for testing and demonstrating the led support, should probably not be used for real world
+// cases
+extern keyframe_animation_t led_test_animation;
+
+#endif /* KEYBOARDS_ERGODOX_INFINITY_ANIMATIONS_H_ */

keyboards/ergodox/infinity/config.h

@@ -40,7 +40,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* number of backlight levels */
 #define BACKLIGHT_LEVELS 3
 
-#define LED_BRIGHTNESS_LO       15
+#define LED_BRIGHTNESS_LO       100
 #define LED_BRIGHTNESS_HI       255
 
 /* define if matrix has ghost */
@@ -54,6 +54,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // The visualizer needs gfx thread priorities
 #define VISUALIZER_THREAD_PRIORITY (NORMAL_PRIORITY - 2)
 
+#define VISUALIZER_USER_DATA_SIZE 16
+
 /*
  * Feature disable options
  *  These options are also useful to firmware size reduction.

keyboards/ergodox/infinity/drivers/gdisp/IS31FL3731C/gdisp_IS31FL3731C.c

@@ -25,6 +25,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "board_IS31FL3731C.h"
 
+
+// Can't include led_tables from here
+extern const uint8_t CIE1931_CURVE[];
+
 /*===========================================================================*/
 /* Driver local definitions.                                                 */
 /*===========================================================================*/
@@ -100,37 +104,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #define IS31
 
-//Generated by http://jared.geek.nz/2013/feb/linear-led-pwm
-const unsigned char cie[256] = {
-    0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
-    2, 2, 2, 3, 3, 3, 3, 3, 3, 3,
-    3, 4, 4, 4, 4, 4, 4, 5, 5, 5,
-    5, 5, 6, 6, 6, 6, 6, 7, 7, 7,
-    7, 8, 8, 8, 8, 9, 9, 9, 10, 10,
-    10, 10, 11, 11, 11, 12, 12, 12, 13, 13,
-    13, 14, 14, 15, 15, 15, 16, 16, 17, 17,
-    17, 18, 18, 19, 19, 20, 20, 21, 21, 22,
-    22, 23, 23, 24, 24, 25, 25, 26, 26, 27,
-    28, 28, 29, 29, 30, 31, 31, 32, 32, 33,
-    34, 34, 35, 36, 37, 37, 38, 39, 39, 40,
-    41, 42, 43, 43, 44, 45, 46, 47, 47, 48,
-    49, 50, 51, 52, 53, 54, 54, 55, 56, 57,
-    58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
-    68, 70, 71, 72, 73, 74, 75, 76, 77, 79,
-    80, 81, 82, 83, 85, 86, 87, 88, 90, 91,
-    92, 94, 95, 96, 98, 99, 100, 102, 103, 105,
-    106, 108, 109, 110, 112, 113, 115, 116, 118, 120,
-    121, 123, 124, 126, 128, 129, 131, 132, 134, 136,
-    138, 139, 141, 143, 145, 146, 148, 150, 152, 154,
-    155, 157, 159, 161, 163, 165, 167, 169, 171, 173,
-    175, 177, 179, 181, 183, 185, 187, 189, 191, 193,
-    196, 198, 200, 202, 204, 207, 209, 211, 214, 216,
-    218, 220, 223, 225, 228, 230, 232, 235, 237, 240,
-    242, 245, 247, 250, 252, 255,
-};
-
-
 /*===========================================================================*/
 /* Driver local functions.                                                   */
 /*===========================================================================*/
@@ -231,7 +204,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		uint8_t* src = PRIV(g)->frame_buffer;
 		for (int y=0;y<GDISP_SCREEN_HEIGHT;y++) {
 		    for (int x=0;x<GDISP_SCREEN_WIDTH;x++) {
-		        PRIV(g)->write_buffer[get_led_address(g, x, y)]=cie[*src];
+		        PRIV(g)->write_buffer[get_led_address(g, x, y)]=CIE1931_CURVE[*src];
 		        ++src;
 		    }
 		}

keyboards/ergodox/infinity/drivers/gdisp/st7565ergodox/board_ST7565.h

@@ -8,8 +8,6 @@
 #ifndef _GDISP_LLD_BOARD_H
 #define _GDISP_LLD_BOARD_H
 
-#include "print.h"
-
 #define ST7565_LCD_BIAS         ST7565_LCD_BIAS_9 // actually 6
 #define ST7565_ADC              ST7565_ADC_NORMAL
 #define ST7565_COM_SCAN         ST7565_COM_SCAN_DEC
@@ -39,35 +37,49 @@
 // MSB First
 // CLK Low by default
 static const SPIConfig spi1config = {
-	NULL,
+   // Operation complete callback or @p NULL.
-	/* HW dependent part.*/
+  .end_cb = NULL,
-	ST7565_GPIOPORT,
+   //The chip select line port - when not using pcs.
-    ST7565_SS_PIN,
+  .ssport = ST7565_GPIOPORT,
-    SPIx_CTARn_FMSZ(7)
+   // brief The chip select line pad number - when not using pcs.
-    | SPIx_CTARn_ASC(7)
+  .sspad=ST7565_SS_PIN,
-    | SPIx_CTARn_DT(7)
+   // SPI initialization data.
-    | SPIx_CTARn_CSSCK(7)
+  .tar0 =
-    | SPIx_CTARn_PBR(0)
+    SPIx_CTARn_FMSZ(7) // Frame size = 8 bytes
-    | SPIx_CTARn_BR(7)
+    | SPIx_CTARn_ASC(1) // After SCK Delay Scaler (min 50 ns) = 55.56ns
-	//SPI_CR1_BR_0
+    | SPIx_CTARn_DT(0) // Delay After Transfer Scaler (no minimum)= 27.78ns
+    | SPIx_CTARn_CSSCK(0) // PCS to SCK Delay Scaler (min 20 ns) = 27.78ns
+    | SPIx_CTARn_PBR(0) // Baud Rate Prescaler = 2
+    | SPIx_CTARn_BR(0) // Baud rate (min 50ns) = 55.56ns
 };
 
-static bool_t st7565_is_data_mode = 1;
+static GFXINLINE void acquire_bus(GDisplay *g) {
+    (void) g;
+    // Only the LCD is using the SPI bus, so no need to acquire
+    // spiAcquireBus(&SPID1);
+    spiSelect(&SPID1);
+}
+
+static GFXINLINE void release_bus(GDisplay *g) {
+    (void) g;
+    // Only the LCD is using the SPI bus, so no need to release
+    //spiReleaseBus(&SPID1);
+    spiUnselect(&SPID1);
+}
 
 static GFXINLINE void init_board(GDisplay *g) {
     (void) g;
     palSetPadModeNamed(A0, PAL_MODE_OUTPUT_PUSHPULL);
     palSetPad(ST7565_GPIOPORT, ST7565_A0_PIN);
-    st7565_is_data_mode = 1;
     palSetPadModeNamed(RST, PAL_MODE_OUTPUT_PUSHPULL);
     palSetPad(ST7565_GPIOPORT, ST7565_RST_PIN);
     palSetPadModeRaw(MOSI, ST7565_SPI_MODE);
     palSetPadModeRaw(SLCK, ST7565_SPI_MODE);
-    palSetPadModeRaw(SS, ST7565_SPI_MODE);
+    palSetPadModeNamed(SS, PAL_MODE_OUTPUT_PUSHPULL);
 
     spiInit();
     spiStart(&SPID1, &spi1config);
-    spiSelect(&SPID1);
+    release_bus(g);
 }
 
 static GFXINLINE void post_init_board(GDisplay *g) {
@@ -84,43 +96,17 @@ static GFXINLINE void setpin_reset(GDisplay *g, bool_t state) {
     }
 }
 
-static GFXINLINE void acquire_bus(GDisplay *g) {
+static GFXINLINE void enter_data_mode(GDisplay *g) {
-    (void) g;
+    palSetPad(ST7565_GPIOPORT, ST7565_A0_PIN);
-    // Only the LCD is using the SPI bus, so no need to acquire
-    // spiAcquireBus(&SPID1);
 }
 
-static GFXINLINE void release_bus(GDisplay *g) {
+static GFXINLINE void enter_cmd_mode(GDisplay *g) {
-    (void) g;
+    palClearPad(ST7565_GPIOPORT, ST7565_A0_PIN);
-    // Only the LCD is using the SPI bus, so no need to release
-    //spiReleaseBus(&SPID1);
 }
 
-static GFXINLINE void write_cmd(GDisplay *g, uint8_t cmd) {
-	(void) g;
-	if (st7565_is_data_mode) {
-	    // The sleeps need to be at lest 10 vs 25 ns respectively
-	    // So let's sleep two ticks, one tick might not be enough
-	    // if we are at the end of the tick
-	    chThdSleep(2);
-        palClearPad(ST7565_GPIOPORT, ST7565_A0_PIN);
-        chThdSleep(2);
-        st7565_is_data_mode = 0;
-	}
-	spiSend(&SPID1, 1, &cmd);
-}
 
 static GFXINLINE void write_data(GDisplay *g, uint8_t* data, uint16_t length) {
 	(void) g;
-	if (!st7565_is_data_mode) {
-	    // The sleeps need to be at lest 10 vs 25 ns respectively
-	    // So let's sleep two ticks, one tick might not be enough
-	    // if we are at the end of the tick
-	    chThdSleep(2);
-        palSetPad(ST7565_GPIOPORT, ST7565_A0_PIN);
-	    chThdSleep(2);
-        st7565_is_data_mode = 1;
-	}
 	spiSend(&SPID1, length, data);
 }
 

keyboards/ergodox/infinity/drivers/gdisp/st7565ergodox/gdisp_lld_ST7565.c

@@ -20,16 +20,16 @@
 /*===========================================================================*/
 
 #ifndef GDISP_SCREEN_HEIGHT
-	#define GDISP_SCREEN_HEIGHT		32
+#define GDISP_SCREEN_HEIGHT		32
 #endif
 #ifndef GDISP_SCREEN_WIDTH
-	#define GDISP_SCREEN_WIDTH		128
+#define GDISP_SCREEN_WIDTH		128
 #endif
 #ifndef GDISP_INITIAL_CONTRAST
-	#define GDISP_INITIAL_CONTRAST	0
+#define GDISP_INITIAL_CONTRAST	35
 #endif
 #ifndef GDISP_INITIAL_BACKLIGHT
-	#define GDISP_INITIAL_BACKLIGHT	100
+#define GDISP_INITIAL_BACKLIGHT	100
 #endif
 
 #define GDISP_FLG_NEEDFLUSH			(GDISP_FLG_DRIVER<<0)
@@ -40,16 +40,16 @@
 /* Driver config defaults for backward compatibility.               	     */
 /*===========================================================================*/
 #ifndef ST7565_LCD_BIAS
-  #define ST7565_LCD_BIAS         ST7565_LCD_BIAS_7
+#define ST7565_LCD_BIAS         ST7565_LCD_BIAS_7
 #endif
 #ifndef ST7565_ADC
-  #define ST7565_ADC              ST7565_ADC_NORMAL
+#define ST7565_ADC              ST7565_ADC_NORMAL
 #endif
 #ifndef ST7565_COM_SCAN
-  #define ST7565_COM_SCAN         ST7565_COM_SCAN_INC
+#define ST7565_COM_SCAN         ST7565_COM_SCAN_INC
 #endif
 #ifndef ST7565_PAGE_ORDER
-  #define ST7565_PAGE_ORDER       0,1,2,3
+#define ST7565_PAGE_ORDER       0,1,2,3
 #endif
 
 /*===========================================================================*/
@@ -58,12 +58,24 @@
 
 typedef struct{
     bool_t buffer2;
+    uint8_t data_pos;
+    uint8_t data[16];
     uint8_t ram[GDISP_SCREEN_HEIGHT * GDISP_SCREEN_WIDTH / 8];
 }PrivData;
 
 // Some common routines and macros
 #define PRIV(g)                         ((PrivData*)g->priv)
 #define RAM(g)							(PRIV(g)->ram)
+
+static GFXINLINE void write_cmd(GDisplay* g, uint8_t cmd) {
+    PRIV(g)->data[PRIV(g)->data_pos++] = cmd;
+}
+
+static GFXINLINE void flush_cmd(GDisplay* g) {
+    write_data(g, PRIV(g)->data, PRIV(g)->data_pos);
+    PRIV(g)->data_pos = 0;
+}
+
 #define write_cmd2(g, cmd1, cmd2)		{ write_cmd(g, cmd1); write_cmd(g, cmd2); }
 #define write_cmd3(g, cmd1, cmd2, cmd3)	{ write_cmd(g, cmd1); write_cmd(g, cmd2); write_cmd(g, cmd3); }
 
@@ -86,207 +98,232 @@ typedef struct{
  */
 
 LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
-	// The private area is the display surface.
+    // The private area is the display surface.
-	g->priv = gfxAlloc(sizeof(PrivData));
+    g->priv = gfxAlloc(sizeof(PrivData));
-	PRIV(g)->buffer2 = false;
+    PRIV(g)->buffer2 = false;
+    PRIV(g)->data_pos = 0;
 
-	// Initialise the board interface
+    // Initialise the board interface
-	init_board(g);
+    init_board(g);
 
-	// Hardware reset
+    // Hardware reset
-	setpin_reset(g, TRUE);
+    setpin_reset(g, TRUE);
-	gfxSleepMilliseconds(20);
+    gfxSleepMilliseconds(20);
-	setpin_reset(g, FALSE);
+    setpin_reset(g, FALSE);
-	gfxSleepMilliseconds(20);
+    gfxSleepMilliseconds(20);
+    acquire_bus(g);
+    enter_cmd_mode(g);
 
-	acquire_bus(g);
+    write_cmd(g, ST7565_RESET);
-    write_cmd(g, ST7565_DISPLAY_OFF);
+    write_cmd(g, ST7565_LCD_BIAS);
-	write_cmd(g, ST7565_LCD_BIAS);
     write_cmd(g, ST7565_ADC);
     write_cmd(g, ST7565_COM_SCAN);
-    
+
+    write_cmd(g, ST7565_RESISTOR_RATIO | 0x1);
+    write_cmd2(g, ST7565_CONTRAST, GDISP_INITIAL_CONTRAST);
+
+    // turn on internal power supply (VC=1, VR=1, VF=1)
+    write_cmd(g, ST7565_POWER_CONTROL | 0x07);
+
+    write_cmd(g, ST7565_INVERT_DISPLAY);
+    write_cmd(g, ST7565_ALLON_NORMAL);
+
     write_cmd(g, ST7565_START_LINE | 0);
-
+    write_cmd(g, ST7565_RMW);
-	write_cmd(g, ST7565_RESISTOR_RATIO | 0x6);
+    flush_cmd(g);
-
-	// turn on voltage converter (VC=1, VR=0, VF=0)
-	write_cmd(g, ST7565_POWER_CONTROL | 0x04);
-	delay_ms(50);
-
-	// turn on voltage regulator (VC=1, VR=1, VF=0)
-	write_cmd(g, ST7565_POWER_CONTROL | 0x06);
-	delay_ms(50);
-
-	// turn on voltage follower (VC=1, VR=1, VF=1)
-	write_cmd(g, ST7565_POWER_CONTROL | 0x07);
-	delay_ms(50);
-
-	write_cmd(g, 0xE2);
-    write_cmd(g, ST7565_COM_SCAN);
-	write_cmd2(g, ST7565_CONTRAST, GDISP_INITIAL_CONTRAST*64/101);
-	//write_cmd2(g, ST7565_CONTRAST, 0);
-	write_cmd(g, ST7565_DISPLAY_ON);
-	write_cmd(g, ST7565_ALLON_NORMAL);
-	write_cmd(g, ST7565_INVERT_DISPLAY);
-
-	write_cmd(g, ST7565_RMW);
 
     // Finish Init
     post_init_board(g);
 
- 	// Release the bus
+    // Release the bus
-	release_bus(g);
+    release_bus(g);
 
-	/* Initialise the GDISP structure */
+    /* Initialise the GDISP structure */
-	g->g.Width = GDISP_SCREEN_WIDTH;
+    g->g.Width = GDISP_SCREEN_WIDTH;
-	g->g.Height = GDISP_SCREEN_HEIGHT;
+    g->g.Height = GDISP_SCREEN_HEIGHT;
-	g->g.Orientation = GDISP_ROTATE_0;
+    g->g.Orientation = GDISP_ROTATE_0;
-	g->g.Powermode = powerOn;
+    g->g.Powermode = powerOff;
-	g->g.Backlight = GDISP_INITIAL_BACKLIGHT;
+    g->g.Backlight = GDISP_INITIAL_BACKLIGHT;
-	g->g.Contrast = GDISP_INITIAL_CONTRAST;
+    g->g.Contrast = GDISP_INITIAL_CONTRAST;
-	return TRUE;
+    return TRUE;
 }
 
 #if GDISP_HARDWARE_FLUSH
-	LLDSPEC void gdisp_lld_flush(GDisplay *g) {
+LLDSPEC void gdisp_lld_flush(GDisplay *g) {
-		unsigned	p;
+    unsigned	p;
 
-		// Don't flush if we don't need it.
+    // Don't flush if we don't need it.
-		if (!(g->flags & GDISP_FLG_NEEDFLUSH))
+    if (!(g->flags & GDISP_FLG_NEEDFLUSH))
-			return;
+        return;
 
-		acquire_bus(g);
+    acquire_bus(g);
-		unsigned dstOffset = (PRIV(g)->buffer2 ? 4 : 0);
+    enter_cmd_mode(g);
-		for (p = 0; p < 4; p++) {
+    unsigned dstOffset = (PRIV(g)->buffer2 ? 4 : 0);
-			write_cmd(g, ST7565_PAGE | (p + dstOffset));
+    for (p = 0; p < 4; p++) {
-			write_cmd(g, ST7565_COLUMN_MSB | 0);
+        write_cmd(g, ST7565_PAGE | (p + dstOffset));
-			write_cmd(g, ST7565_COLUMN_LSB | 0);
+        write_cmd(g, ST7565_COLUMN_MSB | 0);
-			write_cmd(g, ST7565_RMW);
+        write_cmd(g, ST7565_COLUMN_LSB | 0);
-			write_data(g, RAM(g) + (p*GDISP_SCREEN_WIDTH), GDISP_SCREEN_WIDTH);
+        write_cmd(g, ST7565_RMW);
-		}
+        flush_cmd(g);
-		unsigned line = (PRIV(g)->buffer2 ? 32 : 0);
+        enter_data_mode(g);
-        write_cmd(g, ST7565_START_LINE | line);
+        write_data(g, RAM(g) + (p*GDISP_SCREEN_WIDTH), GDISP_SCREEN_WIDTH);
-        PRIV(g)->buffer2 = !PRIV(g)->buffer2;
+        enter_cmd_mode(g);
-		release_bus(g);
+    }
+    unsigned line = (PRIV(g)->buffer2 ? 32 : 0);
+    write_cmd(g, ST7565_START_LINE | line);
+    flush_cmd(g);
+    PRIV(g)->buffer2 = !PRIV(g)->buffer2;
+    release_bus(g);
 
-		g->flags &= ~GDISP_FLG_NEEDFLUSH;
+    g->flags &= ~GDISP_FLG_NEEDFLUSH;
-	}
+}
 #endif
 
 #if GDISP_HARDWARE_DRAWPIXEL
-	LLDSPEC void gdisp_lld_draw_pixel(GDisplay *g) {
+LLDSPEC void gdisp_lld_draw_pixel(GDisplay *g) {
-		coord_t		x, y;
+    coord_t		x, y;
 
-		switch(g->g.Orientation) {
+    switch(g->g.Orientation) {
-		default:
+    default:
-		case GDISP_ROTATE_0:
+    case GDISP_ROTATE_0:
-			x = g->p.x;
+        x = g->p.x;
-			y = g->p.y;
+        y = g->p.y;
-			break;
+        break;
-		case GDISP_ROTATE_90:
+    case GDISP_ROTATE_90:
-			x = g->p.y;
+        x = g->p.y;
-			y = GDISP_SCREEN_HEIGHT-1 - g->p.x;
+        y = GDISP_SCREEN_HEIGHT-1 - g->p.x;
-			break;
+        break;
-		case GDISP_ROTATE_180:
+    case GDISP_ROTATE_180:
-			x = GDISP_SCREEN_WIDTH-1 - g->p.x;
+        x = GDISP_SCREEN_WIDTH-1 - g->p.x;
-			y = GDISP_SCREEN_HEIGHT-1 - g->p.y;
+        y = GDISP_SCREEN_HEIGHT-1 - g->p.y;
-			break;
+        break;
-		case GDISP_ROTATE_270:
+    case GDISP_ROTATE_270:
-			x = GDISP_SCREEN_HEIGHT-1 - g->p.y;
+        x = GDISP_SCREEN_HEIGHT-1 - g->p.y;
-			y = g->p.x;
+        y = g->p.x;
-			break;
+        break;
-		}
+    }
-		if (gdispColor2Native(g->p.color) != Black)
+    if (gdispColor2Native(g->p.color) != Black)
-			RAM(g)[xyaddr(x, y)] |= xybit(y);
+        RAM(g)[xyaddr(x, y)] |= xybit(y);
-		else
+    else
-			RAM(g)[xyaddr(x, y)] &= ~xybit(y);
+        RAM(g)[xyaddr(x, y)] &= ~xybit(y);
-		g->flags |= GDISP_FLG_NEEDFLUSH;
+    g->flags |= GDISP_FLG_NEEDFLUSH;
-	}
+}
 #endif
 
 #if GDISP_HARDWARE_PIXELREAD
-	LLDSPEC color_t gdisp_lld_get_pixel_color(GDisplay *g) {
+LLDSPEC color_t gdisp_lld_get_pixel_color(GDisplay *g) {
-		coord_t		x, y;
+    coord_t		x, y;
 
-		switch(g->g.Orientation) {
+    switch(g->g.Orientation) {
-		default:
+    default:
-		case GDISP_ROTATE_0:
+    case GDISP_ROTATE_0:
-			x = g->p.x;
+        x = g->p.x;
-			y = g->p.y;
+        y = g->p.y;
-			break;
+        break;
-		case GDISP_ROTATE_90:
+    case GDISP_ROTATE_90:
-			x = g->p.y;
+        x = g->p.y;
-			y = GDISP_SCREEN_HEIGHT-1 - g->p.x;
+        y = GDISP_SCREEN_HEIGHT-1 - g->p.x;
-			break;
+        break;
-		case GDISP_ROTATE_180:
+    case GDISP_ROTATE_180:
-			x = GDISP_SCREEN_WIDTH-1 - g->p.x;
+        x = GDISP_SCREEN_WIDTH-1 - g->p.x;
-			y = GDISP_SCREEN_HEIGHT-1 - g->p.y;
+        y = GDISP_SCREEN_HEIGHT-1 - g->p.y;
-			break;
+        break;
-		case GDISP_ROTATE_270:
+    case GDISP_ROTATE_270:
-			x = GDISP_SCREEN_HEIGHT-1 - g->p.y;
+        x = GDISP_SCREEN_HEIGHT-1 - g->p.y;
-			y = g->p.x;
+        y = g->p.x;
-			break;
+        break;
-		}
+    }
-		return (RAM(g)[xyaddr(x, y)] & xybit(y)) ? White : Black;
+    return (RAM(g)[xyaddr(x, y)] & xybit(y)) ? White : Black;
-	}
+}
 #endif
 
+LLDSPEC void gdisp_lld_blit_area(GDisplay *g) {
+    uint8_t* buffer = (uint8_t*)g->p.ptr;
+    int linelength = g->p.cx;
+    for (int i = 0; i < g->p.cy; i++) {
+        unsigned dstx = g->p.x;
+        unsigned dsty = g->p.y + i;
+        unsigned srcx = g->p.x1;
+        unsigned srcy = g->p.y1 + i;
+        unsigned srcbit = srcy * g->p.x2 + srcx;
+        for(int j=0; j < linelength; j++) {
+            uint8_t src = buffer[srcbit / 8];
+            uint8_t bit = 7-(srcbit % 8);
+            uint8_t bitset = (src >> bit) & 1;
+            uint8_t* dst = &(RAM(g)[xyaddr(dstx, dsty)]);
+            if (bitset) {
+                *dst |= xybit(dsty);
+            }
+            else {
+                *dst &= ~xybit(dsty);
+            }
+			dstx++;
+            srcbit++;
+        }
+    }
+    g->flags |= GDISP_FLG_NEEDFLUSH;
+}
+
 #if GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL
-	LLDSPEC void gdisp_lld_control(GDisplay *g) {
+LLDSPEC void gdisp_lld_control(GDisplay *g) {
-		switch(g->p.x) {
+    switch(g->p.x) {
-		case GDISP_CONTROL_POWER:
+    case GDISP_CONTROL_POWER:
-			if (g->g.Powermode == (powermode_t)g->p.ptr)
+        if (g->g.Powermode == (powermode_t)g->p.ptr)
-				return;
+            return;
-			switch((powermode_t)g->p.ptr) {
+        switch((powermode_t)g->p.ptr) {
-			case powerOff:
+        case powerOff:
-			case powerSleep:
+        case powerSleep:
-			case powerDeepSleep:
+        case powerDeepSleep:
-				acquire_bus(g);
+            acquire_bus(g);
-				write_cmd(g, ST7565_DISPLAY_OFF);
+            enter_cmd_mode(g);
-				release_bus(g);
+            write_cmd(g, ST7565_DISPLAY_OFF);
-				break;
+            flush_cmd(g);
-			case powerOn:
+            release_bus(g);
-				acquire_bus(g);
+            break;
-				write_cmd(g, ST7565_DISPLAY_ON);
+        case powerOn:
-				release_bus(g);
+            acquire_bus(g);
-				break;
+            enter_cmd_mode(g);
-			default:
+            write_cmd(g, ST7565_DISPLAY_ON);
-				return;
+            flush_cmd(g);
-			}
+            release_bus(g);
-			g->g.Powermode = (powermode_t)g->p.ptr;
+            break;
-			return;
+        default:
+            return;
+        }
+        g->g.Powermode = (powermode_t)g->p.ptr;
+        return;
 
-		case GDISP_CONTROL_ORIENTATION:
+        case GDISP_CONTROL_ORIENTATION:
-			if (g->g.Orientation == (orientation_t)g->p.ptr)
+            if (g->g.Orientation == (orientation_t)g->p.ptr)
-				return;
+                return;
-			switch((orientation_t)g->p.ptr) {
+            switch((orientation_t)g->p.ptr) {
-			/* Rotation is handled by the drawing routines */
+            /* Rotation is handled by the drawing routines */
-			case GDISP_ROTATE_0:
+            case GDISP_ROTATE_0:
-			case GDISP_ROTATE_180:
+            case GDISP_ROTATE_180:
-				g->g.Height = GDISP_SCREEN_HEIGHT;
+                g->g.Height = GDISP_SCREEN_HEIGHT;
-				g->g.Width = GDISP_SCREEN_WIDTH;
+                g->g.Width = GDISP_SCREEN_WIDTH;
-				break;
+                break;
-			case GDISP_ROTATE_90:
+            case GDISP_ROTATE_90:
-			case GDISP_ROTATE_270:
+            case GDISP_ROTATE_270:
-				g->g.Height = GDISP_SCREEN_WIDTH;
+                g->g.Height = GDISP_SCREEN_WIDTH;
-				g->g.Width = GDISP_SCREEN_HEIGHT;
+                g->g.Width = GDISP_SCREEN_HEIGHT;
-				break;
+                break;
-			default:
+            default:
-				return;
+                return;
-			}
+            }
-			g->g.Orientation = (orientation_t)g->p.ptr;
+            g->g.Orientation = (orientation_t)g->p.ptr;
-			return;
+            return;
 
-		case GDISP_CONTROL_CONTRAST:
+            case GDISP_CONTROL_CONTRAST:
-            if ((unsigned)g->p.ptr > 100)
+                g->g.Contrast = (unsigned)g->p.ptr & 63;
-            	g->p.ptr = (void *)100;
+                acquire_bus(g);
-			acquire_bus(g);
+                enter_cmd_mode(g);
-			write_cmd2(g, ST7565_CONTRAST, ((((unsigned)g->p.ptr)<<6)/101) & 0x3F);
+                write_cmd2(g, ST7565_CONTRAST, g->g.Contrast);
-			release_bus(g);
+                flush_cmd(g);
-            g->g.Contrast = (unsigned)g->p.ptr;
+                release_bus(g);
-			return;
+                return;
-		}
+    }
-	}
+}
 #endif // GDISP_NEED_CONTROL
 
 #endif // GFX_USE_GDISP

keyboards/ergodox/infinity/drivers/gdisp/st7565ergodox/gdisp_lld_config.h

@@ -14,12 +14,13 @@
 /* Driver hardware support.                                                  */
 /*===========================================================================*/
 
-#define GDISP_HARDWARE_FLUSH			TRUE		// This controller requires flushing
+#define GDISP_HARDWARE_FLUSH            TRUE		// This controller requires flushing
-#define GDISP_HARDWARE_DRAWPIXEL		TRUE
+#define GDISP_HARDWARE_DRAWPIXEL        TRUE
-#define GDISP_HARDWARE_PIXELREAD		TRUE
+#define GDISP_HARDWARE_PIXELREAD        TRUE
-#define GDISP_HARDWARE_CONTROL			TRUE
+#define GDISP_HARDWARE_CONTROL          TRUE
+#define GDISP_HARDWARE_BITFILLS         TRUE
 
-#define GDISP_LLD_PIXELFORMAT			GDISP_PIXELFORMAT_MONO
+#define GDISP_LLD_PIXELFORMAT           GDISP_PIXELFORMAT_MONO
 
 #endif	/* GFX_USE_GDISP */
 

keyboards/ergodox/infinity/drivers/gdisp/st7565ergodox/st7565.h

@@ -34,4 +34,6 @@
 #define ST7565_RESISTOR_RATIO       0x20
 #define ST7565_POWER_CONTROL        0x28
 
+#define ST7565_RESET                0xE2
+
 #endif /* _ST7565_H */

keyboards/ergodox/infinity/gfxconf.h

@@ -143,7 +143,7 @@
         #define GDISP_HARDWARE_DRAWPIXEL             TRUE
         #define GDISP_HARDWARE_CLEARS                FALSE
         #define GDISP_HARDWARE_FILLS                 FALSE
-        #define GDISP_HARDWARE_BITFILLS              FALSE
+        //#define GDISP_HARDWARE_BITFILLS              FALSE
         #define GDISP_HARDWARE_SCROLL                FALSE
         #define GDISP_HARDWARE_PIXELREAD             TRUE
         #define GDISP_HARDWARE_CONTROL               TRUE

keyboards/ergodox/infinity/infinity.c

@@ -70,10 +70,33 @@ void lcd_backlight_hal_init(void) {
     RGB_PORT->PCR[BLUE_PIN] = RGB_MODE;
 }
 
+static uint16_t cie_lightness(uint16_t v) {
+    // The CIE 1931 formula for lightness
+    // Y = luminance (output) 0-1
+    // L = lightness input 0 - 100
+
+    // Y = (L* / 902.3)           if L* <= 8
+    // Y = ((L* + 16) / 116)^3    if L* > 8
+
+    float l =  100.0f * (v / 65535.0f);
+    float y = 0.0f;
+    if (l <= 8.0f) {
+       y = l / 902.3;
+    }
+    else {
+        y = ((l + 16.0f) / 116.0f);
+        y = y * y * y;
+        if (y > 1.0f) {
+            y = 1.0f;
+        }
+    }
+    return y * 65535.0f;
+}
+
 void lcd_backlight_hal_color(uint16_t r, uint16_t g, uint16_t b) {
-	CHANNEL_RED.CnV = r;
+	CHANNEL_RED.CnV = cie_lightness(r);
-	CHANNEL_GREEN.CnV = g;
+	CHANNEL_GREEN.CnV = cie_lightness(g);
-	CHANNEL_BLUE.CnV = b;
+	CHANNEL_BLUE.CnV = cie_lightness(b);
 }
 
 __attribute__ ((weak))
@@ -103,34 +126,48 @@ void matrix_scan_kb(void) {
 	matrix_scan_user();
 }
 
+__attribute__ ((weak))
 void ergodox_board_led_on(void){
 }
 
+__attribute__ ((weak))
 void ergodox_right_led_1_on(void){
 }
 
+__attribute__ ((weak))
 void ergodox_right_led_2_on(void){
 }
 
+__attribute__ ((weak))
 void ergodox_right_led_3_on(void){
 }
 
-void ergodox_right_led_on(uint8_t led){
+__attribute__ ((weak))
-}
-
 void ergodox_board_led_off(void){
 }
 
+__attribute__ ((weak))
 void ergodox_right_led_1_off(void){
 }
 
+__attribute__ ((weak))
 void ergodox_right_led_2_off(void){
 }
 
+__attribute__ ((weak))
 void ergodox_right_led_3_off(void){
 }
 
-void ergodox_right_led_off(uint8_t led){
+__attribute__ ((weak))
+void ergodox_right_led_1_set(uint8_t n) {
+}
+
+__attribute__ ((weak))
+void ergodox_right_led_2_set(uint8_t n) {
+}
+
+__attribute__ ((weak))
+void ergodox_right_led_3_set(uint8_t n) {
 }
 
 #ifdef ONEHAND_ENABLE

keyboards/ergodox/infinity/infinity.h

@@ -7,13 +7,38 @@ void ergodox_board_led_on(void);
 void ergodox_right_led_1_on(void);
 void ergodox_right_led_2_on(void);
 void ergodox_right_led_3_on(void);
-void ergodox_right_led_on(uint8_t led);
+
+inline void ergodox_right_led_on(uint8_t led) {
+    switch (led) {
+    case 0:
+        ergodox_right_led_1_on();
+        break;
+    case 1:
+        ergodox_right_led_2_on();
+        break;
+    case 2:
+        ergodox_right_led_3_on();
+        break;
+    }
+}
 
 void ergodox_board_led_off(void);
 void ergodox_right_led_1_off(void);
 void ergodox_right_led_2_off(void);
 void ergodox_right_led_3_off(void);
-void ergodox_right_led_off(uint8_t led);
+inline void ergodox_right_led_off(uint8_t led) {
+    switch (led) {
+    case 0:
+        ergodox_right_led_1_off();
+        break;
+    case 1:
+        ergodox_right_led_2_off();
+        break;
+    case 2:
+        ergodox_right_led_3_off();
+        break;
+    }
+}
 
 inline void ergodox_led_all_on(void)
 {
@@ -31,36 +56,22 @@ inline void ergodox_led_all_off(void)
     ergodox_right_led_3_off();
 }
 
-inline void ergodox_right_led_1_set(uint8_t n){
+void ergodox_right_led_1_set(uint8_t n);
-	if (n) {
+void ergodox_right_led_2_set(uint8_t n);
-		ergodox_right_led_1_on();
+void ergodox_right_led_3_set(uint8_t n);
-	} else {
-		ergodox_right_led_1_off();
-	}
-}
-
-inline void ergodox_right_led_2_set(uint8_t n){
-	if (n) {
-		ergodox_right_led_2_on();
-	} else {
-		ergodox_right_led_2_off();
-	}
-}
-
-inline void ergodox_right_led_3_set(uint8_t n){
-	if (n) {
-		ergodox_right_led_3_on();
-	} else {
-		ergodox_right_led_3_off();
-	}
-}
 
 inline void ergodox_right_led_set(uint8_t led, uint8_t n){
-	if (n) {
+    switch (led) {
-		ergodox_right_led_on(led);
+    case 0:
-	} else {
+        ergodox_right_led_1_set(n);
-		ergodox_right_led_off(led);
+        break;
-	}
+    case 1:
+        ergodox_right_led_2_set(n);
+        break;
+    case 2:
+        ergodox_right_led_3_set(n);
+        break;
+    }
 }
 
 inline void ergodox_led_all_set(uint8_t n) {

keyboards/ergodox/infinity/matrix.c

@@ -24,6 +24,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "print.h"
 #include "debug.h"
 #include "matrix.h"
+#include "serial_link/system/serial_link.h"
 
 
 /*

keyboards/ergodox/infinity/rules.mk

@@ -1,6 +1,7 @@
 # project specific files
 SRC =	matrix.c \
-	led.c
+	led.c \
+	animations.c
 
 ## chip/board settings
 # - the next two should match the directories in
@@ -59,21 +60,17 @@ OPT_DEFS += -DCORTEX_VTOR_INIT=0x00002000
 #
 CUSTOM_MATRIX ?= yes # Custom matrix file
 SERIAL_LINK_ENABLE = yes
-VISUALIZER_ENABLE ?= no #temporarily disabled to make everything compile
+VISUALIZER_ENABLE ?= yes
 LCD_ENABLE ?= yes
-LED_ENABLE ?= yes
+LED_ENABLE ?= no
 LCD_BACKLIGHT_ENABLE ?= yes
 MIDI_ENABLE = no
 RGBLIGHT_ENABLE = no
 
-ifndef QUANTUM_DIR
-	include ../../../Makefile
-endif
-
 ifdef LCD_ENABLE
 include $(SUBPROJECT_PATH)/drivers/gdisp/st7565ergodox/driver.mk
 endif
 
 ifdef LED_ENABLE
 include $(SUBPROJECT_PATH)/drivers/gdisp/IS31FL3731C/driver.mk
-endif
+endif

keyboards/ergodox/infinity/simple_visualizer.h

@@ -0,0 +1,123 @@
+/* Copyright 2017 Fred Sundvik
+ *
+ * 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 KEYBOARDS_ERGODOX_INFINITY_SIMPLE_VISUALIZER_H_
+#define KEYBOARDS_ERGODOX_INFINITY_SIMPLE_VISUALIZER_H_
+
+// Currently we are assuming that both the backlight and LCD are enabled
+// But it's entirely possible to write a custom visualizer that use only
+// one of them
+#ifndef LCD_BACKLIGHT_ENABLE
+#error This visualizer needs that LCD backlight is enabled
+#endif
+
+#ifndef LCD_ENABLE
+#error This visualizer needs that LCD is enabled
+#endif
+
+#include "visualizer.h"
+#include "visualizer_keyframes.h"
+#include "lcd_keyframes.h"
+#include "lcd_backlight_keyframes.h"
+#include "system/serial_link.h"
+#include "led.h"
+#include "animations.h"
+
+static const uint32_t logo_background_color = LCD_COLOR(0x00, 0x00, 0xFF);
+static const uint32_t initial_color = LCD_COLOR(0, 0, 0);
+
+static bool initial_update = true;
+
+// Feel free to modify the animations below, or even add new ones if needed
+
+static keyframe_animation_t lcd_layer_display = {
+    .num_frames = 1,
+    .loop = false,
+    .frame_lengths = {gfxMillisecondsToTicks(0)},
+    .frame_functions = {lcd_keyframe_display_layer_and_led_states}
+};
+
+// The color animation animates the LCD color when you change layers
+static keyframe_animation_t color_animation = {
+    .num_frames = 2,
+    .loop = false,
+    // Note that there's a 200 ms no-operation frame,
+    // this prevents the color from changing when activating the layer
+    // momentarily
+    .frame_lengths = {gfxMillisecondsToTicks(200), gfxMillisecondsToTicks(500)},
+    .frame_functions = {keyframe_no_operation, backlight_keyframe_animate_color},
+};
+
+void initialize_user_visualizer(visualizer_state_t* state) {
+    // The brightness will be dynamically adjustable in the future
+    // But for now, change it here.
+    lcd_backlight_brightness(130);
+    state->current_lcd_color = initial_color;
+    state->target_lcd_color = logo_background_color;
+    initial_update = true;
+    start_keyframe_animation(&default_startup_animation);
+}
+
+
+// This function should be implemented by the keymap visualizer
+// Don't change anything else than state->target_lcd_color and state->layer_text as that's the only thing
+// that the simple_visualizer assumes that you are updating
+// Also make sure that the buffer passed to state->layer_text remains valid until the previous animation is
+// stopped. This can be done by either double buffering it or by using constant strings
+static void get_visualizer_layer_and_color(visualizer_state_t* state);
+
+void update_user_visualizer_state(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status) {
+    // Add more tests, change the colors and layer texts here
+    // Usually you want to check the high bits (higher layers first)
+    // because that's the order layers are processed for keypresses
+    // You can for check for example:
+    // state->status.layer
+    // state->status.default_layer
+    // state->status.leds (see led.h for available statuses)
+
+    uint32_t prev_color = state->target_lcd_color;
+    const char* prev_layer_text = state->layer_text;
+
+    get_visualizer_layer_and_color(state);
+
+    if (initial_update || prev_color != state->target_lcd_color) {
+        start_keyframe_animation(&color_animation);
+    }
+
+    if (initial_update || prev_layer_text != state->layer_text) {
+        start_keyframe_animation(&lcd_layer_display);
+    }
+    // You can also stop existing animations, and start your custom ones here
+    // remember that you should normally have only one animation for the LCD
+    // and one for the background. But you can also combine them if you want.
+}
+
+void user_visualizer_suspend(visualizer_state_t* state) {
+    state->layer_text = "Suspending...";
+    uint8_t hue = LCD_HUE(state->current_lcd_color);
+    uint8_t sat = LCD_SAT(state->current_lcd_color);
+    state->target_lcd_color = LCD_COLOR(hue, sat, 0);
+    start_keyframe_animation(&default_suspend_animation);
+}
+
+void user_visualizer_resume(visualizer_state_t* state) {
+    state->current_lcd_color = initial_color;
+    state->target_lcd_color = logo_background_color;
+    initial_update = true;
+    start_keyframe_animation(&default_startup_animation);
+}
+
+#endif /* KEYBOARDS_ERGODOX_INFINITY_SIMPLE_VISUALIZER_H_ */

keyboards/ergodox/infinity/visualizer.c

@@ -0,0 +1,329 @@
+/*
+Copyright 2016 Fred Sundvik <[email protected]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+// Currently we are assuming that both the backlight and LCD are enabled
+// But it's entirely possible to write a custom visualizer that use only
+// one of them
+#ifndef LCD_BACKLIGHT_ENABLE
+#error This visualizer needs that LCD backlight is enabled
+#endif
+
+#ifndef LCD_ENABLE
+#error This visualizer needs that LCD is enabled
+#endif
+
+#include "visualizer.h"
+#include "visualizer_keyframes.h"
+#include "lcd_keyframes.h"
+#include "lcd_backlight_keyframes.h"
+#include "system/serial_link.h"
+#include "animations.h"
+
+static const uint32_t logo_background_color = LCD_COLOR(0x00, 0x00, 0xFF);
+static const uint32_t initial_color = LCD_COLOR(0, 0, 0);
+
+static const uint32_t led_emulation_colors[4] = {
+    LCD_COLOR(0, 0, 0),
+    LCD_COLOR(255, 255, 255),
+    LCD_COLOR(84, 255, 255),
+    LCD_COLOR(168, 255, 255),
+};
+
+static uint32_t next_led_target_color = 0;
+
+typedef enum {
+    LCD_STATE_INITIAL,
+    LCD_STATE_LAYER_BITMAP,
+    LCD_STATE_BITMAP_AND_LEDS,
+} lcd_state_t;
+
+static lcd_state_t lcd_state = LCD_STATE_INITIAL;
+
+typedef struct {
+    uint8_t led_on;
+    uint8_t led1;
+    uint8_t led2;
+    uint8_t led3;
+} visualizer_user_data_t;
+
+// Don't access from visualization function, use the visualizer state instead
+static visualizer_user_data_t user_data_keyboard = {
+    .led_on = 0,
+    .led1 = LED_BRIGHTNESS_HI,
+    .led2 = LED_BRIGHTNESS_HI,
+    .led3 = LED_BRIGHTNESS_HI,
+};
+
+_Static_assert(sizeof(visualizer_user_data_t) <= VISUALIZER_USER_DATA_SIZE,
+    "Please increase the VISUALIZER_USER_DATA_SIZE");
+
+// Feel free to modify the animations below, or even add new ones if needed
+
+
+// The color animation animates the LCD color when you change layers
+static keyframe_animation_t one_led_color = {
+    .num_frames = 1,
+    .loop = false,
+    .frame_lengths = {gfxMillisecondsToTicks(0)},
+    .frame_functions = {backlight_keyframe_set_color},
+};
+
+bool swap_led_target_color(keyframe_animation_t* animation, visualizer_state_t* state) {
+    uint32_t temp = next_led_target_color;
+    next_led_target_color = state->target_lcd_color;
+    state->target_lcd_color = temp;
+    return false;
+}
+
+// The color animation animates the LCD color when you change layers
+static keyframe_animation_t two_led_colors = {
+    .num_frames = 2,
+    .loop = true,
+    .frame_lengths = {gfxMillisecondsToTicks(1000), gfxMillisecondsToTicks(0)},
+    .frame_functions = {backlight_keyframe_set_color, swap_led_target_color},
+};
+
+// The LCD animation alternates between the layer name display and a
+// bitmap that displays all active layers
+static keyframe_animation_t lcd_bitmap_animation = {
+    .num_frames = 1,
+    .loop = false,
+    .frame_lengths = {gfxMillisecondsToTicks(0)},
+    .frame_functions = {lcd_keyframe_display_layer_bitmap},
+};
+
+static keyframe_animation_t lcd_bitmap_leds_animation = {
+    .num_frames = 2,
+    .loop = true,
+    .frame_lengths = {gfxMillisecondsToTicks(2000), gfxMillisecondsToTicks(2000)},
+    .frame_functions = {lcd_keyframe_display_layer_bitmap, lcd_keyframe_display_led_states},
+};
+
+void initialize_user_visualizer(visualizer_state_t* state) {
+    // The brightness will be dynamically adjustable in the future
+    // But for now, change it here.
+    lcd_backlight_brightness(130);
+    state->current_lcd_color = initial_color;
+    state->target_lcd_color = logo_background_color;
+    lcd_state = LCD_STATE_INITIAL;
+    start_keyframe_animation(&default_startup_animation);
+}
+
+inline bool is_led_on(visualizer_user_data_t* user_data, uint8_t num) {
+    return user_data->led_on & (1u << num);
+}
+
+static uint8_t get_led_index_master(visualizer_user_data_t* user_data) {
+    for (int i=0; i < 3; i++) {
+        if (is_led_on(user_data, i)) {
+            return i + 1;
+        }
+    }
+    return 0;
+}
+
+static uint8_t get_led_index_slave(visualizer_user_data_t* user_data) {
+    uint8_t master_index = get_led_index_master(user_data);
+    if (master_index!=0) {
+        for (int i=master_index; i < 3; i++) {
+            if (is_led_on(user_data, i)) {
+                return i + 1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static uint8_t get_secondary_led_index(visualizer_user_data_t* user_data) {
+    if (is_led_on(user_data, 0) &&
+            is_led_on(user_data, 1) &&
+            is_led_on(user_data, 2)) {
+        return 3;
+    }
+    return 0;
+}
+
+static uint8_t get_brightness(visualizer_user_data_t* user_data, uint8_t index) {
+    switch (index) {
+    case 1:
+        return user_data->led1;
+    case 2:
+        return user_data->led2;
+    case 3:
+        return user_data->led3;
+    }
+    return 0;
+}
+
+static void update_emulated_leds(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status) {
+    visualizer_user_data_t* user_data_new = (visualizer_user_data_t*)state->status.user_data;
+    visualizer_user_data_t* user_data_old = (visualizer_user_data_t*)prev_status->user_data;
+
+    uint8_t new_index;
+    uint8_t old_index;
+
+    if (is_serial_link_master()) {
+        new_index = get_led_index_master(user_data_new);
+        old_index = get_led_index_master(user_data_old);
+    }
+    else {
+        new_index = get_led_index_slave(user_data_new);
+        old_index = get_led_index_slave(user_data_old);
+    }
+    uint8_t new_secondary_index = get_secondary_led_index(user_data_new);
+    uint8_t old_secondary_index = get_secondary_led_index(user_data_old);
+
+    uint8_t old_brightness = get_brightness(user_data_old, old_index);
+    uint8_t new_brightness = get_brightness(user_data_new, new_index);
+
+    uint8_t old_secondary_brightness = get_brightness(user_data_old, old_secondary_index);
+    uint8_t new_secondary_brightness = get_brightness(user_data_new, new_secondary_index);
+
+    if (lcd_state == LCD_STATE_INITIAL ||
+            new_index != old_index ||
+            new_secondary_index != old_secondary_index ||
+            new_brightness != old_brightness ||
+            new_secondary_brightness != old_secondary_brightness) {
+
+        if (new_secondary_index != 0) {
+            state->target_lcd_color = change_lcd_color_intensity(
+                led_emulation_colors[new_index], new_brightness);
+            next_led_target_color = change_lcd_color_intensity(
+                led_emulation_colors[new_secondary_index], new_secondary_brightness);
+
+            stop_keyframe_animation(&one_led_color);
+            start_keyframe_animation(&two_led_colors);
+        } else {
+            state->target_lcd_color = change_lcd_color_intensity(
+                led_emulation_colors[new_index], new_brightness);
+            stop_keyframe_animation(&two_led_colors);
+            start_keyframe_animation(&one_led_color);
+        }
+    }
+}
+
+static void update_lcd_text(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status) {
+    if (state->status.leds) {
+        if (lcd_state != LCD_STATE_BITMAP_AND_LEDS ||
+                state->status.leds != prev_status->leds ||
+                state->status.layer != prev_status->layer ||
+                state->status.default_layer != prev_status->default_layer) {
+
+            // NOTE: that it doesn't matter if the animation isn't playing, stop will do nothing in that case
+            stop_keyframe_animation(&lcd_bitmap_animation);
+
+            lcd_state = LCD_STATE_BITMAP_AND_LEDS;
+            // For information:
+            // The logic in this function makes sure that this doesn't happen, but if you call start on an
+            // animation that is already playing it will be restarted.
+            start_keyframe_animation(&lcd_bitmap_leds_animation);
+        }
+    } else {
+        if (lcd_state != LCD_STATE_LAYER_BITMAP ||
+                state->status.layer != prev_status->layer ||
+                state->status.default_layer != prev_status->default_layer) {
+
+            stop_keyframe_animation(&lcd_bitmap_leds_animation);
+
+            lcd_state = LCD_STATE_LAYER_BITMAP;
+            start_keyframe_animation(&lcd_bitmap_animation);
+        }
+    }
+}
+
+void update_user_visualizer_state(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status) {
+    // Check the status here to start and stop animations
+    // You might have to save some state, like the current animation here so that you can start the right
+    // This function is called every time the status changes
+
+    // NOTE that this is called from the visualizer thread, so don't access anything else outside the status
+    // This is also important because the slave won't have access to the active layer for example outside the
+    // status.
+
+    update_emulated_leds(state, prev_status);
+    update_lcd_text(state, prev_status);
+
+}
+
+void user_visualizer_suspend(visualizer_state_t* state) {
+    state->layer_text = "Suspending...";
+    uint8_t hue = LCD_HUE(state->current_lcd_color);
+    uint8_t sat = LCD_SAT(state->current_lcd_color);
+    state->target_lcd_color = LCD_COLOR(hue, sat, 0);
+    start_keyframe_animation(&default_suspend_animation);
+}
+
+void user_visualizer_resume(visualizer_state_t* state) {
+    state->current_lcd_color = initial_color;
+    state->target_lcd_color = logo_background_color;
+    lcd_state = LCD_STATE_INITIAL;
+    start_keyframe_animation(&default_startup_animation);
+}
+
+void ergodox_board_led_on(void){
+    // No board led support
+}
+
+void ergodox_right_led_1_on(void){
+    user_data_keyboard.led_on |= (1u << 0);
+    visualizer_set_user_data(&user_data_keyboard);
+}
+
+void ergodox_right_led_2_on(void){
+    user_data_keyboard.led_on |= (1u << 1);
+    visualizer_set_user_data(&user_data_keyboard);
+}
+
+void ergodox_right_led_3_on(void){
+    user_data_keyboard.led_on |= (1u << 2);
+    visualizer_set_user_data(&user_data_keyboard);
+}
+
+void ergodox_board_led_off(void){
+    // No board led support
+}
+
+void ergodox_right_led_1_off(void){
+    user_data_keyboard.led_on &= ~(1u << 0);
+    visualizer_set_user_data(&user_data_keyboard);
+}
+
+void ergodox_right_led_2_off(void){
+    user_data_keyboard.led_on &= ~(1u << 1);
+    visualizer_set_user_data(&user_data_keyboard);
+}
+
+void ergodox_right_led_3_off(void){
+    user_data_keyboard.led_on &= ~(1u << 2);
+    visualizer_set_user_data(&user_data_keyboard);
+}
+
+void ergodox_right_led_1_set(uint8_t n) {
+    user_data_keyboard.led1 = n;
+    visualizer_set_user_data(&user_data_keyboard);
+}
+
+void ergodox_right_led_2_set(uint8_t n) {
+    user_data_keyboard.led2 = n;
+    visualizer_set_user_data(&user_data_keyboard);
+}
+
+void ergodox_right_led_3_set(uint8_t n) {
+    user_data_keyboard.led3 = n;
+    visualizer_set_user_data(&user_data_keyboard);
+}

keyboards/ergodox/keymaps/default/visualizer.c

@@ -0,0 +1,42 @@
+/*
+Copyright 2017 Fred Sundvik
+
+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 "simple_visualizer.h"
+
+// This function should be implemented by the keymap visualizer
+// Don't change anything else than state->target_lcd_color and state->layer_text as that's the only thing
+// that the simple_visualizer assumes that you are updating
+// Also make sure that the buffer passed to state->layer_text remains valid until the previous animation is
+// stopped. This can be done by either double buffering it or by using constant strings
+static void get_visualizer_layer_and_color(visualizer_state_t* state) {
+    uint8_t saturation = 60;
+    if (state->status.leds & (1u << USB_LED_CAPS_LOCK)) {
+        saturation = 255;
+    }
+    if (state->status.layer & 0x4) {
+        state->target_lcd_color = LCD_COLOR(0, saturation, 0xFF);
+        state->layer_text = "Media & Mouse";
+    }
+    else if (state->status.layer & 0x2) {
+        state->target_lcd_color = LCD_COLOR(168, saturation, 0xFF);
+        state->layer_text = "Symbol";
+    }
+    else {
+        state->target_lcd_color = LCD_COLOR(84, saturation, 0xFF);
+        state->layer_text = "Default";
+    }
+}

keyboards/ergodox/keymaps/dvorak_programmer/keymap.c

@@ -311,12 +311,12 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
         break;        
         case SWITCH_NDS:
              if (record->event.pressed) {
-                return MACRO( D(LSFT), T(F11), U(LSFT), W(500), D(LALT), T(TAB), U(LALT), END); 
+                return MACRO( D(LSFT), T(F11), U(LSFT), W(255), D(LALT), T(TAB), U(LALT), END);
             }                                
         break;        
         case OPEN_CLOSE_PAREN:
             if (record->event.pressed) {
-                return MACRO( D(LSFT), T(LPRN), T(RPRN), U(LSFT), T(LEFT), END);
+                return MACRO( D(LSFT), T(9), T(0), U(LSFT), T(LEFT), END);
             }
         break;
         case OPEN_CLOSE_BRACKET:
@@ -326,7 +326,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
         break;        
         case OPEN_CLOSE_CURLY:
             if (record->event.pressed) {
-                return MACRO( D(LSFT), T(LCBR), T(RCBR), U(LSFT), T(LEFT), END);
+                return MACRO( D(LSFT), T(LBRC), T(RBRC), U(LSFT), T(LEFT), END);
             }
         break;                
         case OPEN_CLOSE_SINGLE_QUOTE:

keyboards/ergodox/keymaps/familiar/README.md

@@ -0,0 +1,69 @@
+# ErgoDox Familiar Layout
+Familiar layout for those who regularly switch back and forth from ErgoDox to regular QWERTY.
+
+[![License: GPL v3](https://img.shields.io/badge/License-GPL%20v3-blue.svg)](../../../../license_GPLv3.md../../../../license_GPLv3.md) [![standard-readme compliant](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg)](https://github.com/RichardLitt/standard-readme)
+
+## Table of Contents
+
+- [Background](#background)
+- [Install](#install)
+- [Usage](#usage)
+    - [Layers](#layers)
+- [Contribute](#contribute)
+    - [Issues](#issues)
+- [License](#license)
+
+## Background
+
+This layout is built to be as familiar as possible for users coming directly from a default (QWERTY US) keyboard, while gaining as much advantage as possible from the ErgoDox and QMK featureset. I use an ErgoDoxEZ at home, but I don't have a regular office (CS grad student) so I regularly use either my laptop or a default-setup lab computer; I context switch daily so this layout is meant to reduce the mental overhead as much as possible.
+
+The default ErgoDoxEZ layout is probably more optimized as a solo daily driver - as are a lot of the others available keymaps. The focus of this layout is to get as much from the 'Dox as possible without overly disrupting long-established muscle memory.
+
+Key features of the familiar layout:
+1. QWERTY default layout.
+1. International symbols layer, mapped in the US-International layout default positions, through [UCIS](https://github.com/qmk/qmk_firmware/wiki/Unicode-and-additional-language-support#ucis_enable).
+1. Numpad layer on right hand.
+1. Thumb cluster holds spacebar, ALT, and access to secondary layers.
+1. Function-layer arrow keys in both the first-person-shooter (actually ESDF instead of WASD) and vim (HJKL) locations.
+
+## Install
+
+If you are on Windows or Mac, choose the proper line in [`keymap.c`](keymap.c) for [unicode/international character support](https://github.com/qmk/qmk_firmware/wiki/Unicode-and-additional-language-support#ucis_enable) (starts at line 235).
+```c
+void matrix_init_user(void) {
+    set_unicode_input_mode(UC_LNX); // Linux
+    //set_unicode_input_mode(UC_OSX); // Mac OSX
+    //set_unicode_input_mode(UC_WIN); // Windows (with registry key, see wiki)
+    //set_unicode_input_mode(UC_WINC); // Windows (with WinCompose, see wiki)
+};
+```
+
+For instructions on building and installing this keymap, [go to the wiki](https://github.com/qmk/qmk_firmware/tree/master/keyboards/ergodox#build-dependencies). Below is the command for me; it may be different for you.
+```sh
+$ make ergodox-ez-familiar-teensy
+```
+
+## Usage
+
+[![Familiar Layout](familiar.png)](http://www.keyboard-layout-editor.com/#/gists/13508a9f99cff381d58b7be6f7dcc644)
+
+### Layers
+1. Base Layer: QWERTY, with arrow keys at bottom right.
+1. UCIS Layer: US-International symbols layer, plus —. Accessed by toggling the `INTL` layer using the UCIS key (bottom of left thumb cluster).
+1. UCIS-Shifted Layer: Making shift work for UCIS characters. An ugly workaround. Any ideas? Accessed through holding shift while the UCIS layer is active (toggles the `INSF` layer).
+1. Numpad Layer: Right hand number pad. Accessed by toggling the `NUMP` layer using the NPAD key (bottom of right thumb cluster).
+1. Function Layer: F1-F12, arrows on ESDF and HJKL, media player controls. Accessed by holding either FN key (center key of each thumb cluster), which toggles the `ARRW` layer. I know, I need to work on my naming conventions.
+
+## Contribute
+
+[Contributor Covenant](http://contributor-covenant.org/)
+
+I'm terrible at this; I have no background in human-computer interaction, kinesiology, or keyboard-ology. Please send comments/issues/pull requests/angry tweets/etc. If you think there is a better way to take advantage of the ErgoDox/QMK comination without straying far from 84/101-key QWERTY, I want to know it.
+
+### Issues
+1. The top two keys of the right thumb cluster are currently unused. I wanted them for screen brightness, but I haven't found a solution I like.
+1. The `'`, `"`, `[`, and `]` keys are terrible to access; I want to put them somewhere else but I haven't figured out where.
+1. The `INSF` layer is an ugly workaround. I should write a function for doing different things in the `INTL` layer depending on whether SHIFT is being held. Or something. Ideas?
+
+## License
+QMK is licensed ([mostly](https://github.com/qmk/qmk_firmware/issues/1038)) under the [GPLv2](blob/master/license_GPLv2.md). Accordingly, to whatever extent applicable, this keymap is licensed under the [GPLv3](../../../../license_GPLv3.md).

keyboards/ergodox/keymaps/familiar/keymap.c

@@ -0,0 +1,267 @@
+#include "ergodox.h"
+#include "debug.h"
+#include "action_layer.h"
+#include "version.h"
+
+// Layers
+#define BASE 0 // default layer
+#define INTL 1 // international symbols
+#define INSF 2 // international symbols shifted
+#define NUMP 3 // numpad
+#define ARRW 4 // function, media, arrow keys
+
+// Fillers to make layering more clear
+#define _______ KC_TRNS
+#define XXXXXXX KC_NO
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+// If it accepts an argument (i.e, is a function), it doesn't need KC_.
+// Otherwise, it needs KC_*
+/* layer 0 : default
+ *
+ * ,--------------------------------------------------.           ,--------------------------------------------------.
+ * | ESC    |   1  |   2  |   3  |   4  |   5  |   6  |           |  7   |   8  |   9  |   0  |   -  |   =  | BCKSPC |
+ * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
+ * | TAB    |   Q  |   W  |   E  |   R  |   T  | HOME |           | PGUP |   Y  |   U  |   I  |   O  |   P  | DELETE |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * | `      |   A  |   S  |   D  |   F  |   G  |------|           |------|   H  |   J  |   K  |   L  |   ;  |  ENTER |
+ * |--------+------+------+------+------+------|  END |           | PGDN |------+------+------+------+------+--------|
+ * | (/LSFT |   Z  |   X  |   C  |   V  |   B  |      |           |      |   N  |   M  |   ,  |   .  |  UP  | )/RSFT |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ * | LCTRL  | LGUI | MENU |   '  |   "  |                                       |   [  |   ]  | LEFT | DOWN |  RIGHT |
+ * `------------------------------------'                                       `------------------------------------'
+ *                                        ,-------------.       ,-------------.
+ *                                        | VOL- | VOL+ |       |      |      |
+ *                                 ,------|------|------|       |------+------+------.
+ *                                 | SPC/ |SLASH/| MUTE |       |NUMLCK|WHACK/| SPC/ |
+ *                                 | ALT  | MO(1)|------|       |------|MO(1) | ALT  |
+ *                                 |      |      | LAY3 |       | LAY2 |      |      |
+ *                                 `--------------------'       `--------------------'
+ */
+[BASE] = KEYMAP(
+        // left hand
+        KC_ESC,     KC_1,       KC_2,       KC_3,       KC_4,       KC_5,       KC_6,
+        KC_TAB,     KC_Q,       KC_W,       KC_E,       KC_R,       KC_T,       KC_HOME,
+        KC_GRV,     KC_A,       KC_S,       KC_D,       KC_F,       KC_G,
+        KC_LSPO,    KC_Z,       KC_X,       KC_C,       KC_V,       KC_B,       KC_END,
+        KC_LCTL,    KC_LGUI,    KC_MENU,    KC_QUOT,    S(KC_QUOT),
+                                                                    KC_VOLD,    KC_VOLU,
+                                                                                KC_MUTE,
+                                            ALT_T(KC_SPC),  LT(ARRW,KC_SLSH),   TG(INTL),
+        // right hand
+            KC_7,       KC_8,       KC_9,       KC_0,       KC_MINS,    KC_EQL,     KC_BSPC,
+            KC_PGUP,    KC_Y,       KC_U,       KC_I,       KC_O,       KC_P,       KC_DEL,
+                        KC_H,       KC_J,       KC_K,       KC_L,       KC_SCLN,    KC_ENTER,
+            KC_PGDN,    KC_N,       KC_M,       KC_COMM,    KC_DOT,     KC_UP,      KC_RSPC,
+                                    KC_LBRC,    KC_RBRC,    KC_LEFT,    KC_DOWN,    KC_RGHT,
+            _______,     _______,
+            KC_NLCK,
+            TG(NUMP),   LT(ARRW,KC_BSLS),   ALT_T(KC_SPC)
+    ),
+
+/* layer 1: International symbols, etc
+ *
+ * ,--------------------------------------------------.           ,--------------------------------------------------.
+ * |     ´  |   ¡  |   ²  |   ³  |   ¤  |   €  |   ¼  |           |  ½   |  ¾   |  ‘   |  ’   |  ¥   |  ×   |        |
+ * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
+ * |        |   ä  |   å  |   é  |   ®  |   þ  |      |           |      |  ü   |  ú   |  í   |  ó   |  ö   |        |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |   á  |   ß  |   ð  |      |      |------|           |------|      |      |      |  ø   |  ¶   |        |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |MO(INSF)|   æ  |      |   ©  |      |      |      |           |      |  ñ   |  µ   |  ç   |      |      |MO(INSF)|
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ * |        |      |      |   ¬  |   ¿  |                                       |  «   |  »   |      |      |        |
+ * `------------------------------------'                                       `------------------------------------'
+ *                                        ,-------------.       ,-------------.
+ *                                        |      |      |       |      |      |
+ *                                 ,------|------|------|       |------+------+------.
+ *                                 |      |      |      |       |      |      |      |
+ *                                 |      |      |------|       |------|      |      |
+ *                                 |      |      |      |       |      |      |      |
+ *                                 `--------------------'       `--------------------'
+ */
+[INTL] = KEYMAP(
+        // left hand
+        UC(0x00B4), UC(0x00A1), UC(0x00B2), UC(0x00B3), UC(0x00A4), UC(0x20AC), UC(0x00BC),
+        _______,    UC(0x00E4), UC(0x00E5), UC(0x00E9), UC(0x00AE), UC(0x00FE), _______,
+        _______,    UC(0x00E1), UC(0x00DF), UC(0x00F0), _______,    _______,
+        MO(INSF),   UC(0x00E6), _______,    UC(0x00A9), _______,    _______,    _______,
+        _______,    _______,    _______,    UC(0x00AC), UC(0x00BF),
+                                            _______,    _______,
+                                                        _______,
+                            _______,        _______,    _______,
+        // right hand
+            UC(0x00BD), UC(0x00BE), UC(0x2018), UC(0x2019), UC(0x00A5), UC(0x00D7), _______,
+            _______,    UC(0x00FC), UC(0x00FA), UC(0x00ED), UC(0x00F3), UC(0x00F6), _______,
+                        _______,    _______,    _______,    UC(0x00F8), UC(0x00B6), _______,
+            _______,    UC(0x00F1), UC(0x00B5), UC(0x00E7), _______,    _______,    MO(INSF),
+                                    UC(0x00AB), UC(0x00BB), _______,    _______,    _______,
+            _______,    _______,
+            _______,
+            _______,    _______,    _______
+    ),
+
+/* layer 2 : international symbols, shifted
+ * This layer is an ugly workaround; it pretends that SHIFT still works normally on keys
+ * which don't produce an "upper case" or "shifted" international symobol.
+ *
+ * ,--------------------------------------------------.           ,--------------------------------------------------.
+ * |     ¨  |   ¹  |      |      |   £  |      |      |           |      |      |      |      |  —  |  ÷   |        |
+ * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
+ * |        |   Ä  |   Å  |   É  |      |   Þ  |      |           |      |  Ü   |  Ú   |  Í   |  Ó   |  Ö   |        |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |   Á  |   §  |   Ð  |      |      |------|           |------|      |      |      |  Ø   |  °   |        |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |   Æ  |      |   ¢  |      |      |      |           |      |  Ñ   |      |  Ç   |      |      |        |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ * |        |      |      |   ¦  |      |                                       |      |      |      |      |        |
+ * `------------------------------------'                                       `------------------------------------'
+ *                                        ,-------------.       ,-------------.
+ *                                        |      |      |       |      |      |
+ *                                 ,------|------|------|       |------+------+------.
+ *                                 |      |      |      |       |      |      |      |
+ *                                 |      |      |------|       |------|      |      |
+ *                                 |      |      |      |       |      |      |      |
+ *                                 `--------------------'       `--------------------'
+ */
+[INSF] = KEYMAP(
+        // left hand
+        UC(0x00A8), UC(0x00B9), _______,    _______,    UC(0x00A3), _______,    _______,
+        _______,    UC(0x00C4), UC(0x00C5), UC(0x00C9), _______,    UC(0x00DE), _______,
+        _______,    UC(0x00C1), UC(0x00A7), UC(0x00D0), S(KC_F),    S(KC_G),
+        _______,    UC(0x00C6), S(KC_X),    UC(0x00A2), S(KC_V),    S(KC_B),    _______,
+        _______,    _______,    _______,    UC(0x00A6), _______,
+                                                                    _______,    _______,
+                                                                                _______,
+                                                    _______,        _______,    _______,
+        // right hand
+            _______,    _______,    _______,    _______,    UC(0x2014), UC(0x00F7), _______,
+            _______,    UC(0x00DC), UC(0x00DA), UC(0x00CD), UC(0x00D3), UC(0x00D6), _______,
+                        S(KC_H),    S(KC_J),    S(KC_K),    UC(0x00D8), UC(0x00B0), _______,
+            _______,    UC(0x00D1), _______,    UC(0x00C7), S(KC_DOT),  _______,    _______,
+                                    _______,    _______,    _______,    _______,    _______,
+            _______,    _______,
+            _______,
+            _______,    _______,    _______
+    ),
+
+/* layer 3: numberpad
+ *
+ * ,--------------------------------------------------.           ,--------------------------------------------------.
+ * |        |      |      |      |      |      |      |           |      |      |   (  |   )  |   /  |  *   |        |
+ * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
+ * |        |      |      |      |      |      |      |           |      |      |   7  |   8  |   9  |  -   |        |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |      |      |      |      |      |------|           |------|      |   4  |   5  |   6  |  +   |        |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |      |      |      |      |      |      |           |      |      |   1  |   2  |   3  |  =   |        |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ * |        |      |      |      |      |                                       |   0  |   .  |   ,  | ENTER|        |
+ * `------------------------------------'                                       `------------------------------------'
+ *                                        ,-------------.       ,-------------.
+ *                                        |      |      |       |      |      |
+ *                                 ,------|------|------|       |------+------+------.
+ *                                 |      |      |      |       |      |      |      |
+ *                                 |      |      |------|       |------|      |      |
+ *                                 |      |      |      |       |      |      |      |
+ *                                 `--------------------'       `--------------------'
+ */
+[NUMP] = KEYMAP(
+        // left hand
+        _______,    _______,    _______,    _______,    _______,    _______,    _______,
+        _______,    _______,    _______,    _______,    _______,    _______,    _______,
+        _______,    _______,    _______,    _______,    _______,    _______,
+        _______,    _______,    _______,    _______,    _______,    _______,    _______,
+        _______,    _______,    _______,    _______,    _______,
+                                            _______,    _______,
+                                                        _______,
+                            _______,        _______,    _______,
+        // right hand
+            _______,    _______,    S(KC_9),    S(KC_0),    KC_PSLS,    KC_PAST,    _______,
+            _______,    _______,    KC_KP_7,    KC_KP_8,    KC_KP_9,    KC_PMNS,    _______,
+                        _______,    KC_KP_4,    KC_KP_5,    KC_KP_6,    KC_PPLS,    _______,
+            _______,    _______,    KC_KP_1,    KC_KP_2,    KC_KP_3,    KC_PEQL,    _______,
+                                    KC_KP_0,    KC_KP_DOT,  KC_PCMM,    KC_PENT,    _______,
+            _______,    _______,
+            _______,
+            _______,    _______,    _______
+    ),
+
+/* layer 4 : functions and arrows
+ * This layer is at the top so that the functions still work no matter what layers are active.
+ *
+ * ,--------------------------------------------------.           ,--------------------------------------------------.
+ * | ESCAPE |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |           |  F7  |  F8  |  F9  | F10  | F11  | F12  | SYSREQ |
+ * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
+ * |        |      |      |  UP  |      |      |      |           |      |      |      |      |      |      | INSERT |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |CAPSLOCK|      | LEFT | DOWN |RIGHT |      |------|           |------| LEFT | DOWN |  UP  | RIGHT|      |        |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |M_PREV|M_STOP|M_PLPS|M_NEXT|      |      |           |      |      |      |      |      | PGUP |        |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ * |        |      |      |      |      |                                       |      |      | HOME | PGDN |    END |
+ * `------------------------------------'                                       `------------------------------------'
+ *                                        ,-------------.       ,-------------.
+ *                                        |      | PAUSE|       |      |      |
+ *                                 ,------|------|------|       |------+------+------.
+ *                                 |      |      |      |       |SCRLK |      |      |
+ *                                 |      |      |------|       |------|      |      |
+ *                                 |      |      |      |       |      |      |      |
+ *                                 `--------------------'       `--------------------'
+ */
+[ARRW] = KEYMAP(
+        // left hand
+        KC_ESC,     KC_F1,      KC_F2,      KC_F3,      KC_F4,      KC_F5,      KC_F6,
+        _______,    _______,    _______,    KC_UP,      _______,    _______,    _______,
+        KC_CAPS,    _______,    KC_LEFT,    KC_DOWN,    KC_RGHT,    _______,
+        _______,    _______,    _______,    _______,    _______,    _______,    _______,
+        _______,    _______,    _______,    _______,    _______,
+                                                                    _______,    KC_PAUSE,
+                                                                                _______,
+                                                    _______,        _______,    _______,
+        // right hand
+            KC_F7,      KC_F8,      KC_F9,      KC_F10,     KC_F11,     KC_F12,     KC_SYSREQ,
+            _______,    _______,    _______,    _______,    _______,    _______,    KC_INS,
+                        KC_LEFT,    KC_DOWN,    KC_UP,      KC_RGHT,    _______,    _______,
+            _______,    _______,    _______,    _______,    _______,    KC_PGUP,    _______,
+                                    _______,    _______,    KC_HOME,    KC_PGDN,    KC_END,
+            _______,    _______,
+            KC_SLCK,
+            _______,    _______,    _______
+    ),
+};
+
+// Runs just one time when the keyboard initializes.
+void matrix_init_user(void) {
+    set_unicode_input_mode(UC_LNX); // Linux
+    //set_unicode_input_mode(UC_OSX); // Mac OSX
+    //set_unicode_input_mode(UC_WIN); // Windows (with registry key, see wiki)
+    //set_unicode_input_mode(UC_WINC); // Windows (with WinCompose, see wiki)
+};
+
+// Runs constantly in the background, in a loop.
+void matrix_scan_user(void) {
+
+    uint8_t layer = biton32(layer_state);
+
+    ergodox_board_led_off();
+    ergodox_right_led_1_off();
+    ergodox_right_led_2_off();
+    ergodox_right_led_3_off();
+    switch (layer) {
+        case INTL:
+        case INSF:
+            ergodox_right_led_1_on();
+            break;
+        case NUMP:
+            ergodox_right_led_2_on();
+            break;
+        case ARRW:
+            ergodox_right_led_3_on();
+            break;
+        default:
+            // none
+            break;
+    }
+
+};

keyboards/ergodox/keymaps/ordinary/keymap.c

@@ -392,7 +392,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 
         case NotEq:
         if (record->event.pressed) {
-            return MACRO( I(10), D(LSFT), T(EXLM), U(LSFT), T(EQL), END  ); // !=
+            return MACRO( I(10), D(LSFT), T(1), U(LSFT), T(EQL), END  ); // !=
         }
         break;
 

keyboards/ergodox/keymaps/siroken3/keymap.c

@@ -0,0 +1,187 @@
+// Netable differences vs. the default firmware for the ErgoDox EZ:
+// 1. The Cmd key is now on the right side, making Cmd+Space easier.
+// 2. The media keys work on OSX (But not on Windows).
+#include "ergodox.h"
+#include "debug.h"
+#include "action_layer.h"
+
+#define BASE 0 // default layer
+#define SYMB 1 // symbols
+#define MDIA 2 // media keys
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+/* Keymap 0: Basic layer
+ *
+ * ,--------------------------------------------------.           ,--------------------------------------------------.
+ * |   =    |   1  |   2  |   3  |   4  |   5  | LEFT |           | RIGHT|   6  |   7  |   8  |   9  |   0  |   -    |
+ * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
+ * | Tab    |   Q  |   W  |   E  |   R  |   T  |  L1  |           |  L1  |   Y  |   U  |   I  |   O  |   P  |   \    |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * | LCtl   |   A  |   S  |   D  |   F  |   G  |------|           |------|   H  |   J  |   K  |   L  |; / L2|  LGui  |
+ * |--------+------+------+------+------+------| BkSp |           | Meh  |------+------+------+------+------+--------|
+ * | LShift |Z/Ctrl|   X  |   C  |   V  |   B  |      |           |      |   N  |   M  |   ,  |   .  |//Ctrl| RShift |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ *   |Grv/L1|  '"  |AltShf| Left | Right|                                       |  Up  | Down |   [  |   ]  | ~L1  |
+ *   `----------------------------------'                                       `----------------------------------'
+ *                                        ,-------------.       ,---------------.
+ *                                        | BkSp | LGui |       | Alt  |Ctrl/Esc|
+ *                                 ,------|------|------|       |------+--------+------.
+ *                                 |      |      | Home |       | PgUp |        |      |
+ *                                 | Space|LANG1 |------|       |------|LANG2   |Enter |
+ *                                 | /LGui|      | End  |       | PgDn |        |      |
+ *                                 `--------------------'       `----------------------'
+ */
+// If it accepts an argument (i.e, is a function), it doesn't need KC_.
+// Otherwise, it needs KC_*
+[BASE] = KEYMAP(  // layer 0 : default
+        // left hand
+        KC_EQL,         KC_1,         KC_2,   KC_3,   KC_4,   KC_5,   KC_LEFT,
+        KC_TAB,         KC_Q,         KC_W,   KC_E,   KC_R,   KC_T,   TG(SYMB),
+        KC_LCTRL,       KC_A,         KC_S,   KC_D,   KC_F,   KC_G,
+        KC_LSFT,        CTL_T(KC_Z),  KC_X,   KC_C,   KC_V,   KC_B,   KC_BSPC,
+        LT(SYMB,KC_GRV),KC_QUOT,      LALT(KC_LSFT),  KC_LEFT,KC_RGHT,
+                                                    KC_BSPC,  KC_LGUI,
+                                                              KC_HOME,
+                                 MT(MOD_LGUI, KC_SPC),KC_LANG1,KC_END,
+        // right hand
+             KC_RGHT,     KC_6,   KC_7,   KC_8,   KC_9,   KC_0,             KC_MINS,
+             TG(SYMB),       KC_Y,   KC_U,   KC_I,   KC_O,   KC_P,             KC_BSLS,
+                          KC_H,   KC_J,   KC_K,   KC_L,   LT(MDIA, KC_SCLN),KC_LGUI,
+             MEH_T(KC_NO),KC_N,   KC_M,   KC_COMM,KC_DOT, CTL_T(KC_SLSH),   KC_RSFT,
+                                  KC_UP,  KC_DOWN,KC_LBRC,KC_RBRC,          KC_FN1,
+             KC_LALT,        CTL_T(KC_ESC),
+             KC_PGUP,
+             KC_PGDN,KC_LANG2, KC_ENT
+    ),
+/* Keymap 1: Symbol Layer
+ *
+ * ,--------------------------------------------------.           ,--------------------------------------------------.
+ * |        |  F1  |  F2  |  F3  |  F4  |  F5  |      |           |      |  F6  |  F7  |  F8  |  F9  |  F10 |   F11  |
+ * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
+ * |        |   !  |   @  |   {  |   }  |   |  |      |           |      |   Up |   7  |   8  |   9  |   *  |   F12  |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |   #  |   $  |   (  |   )  |   `  |------|           |------| Down |   4  |   5  |   6  |   +  |        |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |   %  |   ^  |   [  |   ]  |   ~  |      |           |      |   &  |   1  |   2  |   3  |   \  |        |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ *   |      |      |      |      |      |                                       |      |    . |   0  |   =  |      |
+ *   `----------------------------------'                                       `----------------------------------'
+ *                                        ,-------------.       ,-------------.
+ *                                        |      |      |       |      |      |
+ *                                 ,------|------|------|       |------+------+------.
+ *                                 |      |      |      |       |      |      |      |
+ *                                 |      |      |------|       |------|      |      |
+ *                                 |      |      |      |       |      |      |      |
+ *                                 `--------------------'       `--------------------'
+ */
+// SYMBOLS
+[SYMB] = KEYMAP(
+       // left hand
+       KC_TRNS,KC_F1,  KC_F2,  KC_F3,  KC_F4,  KC_F5,  KC_TRNS,
+       KC_TRNS,KC_EXLM,KC_AT,  KC_LCBR,KC_RCBR,KC_PIPE,KC_TRNS,
+       KC_TRNS,KC_HASH,KC_DLR, KC_LPRN,KC_RPRN,KC_GRV,
+       KC_TRNS,KC_PERC,KC_CIRC,KC_LBRC,KC_RBRC,KC_TILD,KC_TRNS,
+       KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,
+                                       KC_TRNS,KC_TRNS,
+                                               KC_TRNS,
+                               KC_TRNS,KC_TRNS,KC_TRNS,
+       // right hand
+       KC_TRNS, KC_F6,   KC_F7,  KC_F8,   KC_F9,   KC_F10,  KC_F11,
+       KC_TRNS, KC_UP,   KC_7,   KC_8,    KC_9,    KC_ASTR, KC_F12,
+                KC_DOWN, KC_4,   KC_5,    KC_6,    KC_PLUS, KC_TRNS,
+       KC_TRNS, KC_AMPR, KC_1,   KC_2,    KC_3,    KC_BSLS, KC_TRNS,
+                         KC_TRNS,KC_DOT,  KC_0,    KC_EQL,  KC_TRNS,
+       KC_TRNS, KC_TRNS,
+       KC_TRNS,
+       KC_TRNS, KC_TRNS, KC_TRNS
+),
+/* Keymap 2: Media and mouse keys
+ *
+ * ,--------------------------------------------------.           ,--------------------------------------------------.
+ * |        |      |      |      |      |      |      |           |      |      |      |      |      |      |        |
+ * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
+ * |        |      |      | MsUp |      |      |      |           |      |      |      |      |      |      |        |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |      |MsLeft|MsDown|MsRght|      |------|           |------|      |      |      |      |      |  Play  |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |      |      |      |      |      |      |           |      |      |      | Prev | Next |      |        |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ *   |      |      |      | Lclk | Rclk |                                       |VolUp |VolDn | Mute |      |      |
+ *   `----------------------------------'                                       `----------------------------------'
+ *                                        ,-------------.       ,-------------.
+ *                                        |      |      |       |      |      |
+ *                                 ,------|------|------|       |------+------+------.
+ *                                 |      |      |      |       |      |      |Brwser|
+ *                                 |      |      |------|       |------|      |Back  |
+ *                                 |      |      |      |       |      |      |      |
+ *                                 `--------------------'       `--------------------'
+ */
+// MEDIA AND MOUSE
+[MDIA] = KEYMAP(
+       KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+       KC_TRNS, KC_TRNS, KC_TRNS, KC_MS_U, KC_TRNS, KC_TRNS, KC_TRNS,
+       KC_TRNS, KC_TRNS, KC_MS_L, KC_MS_D, KC_MS_R, KC_TRNS,
+       KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+       KC_TRNS, KC_TRNS, KC_TRNS, KC_BTN1, KC_BTN2,
+                                           KC_TRNS, KC_TRNS,
+                                                    KC_TRNS,
+                                  KC_TRNS, KC_TRNS, KC_TRNS,
+    // right hand
+       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_MPLY,
+       KC_TRNS,  KC_TRNS, KC_TRNS, KC_MPRV, KC_MNXT, KC_TRNS, KC_TRNS,
+                          KC_VOLU, KC_VOLD, KC_MUTE, KC_TRNS, KC_TRNS,
+       KC_TRNS, KC_TRNS,
+       KC_TRNS,
+       KC_TRNS, KC_TRNS, KC_WBAK
+),
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+    [1] = ACTION_LAYER_TAP_TOGGLE(SYMB)                // FN1 - Momentary Layer 1 (Symbols)
+};
+
+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;
+};
+
+// Runs just one time when the keyboard initializes.
+void matrix_init_user(void) {
+
+};
+
+// Runs constantly in the background, in a loop.
+void matrix_scan_user(void) {
+
+    uint8_t layer = biton32(layer_state);
+
+    ergodox_board_led_off();
+    ergodox_right_led_1_off();
+    ergodox_right_led_2_off();
+    ergodox_right_led_3_off();
+    switch (layer) {
+      // TODO: Make this relevant to the ErgoDox EZ.
+        case 1:
+            ergodox_right_led_1_on();
+            break;
+        case 2:
+            ergodox_right_led_2_on();
+            break;
+        default:
+            // none
+            break;
+    }
+
+};

keyboards/ergodox/keymaps/siroken3/readme.md

@@ -0,0 +1,15 @@
+# ErgoDox EZ Default Configuration
+
+## Changelog
+
+* Dec 2016:
+  * Added LED keys
+  * Refreshed layout graphic, comes from http://configure.ergodox-ez.com now.
+* Sep 22, 2016:
+  * Created a new key in layer 1 (bottom-corner key) that resets the EEPROM.
+* Feb 2, 2016 (V1.1): 
+  * Made the right-hand quote key double as Cmd/Win on hold. So you get ' when you tap it, " when you tap it with Shift, and Cmd or Win when you hold it. You can then use it as a modifier, or just press and hold it for a moment (and then let go) to send a single Cmd or Win keystroke (handy for opening the Start menu on Windows).
+
+This is what we ship with out of the factory. :) The image says it all:
+
+![Default](default_firmware_v1.2-2.png)

keyboards/ergodox/keymaps/xyverz/keymap.c

@@ -40,7 +40,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 /* Layer 0 : Dvorak
  * ,--------------------------------------------------. ,--------------------------------------------------.
- * |   ]    |   1  |   2  |   3  |   4  |   5  | ESC  | | ESC  |   6  |   7  |   8  |   9  |   0  |   [    |
+ * |   =    |   1  |   2  |   3  |   4  |   5  | ESC  | | ESC  |   6  |   7  |   8  |   9  |   0  |   /    |
  * |--------+------+------+------+------+-------------| |------+------+------+------+------+------+--------|
  * | Tab    |   '  |   ,  |   .  |   P  |   Y  |      | |      |   F  |   G  |   C  |   R  |   L  |   \    |
  * |--------+------+------+------+------+------|      | |      |------+------+------+------+------+--------|
@@ -48,7 +48,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |--------+------+------+------+------+------| _MD  | | _KP  |------+------+------+------+------+--------|
  * | LShift |   ;  |   Q  |   J  |   K  |   X  |      | |      |   B  |   M  |   W  |   V  |   Z  | RShift |
  * `--------+------+------+------+------+-------------' `-------------+------+------+------+------+--------'
- *   | LGUI |   `  |  INS | Left | Rght |                             |  Up  |  Dn  |   /  |   =  | RGUI |
+ *   | LGUI |   `  |  INS | Left | Rght |                             |  Up  |  Dn  |   [  |   ]  | RGUI |
  *   `----------------------------------'                             `----------------------------------'
  *                                      ,-------------. ,-------------.
  *                                      | LCTL | LALT | | RALT | RCTL |
@@ -61,7 +61,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  */
 [_DV] = KEYMAP(
         // left hand
-        KC_RBRC, KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_ESC,
+        KC_EQL,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_ESC,
         KC_TAB,  KC_QUOT, KC_COMM, KC_DOT,  KC_P,    KC_Y,    XXXXXXX,
         KC_CAPS, KC_A,    KC_O,    KC_E,    KC_U,    KC_I,
         KC_LSFT, KC_SCLN, KC_Q,    KC_J,    KC_K,    KC_X,    MO(_MD),
@@ -70,11 +70,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                                                      KC_HOME,
                                    KC_BSPC, KC_DEL,  KC_END,
         // right hand
-        KC_ESC,  KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_LBRC,
+        KC_ESC,  KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_SLSH,
         XXXXXXX, KC_F,    KC_G,    KC_C,    KC_R,    KC_L,    KC_BSLS,
                  KC_D,    KC_H,    KC_T,    KC_N,    KC_S,    KC_MINS,
         MO(_KP), KC_B,    KC_M,    KC_W,    KC_V,    KC_Z,    KC_RSFT,
-                          KC_UP,   KC_DOWN, KC_SLSH, KC_EQL,  KC_RGUI,
+                          KC_UP,   KC_DOWN, KC_LBRC, KC_RBRC, KC_RGUI,
         KC_RALT, KC_RCTL,
         KC_PGUP,
         KC_PGDN, KC_ENT,  KC_SPC
@@ -91,7 +91,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |--------+------+------+------+------+------| _MD  | | _KP  |------+------+------+------+------+--------|
  * | LShift |   Z  |   X  |   C  |   V  |   B  |      | |      |   N  |   M  |   ,  |   .  |   /  | RShift |
  * `--------+------+------+------+------+-------------' `-------------+------+------+------+------+--------'
- *   | LGUI |   `  |  INS | Left | Rght |                             |  Up  |  Dn  |   /  |   =  | RGUI |
+ *   | LGUI |   `  |  INS | Left | Rght |                             |  Up  |  Dn  |   [  |   ]  | RGUI |
  *   `----------------------------------'                             `----------------------------------'
  *                                      ,-------------. ,-------------.
  *                                      | LCTL | LALT | | RALT | RCTL |
@@ -133,7 +133,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |--------+------+------+------+------+------| _MD  | | _KP  |------+------+------+------+------+--------|
  * | LShift |   Z  |   X  |   C  |   V  |   B  |      | |      |   K  |   M  |   ,  |   .  |   /  | RShift |
  * `--------+------+------+------+------+-------------' `-------------+------+------+------+------+--------'
- *   | LGUI |   `  |  INS | Left | Rght |                             |  Up  |  Dn  |   /  |   =  | RGUI |
+ *   | LGUI |   `  |  INS | Left | Rght |                             |  Up  |  Dn  |   [  |   ]  | RGUI |
  *   `----------------------------------'                             `----------------------------------'
  *                                      ,-------------. ,-------------.
  *                                      | LCTL | LALT | | RALT | RCTL |

keyboards/ergodox/keymaps/xyverz/readme.md

@@ -2,7 +2,7 @@
 
 ## About this keymap:
 
-The Dvorak layout shown herestems from my early Kinesis years, using the Contour PS/2 with a Dvorak software layout. Because of this, the RBRC and LBRC were on opposite sides of the board in the corner keys. I've decided to continue using this layout with my ErgoDox.
+The Dvorak layout shown here stems from my early Kinesis years, using the Contour PS/2 with a Dvorak software layout. ~~Because of this, the RBRC and LBRC were on opposite sides of the board in the corner keys. I've decided to continue using this layout with my ErgoDox.~~ I've decided do give the normal placing of the SLSH, EQL, and xBRC keys a try, after using a different keyboard for a while...
 
 The QWERTY layout shown here is based entirely on the Kinesis Advantage layout, with the additional keys as shown in the diagrams. The Colemak layout is merely an adaptation of that.
 
@@ -17,15 +17,15 @@ I've enabled persistent keymaps for Qwerty, Dvorak and Colemak layers, similar t
 ### Layer 0: Dvorak layer
 
 	,--------------------------------------------------.,--------------------------------------------------.
-	|   ]    |   1  |   2  |   3  |   4  |   5  | ESC  || ESC  |   6  |   7  |   8  |   9  |   0  |   [    |
+	|   =    |   1  |   2  |   3  |   4  |   5  | ESC  || ESC  |   6  |   7  |   8  |   9  |   0  |   /    |
 	|--------+------+------+------+------+-------------||------+------+------+------+------+------+--------|
-	| Tab    |   '  |   ,  |   .  |   Y  |   Y  |      ||      |   F  |   G  |   C  |   R  |   L  |   \    |
+	| Tab    |   '  |   ,  |   .  |   P  |   Y  |      ||      |   F  |   G  |   C  |   R  |   L  |   \    |
 	|--------+------+------+------+------+------|      ||      |------+------+------+------+------+--------|
 	| CapsLk |   A  |   O  |   E  |   U  |   I  |------||------|   D  |   H  |   T  |   N  |   S  |   -    |
 	|--------+------+------+------+------+------| _MD  || _KP  |------+------+------+------+------+--------|
 	| LShift |   Z  |   X  |   C  |   V  |   X  |      ||      |   B  |   M  |   W  |   V  |   Z  | RShift |
 	`--------+------+------+------+------+-------------'`-------------+------+------+------+------+--------'
-	  | LGUI |   `  |  INS | Left | Rght |                            |  Up  |  Dn  |   /  |   =  | RGUI |
+	  | LGUI |   `  |  INS | Left | Rght |                            |  Up  |  Dn  |   [  |   ]  | RGUI |
 	  `----------------------------------'                            `----------------------------------'
 	                                     ,-------------.,-------------.
 	                                     | LCtr | LAlt || Ralt | RCtr |

keyboards/ergodox/keymaps/yoruian/keymap.c

@@ -17,7 +17,7 @@
 #include "yoruian.h"
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-[0] = KEYMAP\
+[0] = KEYMAP_YORUIAN\
 (9,  7,    5,    3,    1,    GRV,  MINS, EQL,  LBRC, 0,    2,    4,    6,    8,
  ES, RBRC, Y,    O,    R,    BSLS, P3,   P3,   J,    V,    D,    F,    W,    Q,
  LC, U,    I,    A,    N,    SCLN,             M,    H,    T,    S,    C,    RC,
@@ -26,7 +26,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                              BSPC, RALT, P2,   TAB,
                                    NO,   NO,
                        E,    LSFT, NO,   NO,   ENT,  SPC),
-[1] = KEYMAP\
+[1] = KEYMAP_YORUIAN\
 (TR, TR,   TR,   TR,   TR,   TR,   TR,   TR,   TR,   F5,   F6,   F7,   F8,   F9,
  TR, TR,   TR,   TR,   TR,   TR,   TR,   TR,   TR,   F1,   F2,   F3,   F4,   FT,
  TR, TR,   TR,   TR,   TR,   TR,               PAUS, LEFT, DOWN, UP,   RGHT, FE,

keyboards/ergodox/keymaps/yoruian/yoruian.h

@@ -18,36 +18,32 @@
 #include "debug.h"
 #include "action_layer.h"
 
-#undef KEYMAP
+#define KEYMAP_YORUIAN(                                                        \
-#define KEYMAP\
+ /* Spacial positions. */                                                      \
-(									\
+ k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0A, k0B, k0C, k0D,         \
- /* Spacial positions. */						\
+ k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1A, k1B, k1C, k1D,         \
- k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0A, k0B, k0C, k0D,	\
+ k20, k21, k22, k23, k24, k25,           k28, k29, k2A, k2B, k2C, k2D,         \
- k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1A, k1B, k1C, k1D,	\
+ k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3A, k3B, k3C, k3D,         \
- k20, k21, k22, k23, k24, k25,           k28, k29, k2A, k2B, k2C, k2D,	\
+ k40, k41, k42, k43, k44,                     k49, k4A, k4B, k4C, k4D,         \
- k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3A, k3B, k3C, k3D,	\
+                          k55, k56, k57, k58,                                  \
- k40, k41, k42, k43, k44,                     k49, k4A, k4B, k4C, k4D,	\
+                               k54, k59,                                       \
-                          k55, k56, k57, k58,                           \
+                     k53, k52, k51, k5C, k5B, k5A)                             \
-                               k54, k59,                                \
+  KEYMAP(KC_##k00, KC_##k01, KC_##k02, KC_##k03, KC_##k04, KC_##k05, KC_##k06, \
-                     k53, k52, k51, k5C, k5B, k5A)                      \
+         KC_##k10, KC_##k11, KC_##k12, KC_##k13, KC_##k14, KC_##k15, KC_##k16, \
-									\
+         KC_##k20, KC_##k21, KC_##k22, KC_##k23, KC_##k24, KC_##k25,           \
- /* Matrix positions. */						\
+         KC_##k30, KC_##k31, KC_##k32, KC_##k33, KC_##k34, KC_##k35, KC_##k36, \
- {									\
+         KC_##k40, KC_##k41, KC_##k42, KC_##k43, KC_##k44,                     \
-   { KC_##k00, KC_##k10, KC_##k20, KC_##k30, KC_##k40, KC_NO    },	\
+                                                           KC_##k55, KC_##k56, \
-   { KC_##k01, KC_##k11, KC_##k21, KC_##k31, KC_##k41, KC_##k51 },      \
+                                                                     KC_##k54, \
-   { KC_##k02, KC_##k12, KC_##k22, KC_##k32, KC_##k42, KC_##k52 },      \
+                                                 KC_##k53, KC_##k52, KC_##k51, \
-   { KC_##k03, KC_##k13, KC_##k23, KC_##k33, KC_##k43, KC_##k53 },      \
+         KC_##k07, KC_##k08, KC_##k09, KC_##k0A, KC_##k0B, KC_##k0C, KC_##k0D, \
-   { KC_##k04, KC_##k14, KC_##k24, KC_##k34, KC_##k44, KC_##k54 },      \
+         KC_##k17, KC_##k18, KC_##k19, KC_##k1A, KC_##k1B, KC_##k1C, KC_##k1D, \
-   { KC_##k05, KC_##k15, KC_##k25, KC_##k35, KC_NO,    KC_##k55 },      \
+                   KC_##k28, KC_##k29, KC_##k2A, KC_##k2B, KC_##k2C, KC_##k2D, \
-   { KC_##k06, KC_##k16, KC_NO,    KC_##k36, KC_NO,    KC_##k56 },      \
+         KC_##k37, KC_##k38, KC_##k39, KC_##k3A, KC_##k3B, KC_##k3C, KC_##k3D, \
-   { KC_##k07, KC_##k17, KC_NO,    KC_##k37, KC_NO,    KC_##k57 },      \
+                             KC_##k49, KC_##k4A, KC_##k4B, KC_##k4C, KC_##k4D, \
-   { KC_##k08, KC_##k18, KC_##k28, KC_##k38, KC_NO,    KC_##k58 },      \
+         KC_##k57, KC_##k58,                                                   \
-   { KC_##k09, KC_##k19, KC_##k29, KC_##k39, KC_##k49, KC_##k59 },      \
+         KC_##k59,                                                             \
-   { KC_##k0A, KC_##k1A, KC_##k2A, KC_##k3A, KC_##k4A, KC_##k5A },      \
+         KC_##k5C, KC_##k5B, KC_##k5A)
-   { KC_##k0B, KC_##k1B, KC_##k2B, KC_##k3B, KC_##k4B, KC_##k5B },      \
-   { KC_##k0C, KC_##k1C, KC_##k2C, KC_##k3C, KC_##k4C, KC_##k5C },      \
-   { KC_##k0D, KC_##k1D, KC_##k2D, KC_##k3D, KC_##k4D, KC_NO    }       \
- }
 
 #define KC_ES  KC_ESC
 #define KC_LC  KC_LCTL

keyboards/frosty_flake/matrix.c

@@ -115,6 +115,7 @@ inline matrix_row_t matrix_get_row(uint8_t row) {
 }
 
 void matrix_print(void) {
+#ifndef NO_PRINT
     print("\nr\\c ABCDEFGHIJKLMNOPQR\n");
     for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
         matrix_row_t matrix_row = matrix_get_row(row);
@@ -125,6 +126,7 @@ void matrix_print(void) {
         }
         print("\n");
     }
+#endif
 }
 
 uint8_t matrix_key_count(void) {
@@ -132,4 +134,4 @@ uint8_t matrix_key_count(void) {
     for (uint8_t row = 0; row < MATRIX_ROWS; row++)
         count += bitpop32(matrix[row]);
     return count;
-}
+}

keyboards/gh60/keymaps/dbroqua_7U/Makefile

@@ -0,0 +1,111 @@
+#----------------------------------------------------------------------------
+# On command line:
+#
+# make all = Make software.
+#
+# make clean = Clean out built project files.
+#
+# make coff = Convert ELF to AVR COFF.
+#
+# make extcoff = Convert ELF to AVR Extended COFF.
+#
+# make program = Download the hex file to the device.
+#                Please customize your programmer settings(PROGRAM_CMD)
+#
+# make teensy = Download the hex file to the device, using teensy_loader_cli.
+#               (must have teensy_loader_cli installed).
+#
+# make dfu = Download the hex file to the device, using dfu-programmer (must
+#            have dfu-programmer installed).
+#
+# make flip = Download the hex file to the device, using Atmel FLIP (must
+#             have Atmel FLIP installed).
+#
+# make dfu-ee = Download the eeprom file to the device, using dfu-programmer
+#               (must have dfu-programmer installed).
+#
+# make flip-ee = Download the eeprom file to the device, using Atmel FLIP
+#                (must have Atmel FLIP installed).
+#
+# make debug = Start either simulavr or avarice as specified for debugging, 
+#              with avr-gdb or avr-insight as the front end for debugging.
+#
+# make filename.s = Just compile filename.c into the assembler code only.
+#
+# make filename.i = Create a preprocessed source file for use in submitting
+#                   bug reports to the GCC project.
+#
+# To rebuild project do "make clean" then "make all".
+#----------------------------------------------------------------------------
+
+# MCU name
+#MCU = at90usb1287
+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
+#   comment out to disable the options.
+#
+BOOTMAGIC_ENABLE ?= yes		# Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE ?= yes		# Mouse keys(+4700)
+EXTRAKEY_ENABLE ?= yes		# Audio control and System control(+450)
+# CONSOLE_ENABLE ?= yes		# Console for debug(+400)
+# COMMAND_ENABLE ?= yes		# Commands for debug and configuration
+KEYBOARD_LOCK_ENABLE ?= yes	# Allow locking of keyboard via magic key
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+SLEEP_LED_ENABLE ?= yes	    # Breathing sleep LED during USB suspend
+NKRO_ENABLE ?= yes		    # USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+# BACKLIGHT_ENABLE ?= yes	# Enable keyboard backlight functionality
+# MIDI_ENABLE ?= YES		# MIDI controls
+# UNICODE_ENABLE ?= YES		# Unicode
+# BLUETOOTH_ENABLE ?= yes	# Enable Bluetooth with the Adafruit EZ-Key HID
+RGBLIGHT_ENABLE ?= no    # Enable RGB Underglow
+
+ifndef QUANTUM_DIR
+	include ../../../../Makefile
+endif

keyboards/gh60/keymaps/dbroqua_7U/keymap.c

@@ -0,0 +1,88 @@
+#include "gh60.h"
+#include "action_layer.h"
+
+#define _DEFAULT 0
+#define _FN 1
+
+int esc_led = 0;
+
+// Fillers to make layering more clear
+#define ______ KC_TRNS
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+/* Qwerty gui/alt/space/alt/gui
+ * ,-----------------------------------------------------------------------------------------.
+ * | Esc |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  |  0  |  -  |  =  |  \  |  `  |
+ * |-----------------------------------------------------------------------------------------+
+ * | Tab    |  Q  |  W  |  E  |  R  |  T  |  Y  |  U  |  I  |  O  |  P  |  [  |  ]  |  Bksp  |
+ * |-----------------------------------------------------------------------------------------+
+ * | Ctrl    |  A  |  S  |  D  |  F  |  G  |  H  |  J  |  K  |  L  |  ;  |  '  |    Enter    |
+ * |-----------------------------------------------------------------------------------------+
+ * | Shift     |  Z  |  X  |  C  |  V  |  B  |  N  |  M  |  ,  |  .  |  /  | RShift    | FN  |
+ * |-----------------------------------------------------------------------------------------+
+ *         |LGUI | LAlt  |               Space                | RAlt   |RGUI |
+ *         `-----------------------------------------------------------------'
+ */
+  [_DEFAULT] = KEYMAP_HHKB( /* Basic QWERTY */
+      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_BSLS, KC_GRV, \
+      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_BSPC,  \
+      KC_LCTL, KC_A,    KC_S,    KC_D, KC_F, KC_G,   KC_H, KC_J, KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_ENT,  \
+      KC_LSFT, KC_Z,    KC_X,    KC_C, KC_V, KC_B,   KC_N, KC_M, KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT, MO(_FN), \
+      ______,  KC_LGUI, KC_LALT,             KC_SPC,             ______,  KC_RALT, KC_RGUI, ______ \
+      ),
+
+/* FN Layer
+ * ,-----------------------------------------------------------------------------------------.
+ * | Led | F1  | F2  | F3  | F4  | F5  | F6  | F7  | F8  | F9  | F10 | F11 | F12 | Ins | Del |
+ * |-----------------------------------------------------------------------------------------+
+ * |  CAPS  |     |     |     |     |     |     |     | Psc | Slck| Paus| Up  |     |        |
+ * |-----------------------------------------------------------------------------------------+
+ * |         | Vol-| Vol+| Mute|     |     | *   | /   | Home| PgUp| Left|Right|             |
+ * |-----------------------------------------------------------------------------------------+
+ * |           | Prev| Play| Next|     |     | +   | -   | End  |PgDn| Down|           |     |
+ * |-----------------------------------------------------------------------------------------+
+ *         |       |       |                                 | Stop  |       |
+ *         `-----------------------------------------------------------------'
+ */
+  [_FN] = KEYMAP_HHKB( /* Layer 1 */
+      F(0),   KC_F1,   KC_F2,   KC_F3,   KC_F4,  KC_F5,  KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11, KC_F12, KC_INS,  KC_DEL, \
+      KC_CAPS, ______,  ______,  ______,  ______, ______, ______,  ______,  KC_PSCR, KC_SLCK, KC_PAUS, KC_UP,  ______, ______,  \
+      ______,  KC_VOLD, KC_VOLU, KC_MUTE, ______, ______, KC_PAST, KC_PSLS, KC_HOME, KC_PGUP, KC_LEFT, KC_RGHT,______,   \
+      ______,  KC_MPRV, KC_MPLY, KC_MNXT, ______, ______, KC_PPLS, KC_PMNS, KC_END,  KC_PGDN, KC_DOWN, ______, ______,  \
+      ______,  ______,  ______,                   ______,                   ______,  KC_MSTP, ______,  ______ \
+      )
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+  // MACRODOWN only works in this function
+  return MACRO_NONE;
+};
+
+enum function_id {
+    LED_TOGGLE
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+  [0]  = ACTION_FUNCTION(LED_TOGGLE)
+};
+
+void esc_led_toggle(void) {
+    if (esc_led == 0){
+        esc_led = 1;
+        gh60_esc_led_on();
+    } else {
+        esc_led = 0;
+        gh60_esc_led_off();
+    }
+}
+
+void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
+  switch (id) {
+    case LED_TOGGLE:
+      if (record->event.pressed) {
+        esc_led_toggle();
+      }
+      break;
+  }
+}

keyboards/gh60/keymaps/xyverz/keymap.c

@@ -0,0 +1,149 @@
+#include "gh60.h"
+#include "action_layer.h"
+#include "eeconfig.h"
+
+
+extern keymap_config_t keymap_config;
+
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+#define _QW 0
+#define _DV 1
+#define _CM 2
+#define _FL 3
+
+// Macro name shortcuts
+#define QWERTY M(_QW)
+#define DVORAK M(_DV)
+#define COLEMAK M(_CM)
+
+// Fillers to make layering more clear
+#define _______ KC_TRNS
+#define XXXXXXX KC_NO
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+    /*
+     *  _QW: Qwerty Layer
+     * ,-----------------------------------------------------------.
+     * |ESC | 1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =| Backsp|
+     * |-----------------------------------------------------------|
+     * |Tab  |  Q|  W|  E|  R|  T|  Y|  U|  I|  O|  P|  [|  ]|    \|
+     * |-----------------------------------------------------------|
+     * |Fn     |  A|  S|  D|  F|  G|  H|  J|  K|  L|  ;|  '| Return|
+     * |-----------------------------------------------------------|
+     * |Shift   |  Z|  X|  C|  V|  B|  N|  M|  ,|  .|  /|     Shift|
+     * |-----------------------------------------------------------|
+     * |Ctrl|Alt |Gui |      Space             |Gui |Alt |Ctrl|  Fn|
+     * `-----------------------------------------------------------'
+     */
+[_QW] = { /* Layer 0: Qwerty */
+    {KC_ESC,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC},
+    {KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_BSLS},
+    {MO(_FL), KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, XXXXXXX, KC_ENT },
+    {KC_LSFT, XXXXXXX, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, XXXXXXX, KC_RSFT},
+    {KC_LCTL, KC_LALT, KC_LGUI, XXXXXXX, XXXXXXX, KC_SPC,  XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_RGUI, KC_RALT, KC_RCTL, MO(_FL)}
+  },
+
+    /*
+     *  _DV: Dvorak Layer
+     * ,-----------------------------------------------------------.
+     * |ESC | 1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  [|  ]| Backsp|
+     * |-----------------------------------------------------------|
+     * |Tab  |  '|  ,|  .|  P|  Y|  F|  G|  C|  R|  L|  /|  =|    \|
+     * |-----------------------------------------------------------|
+     * |Fn     |  A|  O|  E|  U|  I|  D|  H|  T|  N|  S|  -| Return|
+     * |-----------------------------------------------------------|
+     * |Shift   |  ;|  Q|  J|  K|  X|  B|  M|  W|  V|  Z|     Shift|
+     * |-----------------------------------------------------------|
+     * |Ctrl|Alt |Gui |      Space             |Gui |Alt |Ctrl|  Fn|
+     * `-----------------------------------------------------------'
+     */
+[_DV] = { /* Layer 1: Dvorak */
+    {KC_ESC,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_LBRC, KC_RBRC, KC_BSPC},
+    {KC_TAB,  KC_QUOT, KC_COMM, KC_DOT,  KC_P,    KC_Y,    KC_F,    KC_G,    KC_C,    KC_R,    KC_L,    KC_SLSH, KC_EQL,  KC_BSLS},
+    {MO(_FL), KC_A,    KC_O,    KC_E,    KC_U,    KC_I,    KC_D,    KC_H,    KC_T,    KC_N,    KC_S,    KC_MINS, XXXXXXX, KC_ENT },
+    {KC_LSFT, XXXXXXX, KC_SCLN, KC_Q,    KC_J,    KC_K,    KC_X,    KC_B,    KC_M,    KC_W,    KC_V,    KC_Z,    XXXXXXX, KC_RSFT},
+    {KC_LCTL, KC_LALT, KC_LGUI, XXXXXXX, XXXXXXX, KC_SPC,  XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_RGUI, KC_RALT, KC_RCTL, MO(_FL)}
+  },
+
+    /*
+     *  _CM: Colemak Layer
+     * ,-----------------------------------------------------------.
+     * |ESC | 1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =| Backsp|
+     * |-----------------------------------------------------------|
+     * |Tab  |  Q|  W|  F|  P|  G|  J|  L|  U|  Y|  ;|  [|  ]|    \|
+     * |-----------------------------------------------------------|
+     * |Fn     |  A|  R|  S|  T|  D|  H|  N|  E|  I|  O|  '| Return|
+     * |-----------------------------------------------------------|
+     * |Shift   |  Z|  X|  C|  V|  B|  K|  M|  ,|  .|  /|     Shift|
+     * |-----------------------------------------------------------|
+     * |Ctrl|Alt |Gui |      Space             |Gui |Alt |Ctrl|  Fn|
+     * `-----------------------------------------------------------'
+     */
+[_CM] = { /* Layer 2: Colemak */
+    {KC_ESC,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC},
+    {KC_TAB,  KC_Q,    KC_W,    KC_F,    KC_P,    KC_G,    KC_J,    KC_L,    KC_U,    KC_Y,    KC_SCLN, KC_LBRC, KC_RBRC, KC_BSLS},
+    {MO(_FL), KC_A,    KC_R,    KC_S,    KC_T,    KC_D,    KC_H,    KC_N,    KC_E,    KC_I,    KC_O,    KC_QUOT, XXXXXXX, KC_ENT },
+    {KC_LSFT, XXXXXXX, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_K,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, XXXXXXX, KC_RSFT},
+    {KC_LCTL, KC_LALT, KC_LGUI, XXXXXXX, XXXXXXX, KC_SPC,  XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_RGUI, KC_RALT, KC_RCTL, MO(_FL)}
+  },
+
+    /*
+     *  _FL: Function Layer
+     * ,-----------------------------------------------------------.
+     * |    |F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|    Del|
+     * |-----------------------------------------------------------|
+     * |     |   |   |   |   |   |   |PgU| Up|PgD|PSc|SLk|Pau|     |
+     * |-----------------------------------------------------------|
+     * |       |   |MPr|MPl|MNx|   |Hom| Lt| Dn| Rt|   |   |       |
+     * |-----------------------------------------------------------|
+     * |CAPS    |   |Mut|VlD|VlU|   |End|   |   |   |   |          |
+     * |-----------------------------------------------------------|
+     * |_QW |_DV |_CM |                        |    |    |    |    |
+     * `-----------------------------------------------------------'
+     */
+[_FL] = { /* Layer 3: Functions */
+    {_______, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_DEL },
+    {_______, _______, _______, _______, _______, _______, _______, KC_PGUP, KC_UP,   KC_PGDN, KC_PSCR, KC_SLCK, KC_PAUS, _______},
+    {_______, _______, KC_MPRV, KC_MPLY, KC_MNXT, _______, KC_HOME, KC_LEFT, KC_DOWN, KC_RGHT, _______, _______, XXXXXXX, _______},
+    {KC_CAPS, XXXXXXX, _______, KC_MUTE, KC_VOLD, KC_VOLU, _______, KC_END,  _______, _______, _______, _______, XXXXXXX, _______},
+    {QWERTY,  DVORAK,  COLEMAK, XXXXXXX, XXXXXXX, _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______, _______, _______, _______}
+  },
+
+
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+
+};
+
+void persistant_default_layer_set(uint16_t default_layer) {
+  eeconfig_update_default_layer(default_layer);
+  default_layer_set(default_layer);
+}
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+      switch(id) {
+        case _DV:
+          if (record->event.pressed) {
+            persistant_default_layer_set(1UL<<_DV);
+          }
+          break;
+        case _QW:
+          if (record->event.pressed) {
+            persistant_default_layer_set(1UL<<_QW);
+          }
+          break;
+        case _CM:
+          if (record->event.pressed) {
+            persistant_default_layer_set(1UL<<_CM);
+          }
+          break;
+      }
+    return MACRO_NONE;
+};

keyboards/handwired/MS-sculpt-mobile/MS-sculpt-mobile.c

@@ -1 +0,0 @@
-#include "MS-sculpt-mobile.h"

keyboards/handwired/MS_sculpt_mobile/MS_sculpt_mobile.c

@@ -0,0 +1 @@
+#include "MS_sculpt_mobile.h"

keyboards/handwired/MS_sculpt_mobile/babblePaste.c

@@ -7,7 +7,8 @@ Huge thanks to https://en.wikipedia.org/wiki/Table_of_keyboard_shortcuts
 and https://github.com/qmk/qmk_firmware/blob/master/keyboards/planck/keymaps/jeebak/keymap.c 
 */
 
-#include "babblePaste.h"
+#include "../MS_sculpt_mobile/babblePaste.h"
+
 #include "action_macro.h"
 
 #ifdef USE_BABLPASTE
@@ -27,7 +28,7 @@ macro_t* switch_babble_mode( uint8_t id) {
 // And else statements have problems, see https://gcc.gnu.org/onlinedocs/gcc-3.0.1/cpp_3.html#SEC15
 #define BABLM(ent, macro...) \
 	if ( ent == shortcut ) \
-		 {  action_macro_play( MACRO(macro)); return MACRO_NONE; }   
+		 {  action_macro_play( MACRO(macro)); return MACRO_NONE; }
 
 
 /* this function runs the appropriate babblepaste macro, given
@@ -456,4 +457,4 @@ const  macro_t *babblePaste (keyrecord_t *record,  uint8_t shortcut) {
 }
 
 
-#endif
+#endif

keyboards/handwired/MS_sculpt_mobile/babblePaste.h

@@ -9,9 +9,9 @@ and jeebak & algernon's keymap
 */
 #ifndef _babblePaste_h_included__
 #define _babblePaste_h_included__
+#include "../MS_sculpt_mobile/config.h"
 #include "action_layer.h"
 #include "quantum_keycodes.h"
-#include "config.h"
 
 #ifdef USE_BABLPASTE
 

keyboards/handwired/MS_sculpt_mobile/keymaps/default/config.h

@@ -0,0 +1,8 @@
+#ifndef CONFIG_USER_H
+#define CONFIG_USER_H
+
+#include "../../../MS_sculpt_mobile/config.h"
+
+// place overrides here
+
+#endif

keyboards/handwired/MS_sculpt_mobile/keymaps/default/keymap.c

@@ -1,4 +1,4 @@
-#include "MS-sculpt-mobile.h"
+#include "../../MS_sculpt_mobile.h"
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* 

keyboards/handwired/MS_sculpt_mobile/keymaps/milestogo/config.h

@@ -1,7 +1,7 @@
 #ifndef CONFIG_USER_H
 #define CONFIG_USER_H
 
-#include "../../config.h"
+#include "../../../MS_sculpt_mobile/config.h"
 
 #define USE_BABLPASTE
 

keyboards/handwired/MS_sculpt_mobile/keymaps/milestogo/keymap.c

@@ -1,7 +1,7 @@
-#include "MS-sculpt-mobile.h"
+#include "../../../MS_sculpt_mobile/babblePaste.h"
+#include "../../MS_sculpt_mobile.h"
 #include "action_layer.h"
 #include "action_util.h"
-#include "babblePaste.h"
 
 #ifdef AUDIO_ENABLE
   #include "audio.h"

keyboards/handwired/atreus50/keymaps/default/keymap.c

@@ -66,7 +66,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   //,----+----+----+----+----+----.         ,----+----+----+----+----+----.
      TAB ,QUOT,COMM,DOT , P  , Y  ,           F  , G  , C  , R  , L  ,MINS,
   //|----+----+----+----+----+----|         |----+----+----+----+----+----|
-      X0 , A  , O  , E  , U  , I  ,           D  , H  , R  , N  , S  ,SLSH,
+      X0 , A  , O  , E  , U  , I  ,           D  , H  , T  , N  , S  ,SLSH,
   //|----+----+----+----+----+----|         |----+----+----+----+----+----|
      LSFT,SCLN, Q  , J  , K  , X  ,           B  , M  , W  , V  , Z  , X4 ,
   //|----+----+----+----+----+----|----+----|----+----+----+----+----+----|

keyboards/handwired/kbod/Makefile

@@ -0,0 +1,3 @@
+ifndef MAKEFILE_INCLUDED
+	include ../../Makefile
+endif

keyboards/handwired/kbod/config.h

@@ -1,7 +1,5 @@
 /*
 Copyright 2012 Jun Wako <wakojun@gmail.com>
-Copyright 2016 Julien Pecqueur <julien@peclu.net>
-Copyright 2016 Felix Uhl <ifreilicht@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
@@ -26,13 +24,13 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define VENDOR_ID       0xFEED
 #define PRODUCT_ID      0x6060
 #define DEVICE_VER      0x0001
-#define MANUFACTURER    Massdrop
+#define MANUFACTURER    fudanchii
-#define PRODUCT         S60-X
+#define PRODUCT         kbod
-#define DESCRIPTION     q.m.k. keyboard firmware for S60-X
+#define DESCRIPTION     Keyboard of Disapproval
 
 /* key matrix size */
-#define MATRIX_ROWS 5
+#define MATRIX_ROWS 8
-#define MATRIX_COLS 15
+#define MATRIX_COLS 8
 
 /*
  * Keyboard Matrix Assignments
@@ -44,11 +42,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *                  ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
  *
 */
-#define MATRIX_ROW_PINS { B7, B3, B2, B1, B0 }
+#define MATRIX_ROW_PINS { C6, D7, E6, B4, B5, B6, B7, D6 }
-#define MATRIX_COL_PINS { D0, D1, D2, D3, D5, D4, D6, D7, B4, B5, B6, C6, C7, E6, F1 }
+#define MATRIX_COL_PINS { D0, D1, F0, F1, F4, F5, F6, F7 }
-#define UNUSED_PINS { F0 }
+#define UNUSED_PINS
 
-/* COL2ROW or ROW2COL */
+/* COL2ROW, ROW2COL, or CUSTOM_MATRIX */
 #define DIODE_DIRECTION COL2ROW
  
 // #define BACKLIGHT_PIN B7
@@ -157,8 +155,13 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* disable action features */
 //#define NO_ACTION_LAYER
 //#define NO_ACTION_TAPPING
-#define NO_ACTION_ONESHOT
+//#define NO_ACTION_ONESHOT
-#define NO_ACTION_MACRO
+//#define NO_ACTION_MACRO
-#define NO_ACTION_FUNCTION
+//#define NO_ACTION_FUNCTION
+
+#define PREVENT_STUCK_MODIFIERS
+
+#undef TAPPING_TOGGLE
+#define TAPPING_TOGGLE 2
 
 #endif

keyboards/handwired/kbod/kbod.c

@@ -1,4 +1,4 @@
-#include "s60-x.h"
+#include "kbod.h"
 
 void matrix_init_kb(void) {
 	// put your keyboard start-up code here

keyboards/handwired/kbod/kbod.h

@@ -0,0 +1,21 @@
+#ifndef KBOD_H
+#define KBOD_H
+
+#include "quantum.h"
+
+#define KEYMAP( \
+    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, \
+    k30,      k31, k32, k33, k34, k35, k36, k37, k38, k39, k3A,         k3B, \
+    k40,  k41,  k42,               k43,               k44,  k45,  k46,  k47  \
+) \
+{                                                                                               \
+    { k00, k01, k02, k03, k04, k05, k06, k07 }, { k08, k09, k0A, k0B, k0C, k0D, KC_NO, KC_NO }, \
+    { k10, k11, k12, k13, k14, k15, k16, k17 }, { k18, k19, k1A, k1B, k1C, k1D, KC_NO,   k3B }, \
+    { k20, k21, k22, k23, k24, k25, k26, k27 }, { k28, k29, k2A, k2B, k2C, k38, k39,     k3A }, \
+    { k30, k31, k32, k33, k34, k35, k36, k37 },                                                 \
+    { k40, k41, k42, k43, k44, k45, k46, k47 },                                                 \
+}
+
+#endif

keyboards/handwired/kbod/keymaps/default/Makefile

@@ -0,0 +1,21 @@
+# Build Options
+#   change to "no" to disable the options, or define them in the Makefile in 
+#   the appropriate keymap folder that will get included automatically
+#
+BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = yes       # Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes       # Audio control and System control(+450)
+CONSOLE_ENABLE = no         # Console for debug(+400)
+COMMAND_ENABLE = no         # Commands for debug and configuration
+NKRO_ENABLE = yes           # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality
+MIDI_ENABLE = no            # MIDI controls
+AUDIO_ENABLE = no           # Audio output on port C6
+UNICODE_ENABLE = no         # Unicode
+BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
+RGBLIGHT_ENABLE = no        # Enable WS2812 RGB underlight.  Do not enable this with audio at the same time.
+SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend
+
+ifndef QUANTUM_DIR
+	include ../../../../Makefile
+endif

keyboards/handwired/kbod/keymaps/default/config.h

@@ -0,0 +1,8 @@
+#ifndef CONFIG_USER_H
+#define CONFIG_USER_H
+
+#include "../../config.h"
+
+// place overrides here
+
+#endif

keyboards/handwired/kbod/keymaps/default/keymap.c

@@ -0,0 +1,104 @@
+#include "kbod.h"
+
+#define _____ KC_TRNS
+
+#define MODS_PRESSED(btn)  (get_mods() & (MOD_BIT(KC_L##btn)|MOD_BIT(KC_R##btn)))
+
+#define SET_WHETHER(mask, btn1, btn2) \
+if (record->event.pressed) {          \
+    if (mask) {                       \
+        add_key(btn2);                \
+        send_keyboard_report();       \
+    } else {                          \
+        add_key(btn1);                \
+        send_keyboard_report();       \
+    }                                 \
+} else {                              \
+    if (mask) {                       \
+        del_key(btn2);                \
+        send_keyboard_report();       \
+    } else {                          \
+        del_key(btn1);                \
+        send_keyboard_report();       \
+    }                                 \
+}                                     \
+
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  KEYMAP( /* Base */
+      F(0), KC_1, KC_2, KC_3, F(1), KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQUAL, KC_BSPC,
+      KC_TAB,  KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLASH,
+      KC_CAPS,  KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCOLON, KC_QUOT, KC_ENTER,
+      KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMMA, KC_DOT, KC_SLASH, KC_RSFT,
+      TT(1), KC_LCTL, KC_LALT, KC_SPACE, KC_RALT, KC_RGUI, KC_APP, KC_RCTL 
+  ),
+  KEYMAP( /* Cursor layer */
+      KC_GRAVE, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_DEL,
+      TT(3),  _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, KC_INSERT,
+      TT(2),  _____, _____, _____, _____, _____, _____, _____, _____, _____, _____, KC_HOME, _____,
+      _____,  _____, _____, _____, _____, _____, _____, _____, KC_PGUP, KC_PGDN, KC_END, KC_UP,
+      _____,  _____, _____, _____, _____, KC_LEFT, KC_DOWN, KC_RIGHT
+  ),
+  KEYMAP( /* Keypad layer */
+      TO(0),  KC_1,  KC_2,  KC_3,  F(1),  KC_5,  KC_6,  KC_P7, KC_P8, KC_P9, KC_P0, KC_PMNS, KC_PPLS, KC_BSPC,
+      _____,  _____, _____, _____, _____, _____, _____, KC_P4, KC_P5, KC_P6, _____, _____, _____, _____,
+      _____,  _____, _____, _____, _____, _____, _____, KC_P1, KC_P2, KC_P3, _____, _____, _____,
+      _____,  _____, _____, _____, _____, _____, _____, KC_P0, KC_PDOT, KC_MS_BTN1, KC_MS_UP, KC_MS_BTN2,
+      _____,  _____, _____, _____, KC_MS_LEFT, KC_MS_DOWN, KC_MS_RIGHT, KC_MS_BTN3
+  ),
+  KEYMAP( /* Multimedia layer */
+      TO(0),  _____, _____, _____, _____, _____, _____, _____, _____, _____, KC_AUDIO_MUTE, KC_AUDIO_VOL_DOWN, KC_AUDIO_VOL_UP, _____,
+      _____,  _____, KC_WAKE, _____, _____, _____, _____, _____, _____, _____, KC_MSTP, KC_MPRV, KC_MNXT, _____,
+      _____,  _____, KC_SLEP, _____, _____, _____, _____, _____, _____, _____, _____, _____, _____,
+      _____,  _____, KC_PWR, _____, _____, _____, _____, _____, _____, KC_MS_BTN1, KC_MS_WH_UP, KC_MS_BTN2,
+      _____,  _____, _____, KC_MPLY, KC_MS_WH_LEFT, KC_MS_WH_DOWN, KC_MS_WH_RIGHT, KC_MS_BTN3
+  ),
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+  [0]  = ACTION_FUNCTION(0),
+  [1]  = ACTION_FUNCTION(1),
+};
+
+
+void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
+  static uint8_t shift_esc_mask;
+  static uint8_t alt_mask;
+  switch (id) {
+    case 0:
+      shift_esc_mask = MODS_PRESSED(SHIFT);
+      SET_WHETHER(shift_esc_mask, KC_ESC, KC_GRAVE);
+      break;
+    case 1:
+      alt_mask = MODS_PRESSED(ALT);
+      SET_WHETHER(alt_mask, KC_4, KC_F4);
+      break;
+  }
+}
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+  return MACRO_NONE;
+};
+
+void led_set_user(uint8_t usb_led) {
+  if (usb_led & _BV(USB_LED_CAPS_LOCK)) {
+    PORTB |= _BV(PB0);
+  } else {
+    PORTB &= ~_BV(PB0);
+  }
+}
+
+void matrix_init_user(void) {
+  DDRB |= _BV(PB0);
+  DDRC |= _BV(PC7);
+}
+
+void matrix_scan_user(void) {
+  uint8_t layer = biton32(layer_state);
+  if (layer) {
+    PORTC |= _BV(PC7);
+  } else {
+    PORTC &= ~_BV(PC7);
+  }
+}

keyboards/handwired/kbod/keymaps/default/readme.md

@@ -0,0 +1,5 @@
+# The default keymap for kbod
+
+This is the default keymap for kbod,
+
+it consists of a base layer with QWERTY layout, a momentary cursor-layer, and mouse-keys and multimedia layers.

keyboards/handwired/kbod/readme.md

@@ -0,0 +1,21 @@
+KBOD keyboard firmware
+======================
+
+KBOD is a 60% Keyboard kit, hand-wired, with Arduino Micro as its controller. It's utilize 8x8 matrix and has layout similar to GH-60
+
+## Quantum MK Firmware
+
+For the full Quantum feature list, see [the parent readme](/).
+
+## Building
+
+Download or clone the whole firmware and use ```make handwired-kbod-default``` to generate the .hex file. You may flash it with avrdude
+
+## Flashing
+Something along this line:
+
+```
+avrdude -p m32u4 -c avr109 -P <COM PORT> -C <avrdude conf file> -e -u flash:w:handwired_kbod_default.hex
+```
+
+[More info](https://github.com/fudanchii/keyboard_of_disapproval)

keyboards/handwired/kbod/rules.mk

@@ -0,0 +1,68 @@
+# MCU name
+#MCU = at90usb1287
+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 ?= no        # Console for debug(+400)
+COMMAND_ENABLE ?= no        # Commands for debug and configuration
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+SLEEP_LED_ENABLE ?= no       # Breathing sleep LED during USB suspend
+# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+NKRO_ENABLE ?= no            # USB Nkey Rollover
+BACKLIGHT_ENABLE ?= no       # Enable keyboard backlight functionality on B7 by default
+MIDI_ENABLE ?= no            # MIDI controls
+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