Merge branch 'master' of https://github.com/jackhumbert/qmk_firmware

.travis.yml

@@ -1,39 +1,21 @@
-os:
+os: linux
-  - linux
+dist: trusty
-
+sudo: required
-language:
+language: c
-  - c
+compiler: avr-gcc
-
+branches:
-compiler:
+  except:
-  - avr-gcc
+    - /^.*-automated-build$/
-
 env:
-  - KEYBOARD=alps64
+  global:
-  - KEYBOARD=arrow_pad
+  - secure: vBTSL34BDPxDilKUuTXqU4CJ26Pv5hogD2nghatkxSQkI1/jbdnLj/DQdPUrMJFDIY6TK3AltsBx72MaMsLQ1JO/Ou24IeHINHXzUC1FlS9yQa48cpxnhX5kzXNyGs3oa0qaFbvnr7RgYRWtmD52n4bIZuSuW+xpBv05x2OCizdT2ZonH33nATaHGFasxROm4qYZ241VfzcUv766V6RVHgL4x9V08warugs+RENVkfzxxwhk3NmkrISabze0gSVJLHBPHxroZC6EUcf/ocobcuDrCwFqtEt90i7pNIAFUE7gZsN2uE75LmpzAWin21G7lLPcPL2k4FJVd8an1HiP2WmscJU6U89fOfMb2viObnKcCzebozBCmKGtHEuXZo9FcReOx49AnQSpmESJGs+q2dL/FApkTjQiyT4J6O5dJpoww0/r57Wx0cmmqjETKBb5rSgXM51Etk3wO09mvcPHsEwrT7qH8r9XWdyCDoEn7FCLX3/LYnf/D4SmZ633YPl5gv3v9XEwxR5+04akjgnvWDSNIaDbWBdxHNb7l4pMc+WR1bwCyMyA7KXj0RrftEGOrm9ZRLe6BkbT4cycA+j77nbPOMcyZChliV9pPQos+4TOJoTzcK2L8yWVoY409aDNVuAjdP6Yum0R2maBGl/etLmIMpJC35C5/lZ+dUNjJAM=
-  - KEYBOARD=atomic
-  - KEYBOARD=atreus
-  - KEYBOARD=bantam44
-  - KEYBOARD=clueboard1
-  - KEYBOARD=clueboard2
-  - KEYBOARD=cluepad
-  - KEYBOARD=ergodox_ez
-  - KEYBOARD=gh60
-  - KEYBOARD=hhkb
-  - KEYBOARD=jd45
-  - KEYBOARD=kc60
-  - KEYBOARD=phantom
-  - KEYBOARD=planck
-  - KEYBOARD=preonic
-  - KEYBOARD=retro_refit
-  - KEYBOARD=satan
-  - KEYBOARD=sixkeyboard
-
 script:
-  - cd keyboards/$KEYBOARD && make all-keymaps
+- make all-keyboards-quick AUTOGEN=true
-
 addons:
   apt:
     packages:
-      - avr-libc
+    - avr-libc
-      - gcc-avr
+    - gcc-avr
-      - dfu-programmer
+    - dfu-programmer
+    - pandoc
+after_success: bash util/travis_compiled_push.sh

Makefile

@@ -10,19 +10,32 @@ abs_tmk_root := $(patsubst %/,%,$(dir $(mkfile_path)))
 ifneq (,$(findstring /keyboards/,$(starting_makefile)))
 	possible_keyboard:=$(patsubst %/,%,$(dir $(patsubst $(abs_tmk_root)/keyboards/%,%,$(starting_makefile))))
 	ifneq (,$(findstring /keymaps/,$(possible_keyboard)))
-		KEYBOARD_DIR:=$(firstword $(subst /keymaps/, ,$(possible_keyboard)))
 		KEYMAP_DIR:=$(lastword $(subst /keymaps/, ,$(possible_keyboard)))
-		tmk_root = ../../../..
+		KEYBOARD_DIR:=$(firstword $(subst /keymaps/, ,$(possible_keyboard)))
+		ifneq (,$(findstring /,$(KEYBOARD_DIR)))
+			# SUBPROJECT_DIR:=$(lastword $(subst /, ,$(KEYBOARD_DIR)))
+			# KEYBOARD_DIR:=$(firstword $(subst /, ,$(KEYBOARD_DIR)))
+			tmk_root = ../../..
+		else
+			tmk_root = ../../../..
+		endif
 	else
-		KEYBOARD_DIR:=$(possible_keyboard)
 		KEYMAP_DIR:=default
-		tmk_root = ../..
+		KEYBOARD_DIR:=$(possible_keyboard)
+		ifneq (,$(findstring /,$(KEYBOARD_DIR)))
+			# SUBPROJECT_DIR:=$(lastword $(subst /, ,$(KEYBOARD_DIR)))
+			# KEYBOARD_DIR:=$(firstword $(subst /, ,$(KEYBOARD_DIR)))
+			tmk_root = ../../..
+		else
+			tmk_root = ../..
+		endif
 	endif
 else
 	tmk_root = .
 endif
 # $(info $(KEYBOARD_DIR))
 # $(info $(KEYMAP_DIR))
+# $(info $(SUBPROJECT_DIR))
 
 # Directory common source filess exist
 TOP_DIR = $(tmk_root)
@@ -32,6 +45,7 @@ TMK_PATH = $(TOP_DIR)/$(TMK_DIR)
 QUANTUM_DIR = quantum
 QUANTUM_PATH = $(TOP_DIR)/$(QUANTUM_DIR)
 
+
 ifdef keyboard
 	KEYBOARD ?= $(keyboard)
 endif
@@ -41,16 +55,49 @@ endif
 ifndef KEYBOARD
 	KEYBOARD=planck
 endif
+
+# converts things to keyboards/subproject
+ifneq (,$(findstring /,$(KEYBOARD)))
+	TEMP:=$(KEYBOARD)
+	KEYBOARD:=$(firstword $(subst /, ,$(TEMP)))
+	SUBPROJECT:=$(lastword $(subst /, ,$(TEMP)))
+endif
+
 KEYBOARD_PATH = $(TOP_DIR)/keyboards/$(KEYBOARD)
+
+ifdef sub
+	SUBPROJECT=$(sub)
+endif
+ifdef subproject
+	SUBPROJECT=$(subproject)
+endif
+
 ifneq ("$(wildcard $(KEYBOARD_PATH)/$(KEYBOARD).c)","")
 	KEYBOARD_FILE = keyboards/$(KEYBOARD)/$(KEYBOARD).c
 	ifndef ARCH
-		include $(KEYBOARD_PATH)/Makefile
+		ifneq ("$(wildcard $(KEYBOARD_PATH)/Makefile)","")
+			include $(KEYBOARD_PATH)/Makefile
+		endif
 	endif
 else 
 $(error "$(KEYBOARD_PATH)/$(KEYBOARD).c" does not exist)
 endif
 
+ifdef SUBPROJECT_DEFAULT
+	SUBPROJECT?=$(SUBPROJECT_DEFAULT)
+endif
+
+ifdef SUBPROJECT
+	SUBPROJECT_PATH = $(TOP_DIR)/keyboards/$(KEYBOARD)/$(SUBPROJECT)
+	ifneq ("$(wildcard $(SUBPROJECT_PATH)/$(SUBPROJECT).c)","")
+		OPT_DEFS += -DSUBPROJECT_$(SUBPROJECT)
+		SUBPROJECT_FILE = keyboards/$(KEYBOARD)/$(SUBPROJECT)/$(SUBPROJECT).c
+		-include $(SUBPROJECT_PATH)/Makefile
+	else 
+$(error "$(SUBPROJECT_PATH)/$(SUBPROJECT).c" does not exist)
+	endif
+endif
+
 ifdef keymap
 	KEYMAP ?= $(keymap)
 endif
@@ -65,15 +112,31 @@ ifneq ("$(wildcard $(KEYMAP_PATH)/keymap.c)","")
 	KEYMAP_FILE = keyboards/$(KEYBOARD)/keymaps/$(KEYMAP)/keymap.c
 	-include $(KEYMAP_PATH)/Makefile
 else 
+	ifeq ("$(wildcard $(SUBPROJECT_PATH)/keymaps/$(KEYMAP)/keymap.c)","")
 $(error "$(KEYMAP_PATH)/keymap.c" does not exist)
+	else
+		KEYMAP_PATH = $(SUBPROJECT_PATH)/keymaps/$(KEYMAP)
+		KEYMAP_FILE = keyboards/$(KEYBOARD)/$(SUBPROJECT)/keymaps/$(KEYMAP)/keymap.c
+		-include $(KEYMAP_PATH)/Makefile
+	endif
+endif
+
+ifdef SUBPROJECT
+	TARGET ?= $(KEYBOARD)_$(SUBPROJECT)_$(KEYMAP)
+else
+	TARGET ?= $(KEYBOARD)_$(KEYMAP)
 endif
 
-TARGET ?= $(KEYBOARD)_$(KEYMAP)
 
 ifneq ("$(wildcard $(KEYMAP_PATH)/config.h)","")
 	CONFIG_H = $(KEYMAP_PATH)/config.h
 else
 	CONFIG_H = $(KEYBOARD_PATH)/config.h
+	ifdef SUBPROJECT
+		ifneq ("$(wildcard $(SUBPROJECT_PATH)/$(SUBPROJECT).c)","")
+			CONFIG_H = $(SUBPROJECT_PATH)/config.h
+		endif
+	endif
 endif
 
 # # project specific files
@@ -81,22 +144,52 @@ SRC += $(KEYBOARD_FILE) \
 	$(KEYMAP_FILE) \
 	$(QUANTUM_DIR)/quantum.c \
 	$(QUANTUM_DIR)/keymap.c \
-	$(QUANTUM_DIR)/keycode_config.c
+	$(QUANTUM_DIR)/keycode_config.c \
+	$(QUANTUM_DIR)/process_keycode/process_leader.c
+
+ifdef SUBPROJECT
+	SRC += $(SUBPROJECT_FILE)
+endif
+
+ifdef SUBPROJECT
+	SRC += $(SUBPROJECT_FILE)
+endif
+
+ifdef SUBPROJECT
+	SRC += $(SUBPROJECT_FILE)
+endif
 
 ifndef CUSTOM_MATRIX
 	SRC += $(QUANTUM_DIR)/matrix.c
 endif
 
+ifeq ($(strip $(MIDI_ENABLE)), yes)
+    OPT_DEFS += -DMIDI_ENABLE
+	SRC += $(QUANTUM_DIR)/process_keycode/process_audio.c
+endif
+
 ifeq ($(strip $(AUDIO_ENABLE)), yes)
+    OPT_DEFS += -DAUDIO_ENABLE
+	SRC += $(QUANTUM_DIR)/process_keycode/process_music.c
 	SRC += $(QUANTUM_DIR)/audio/audio.c
 	SRC += $(QUANTUM_DIR)/audio/voices.c
 	SRC += $(QUANTUM_DIR)/audio/luts.c
 endif
 
+ifeq ($(strip $(UNICODE_ENABLE)), yes)
+    OPT_DEFS += -DUNICODE_ENABLE
+	SRC += $(QUANTUM_DIR)/process_keycode/process_unicode.c
+endif
+
 ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
+	OPT_DEFS += -DRGBLIGHT_ENABLE
 	SRC += $(QUANTUM_DIR)/light_ws2812.c
 	SRC += $(QUANTUM_DIR)/rgblight.c
-	OPT_DEFS += -DRGBLIGHT_ENABLE
+endif
+
+ifeq ($(strip $(TAP_DANCE_ENABLE)), yes)
+  OPT_DEFS += -DTAP_DANCE_ENABLE
+	SRC += $(QUANTUM_DIR)/process_keycode/process_tap_dance.c
 endif
 
 # Optimize size but this may cause error "relocation truncated to fit"
@@ -104,12 +197,16 @@ endif
 
 # Search Path
 VPATH += $(KEYMAP_PATH)
+ifdef SUBPROJECT
+	VPATH += $(SUBPROJECT_PATH)
+endif
 VPATH += $(KEYBOARD_PATH)
 VPATH += $(TOP_DIR)
 VPATH += $(TMK_PATH)
 VPATH += $(QUANTUM_PATH)
 VPATH += $(QUANTUM_PATH)/keymap_extras
 VPATH += $(QUANTUM_PATH)/audio
+VPATH += $(QUANTUM_PATH)/process_keycode
 
 include $(TMK_PATH)/protocol/lufa.mk
 include $(TMK_PATH)/common.mk

keyboards/alps64/matrix.c

@@ -100,6 +100,8 @@ uint8_t matrix_scan(void)
         }
     }
 
+    matrix_scan_quantum();
+
     return 1;
 }
 

keyboards/clueboard/Makefile

@@ -0,0 +1,109 @@
+#----------------------------------------------------------------------------
+# 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".
+#----------------------------------------------------------------------------
+
+SUBPROJECT_DEFAULT = rev2
+
+# MCU name
+MCU = atmega32u4
+
+# Processor frequency.
+#     This will define a symbol, F_CPU, in all source code files equal to the
+#     processor frequency in Hz. You can then use this symbol in your source code to
+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#     automatically to create a 32-bit value in your source code.
+#
+#     This will be an integer division of F_USB below, as it is sourced by
+#     F_USB after it has run through any CPU prescalers. Note that this value
+#     does not *change* the processor frequency - it should merely be updated to
+#     reflect the processor speed set externally so that the code can use accurate
+#     software delays.
+F_CPU = 16000000
+
+
+#
+# LUFA specific
+#
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+# Input clock frequency.
+#     This will define a symbol, F_USB, in all source code files equal to the
+#     input clock frequency (before any prescaling is performed) in Hz. This value may
+#     differ from F_CPU if prescaling is used on the latter, and is required as the
+#     raw input clock is fed directly to the PLL sections of the AVR for high speed
+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
+#     at the end, this will be done automatically to create a 32-bit value in your
+#     source code.
+#
+#     If no clock division is performed on the input clock inside the AVR (via the
+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
+F_USB = $(F_CPU)
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+
+# 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 ?= no	# 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
+NKRO_ENABLE ?= yes		# USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+AUDIO_ENABLE ?= no
+RGBLIGHT_ENABLE ?= no   # Enable keyboard underlight functionality
+MIDI_ENABLE ?= no 		# MIDI controls
+UNICODE_ENABLE ?= no 		# Unicode
+BLUETOOTH_ENABLE ?= no # Enable Bluetooth with the Adafruit EZ-Key HID
+
+ifndef QUANTUM_DIR
+	include ../../Makefile
+endif

keyboards/clueboard/clueboard.c

@@ -1,4 +1,9 @@
-#include "clueboard1.h"
+#include "clueboard.h"
+
+void led_init_ports() {
+    // * Set our LED pins as output
+    DDRB |= (1<<4);
+}
 
 void led_set_kb(uint8_t usb_led) {
     DDRF |= (1<<0);

keyboards/clueboard/clueboard.h

@@ -0,0 +1,13 @@
+#ifndef CLUEBOARD_H
+#define CLUEBOARD_H
+
+#ifdef SUBPROJECT_rev1
+    #include "rev1.h"
+#endif
+#ifdef SUBPROJECT_rev2
+    #include "rev2.h"
+#endif
+
+#include "quantum.h"
+
+#endif

keyboards/clueboard/config.h

@@ -22,29 +22,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 /* USB Device descriptor parameter */
 #define VENDOR_ID       0xC1ED
-#define PRODUCT_ID      0x2301
-#define DEVICE_VER      0x0003
 #define MANUFACTURER    Clueboard
 #define PRODUCT         Clueboard
 #define DESCRIPTION     QMK keyboard firmware for Clueboard
 
-/* key matrix size */
-#define MATRIX_ROWS 5
-#define MATRIX_COLS 16
-
-// ROWS: Top to bottom, COLS: Left to right
-/* Column pin configuration
-* col: 0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15
-* pin: B3 F1 F4 F5 F6 C7 C6 B6 B5 B4 D7 D6 D4 F7 B0 B1
-*/
-#define MATRIX_COL_PINS { B3, F1, F4, F5, F6, C7, C6, B6, B5, B4, D7, D6, D4, F7, B0, B1 }
-/* Row pin configuration
-* row: 0  1  2  3  4
-* pin: D1 D0 D2 D5 D3
-*/
-#define MATRIX_ROW_PINS { D1, D0, D2, D5, D3 }
-#define UNUSED_PINS
-
 /* COL2ROW or ROW2COL */
 #define DIODE_DIRECTION COL2ROW
 
@@ -64,16 +45,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
     keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
 )
 
-/* Underlight configuration
- */
- #define ws2812_PORTREG PORTB
- #define ws2812_DDRREG DDRB
- #define ws2812_pin 2
- #define RGBLED_NUM 14     // Number of LEDs
- #define RGBLIGHT_HUE_STEP 10
- #define RGBLIGHT_SAT_STEP 17
- #define RGBLIGHT_VAL_STEP 17
-
 /*
  * Feature disable options
  *  These options are also useful to firmware size reduction.
@@ -92,4 +63,12 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //#define NO_ACTION_MACRO
 //#define NO_ACTION_FUNCTION
 
+
+#ifdef SUBPROJECT_rev1
+    #include "rev1/config.h"
+#endif
+#ifdef SUBPROJECT_rev2
+    #include "rev2/config.h"
+#endif
+
 #endif

keyboards/clueboard/keymaps/default/keymap.c

@@ -1,4 +1,4 @@
-#include "clueboard2.h"
+#include "clueboard.h"
 
 // Used for SHIFT_ESC
 #define MODS_CTRL_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
@@ -138,6 +138,7 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
       if (record->event.pressed) {
         rgblight_toggle();
       }
+
       break;
     case RGBLED_INCREASE_HUE:
       if (record->event.pressed) {

keyboards/clueboard/keymaps/max/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/max/keymap.c

@@ -1,4 +1,4 @@
-#include "clueboard2.h"
+#include "clueboard.h"
 
 // Used for SHIFT_ESC
 #define MODS_CTRL_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))

keyboards/clueboard/keymaps/skully/keymap.c

@@ -1,4 +1,4 @@
-#include "clueboard2.h"
+#include "clueboard.h"
 
 // Used for SHIFT_ESC
 #define MODS_CTRL_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))

keyboards/clueboard/rev1/Makefile

@@ -0,0 +1,5 @@
+BACKLIGHT_ENABLE = no
+
+ifndef QUANTUM_DIR
+	include ../../../Makefile
+endif

keyboards/clueboard/rev1/config.h

@@ -0,0 +1,37 @@
+#ifndef REV2_CONFIG_H
+#define REV2_CONFIG_H
+
+#include "../config.h"
+
+#define PRODUCT_ID      0x2301
+#define DEVICE_VER      0x0003
+
+/* key matrix size */
+#define MATRIX_ROWS 5
+#define MATRIX_COLS 16
+
+// ROWS: Top to bottom, COLS: Left to right
+/* Column pin configuration
+* col: 0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15
+* pin: B3 F1 F4 F5 F6 C7 C6 B6 B5 B4 D7 D6 D4 F7 B0 B1
+*/
+#define MATRIX_COL_PINS { B3, F1, F4, F5, F6, C7, C6, B6, B5, B4, D7, D6, D4, F7, B0, B1 }
+/* Row pin configuration
+* row: 0  1  2  3  4
+* pin: D1 D0 D2 D5 D3
+*/
+#define MATRIX_ROW_PINS { D1, D0, D2, D5, D3 }
+#define UNUSED_PINS
+
+/* Underlight configuration
+ */
+#define ws2812_PORTREG PORTB
+#define ws2812_DDRREG DDRB
+#define ws2812_pin 2
+#define RGBLED_NUM 14     // Number of LEDs
+#define RGBLIGHT_HUE_STEP 10
+#define RGBLIGHT_SAT_STEP 17
+#define RGBLIGHT_VAL_STEP 17
+
+
+#endif

keyboards/clueboard/rev1/rev1.c

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

keyboards/clueboard/rev1/rev1.h

@@ -1,8 +1,7 @@
-#ifndef CLUEBOARD1_H
+#ifndef REV1_H
-#define CLUEBOARD1_H
+#define REV1_H
-
-#include "quantum.h"
 
+#include "../clueboard.h"
 
 /* Clueboard matrix layout
  * ,-----------------------------------------------------------.  ,---.
@@ -30,6 +29,7 @@
  */
 // The first section contains all of the arguements
 // The second converts the arguments into a two-dimensional array
+
 #define KEYMAP( \
     k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0A, k0B, k0C, k0D, k0E, k0F, \
     k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1A, k1B, k1C, k1D,      k1F, \

keyboards/clueboard/rev2/Makefile

@@ -0,0 +1,5 @@
+BACKLIGHT_ENABLE = yes
+
+ifndef QUANTUM_DIR
+	include ../../../Makefile
+endif

keyboards/clueboard/rev2/config.h

@@ -0,0 +1,40 @@
+#ifndef REV2_CONFIG_H
+#define REV2_CONFIG_H
+
+#include "../config.h"
+
+#define PRODUCT_ID      0x2320
+#define DEVICE_VER      0x0001
+
+/* key matrix size */
+#define MATRIX_ROWS 10
+#define MATRIX_COLS 8
+
+// ROWS: Top to bottom, COLS: Left to right
+/* Row pin configuration
+* row: 0  1  2  3  4  5  6  7  8  9
+* pin: B2 C7 C6 B6 B5 B0 B3 D5 D3 D2
+*/
+#define MATRIX_ROW_PINS { B2, C7, C6, B6, B5, B0, B3, D5, D3, D2 }
+/* Column pin configuration
+ * col: 0  1  2  3  4  5  6  7
+ * pin: F0 F1 F4 F5 F6 F7 E6 B1
+ */
+#define MATRIX_COL_PINS { F0, F1, F4, F5, F6, F7, E6, B1 }
+#define UNUSED_PINS
+
+ /* Backlight configuration
+ */
+#define BACKLIGHT_LEVELS 1
+
+/* Underlight configuration
+ */
+#define ws2812_PORTREG PORTD
+#define ws2812_DDRREG DDRD
+#define ws2812_pin 7
+#define RGBLED_NUM 14     // Number of LEDs
+#define RGBLIGHT_HUE_STEP 10
+#define RGBLIGHT_SAT_STEP 17
+#define RGBLIGHT_VAL_STEP 17
+
+#endif

keyboards/clueboard/rev2/rev2.c

@@ -0,0 +1,47 @@
+#include "rev2.h"
+#include <avr/io.h>
+#include "backlight.h"
+#include "print.h"
+
+void matrix_init_kb(void) {
+	// put your keyboard start-up code here
+	// runs once when the firmware starts up
+	matrix_init_user();
+	led_init_ports();
+
+    // JTAG disable for PORT F. write JTD bit twice within four cycles.
+    MCUCR |= (1<<JTD);
+    MCUCR |= (1<<JTD);
+}
+
+
+void matrix_scan_kb(void) {
+    matrix_scan_user();
+}
+
+void backlight_init_ports(void) {
+    print("init_backlight_pin()\n");
+    // Set our LED pins as output
+    DDRD |= (1<<6); // Esc
+    DDRB |= (1<<7); // Page Up
+    DDRD |= (1<<4); // Arrows
+
+    // Set our LED pins low
+    PORTD &= ~(1<<6); // Esc
+    PORTB &= ~(1<<7); // Page Up
+    PORTD &= ~(1<<4); // Arrows
+}
+
+void backlight_set(uint8_t level) {
+    if ( level == 0 ) {
+        // Turn off light
+        PORTD |= (1<<6); // Esc
+        PORTB |= (1<<7); // Page Up
+        PORTD |= (1<<4); // Arrows
+    } else {
+        // Turn on light
+        PORTD &= ~(1<<6); // Esc
+        PORTB &= ~(1<<7); // Page Up
+        PORTD &= ~(1<<4); // Arrows
+    }
+}

keyboards/clueboard/rev2/rev2.h

@@ -1,8 +1,7 @@
-#ifndef CLUEBOARD2_H
+#ifndef REV2_H
-#define CLUEBOARD2_H
+#define REV2_H
-
-#include "quantum.h"
 
+#include "../clueboard.h"
 
 /* Clueboard matrix layout
  * ,-----------------------------------------------------------.  ,---.
@@ -30,6 +29,7 @@
  */
 // The first section contains all of the arguments
 // The second converts the arguments into a two-dimensional array
+
 #define KEYMAP( \
     k00, k01, k02, k03, k04, k05, k06, k07, k50, k51, k52, k53, k54, k55, k56, k57, \
     k10, k11, k12, k13, k14, k15, k16, k17, k60, k61, k62, k63, k64, k65,      k67, \

keyboards/clueboard1/keymaps/default/keymap.c

@@ -1,184 +0,0 @@
-#include "clueboard1.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 _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|   Q|   W|   E|   R|   T|   Y|   U|   I|   O|   P|   [|   ]|      \|  |PGDN|
-   * |--------------------------------------------------------------------------|  `----'
-   * |Capslck|   A|   S|   D|   F|   G|   H|   J|   K|   L|   ;|   '|   # |  Ent|
-   * |-----------------------------------------------------------------------------.
-   * |Shift|  BS|   Z|   X|   C|   V|   B|   N|   M|   ,|   .|   /|   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_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,            \
-  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),
-
-  /* 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
-   * ,--------------------------------------------------------------------------.  ,----.
-   * |    |    |    |    |    |    |    |    |    |    |    |    |    |    |    |  |    |
-   * |--------------------------------------------------------------------------|  |----|
-   * |      |    |    |    |RESET|   |    |    |    |    |    |    |    |       |  |    |
-   * |--------------------------------------------------------------------------|  `----'
-   * |       |    | _RS|    |    |    |    |    |    |    |    |    |     |     |
-   * |-----------------------------------------------------------------------------.
-   * |     |    |    |    |    |    |    |    |    |    |    |    |     |     |    |
-   * |------------------------------------------------------------------------|----|----.
-   * |     |     |     |     |         |         |     |     |     |  _FL|    |    |    |
-   * `----------------------------------------------------------------------------------'
-   */
-[_RS] = KEYMAP(
-  #ifdef RGBLIGHT_ENABLE
-  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, F(1),             F(7), \
-  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,                   F(8), \
-  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),          F(5),          \
-  KC_TRNS, KC_TRNS, KC_TRNS,KC_TRNS,        F(2),   F(2),                            KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS, F(4),    F(6),    F(3)),
-  #else
-  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,RESET,  KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS, KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,                   KC_TRNS, \
-  KC_TRNS, KC_TRNS, 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_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),
-  #endif
-};
-
-enum function_id {
-    SHIFT_ESC,
-    #ifdef RGBLIGHT_ENABLE
-    RGBLED_TOGGLE,
-    RGBLED_STEP_MODE,
-    RGBLED_INCREASE_HUE,
-    RGBLED_DECREASE_HUE,
-    RGBLED_INCREASE_SAT,
-    RGBLED_DECREASE_SAT,
-    RGBLED_INCREASE_VAL,
-    RGBLED_DECREASE_VAL
-    #endif
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(SHIFT_ESC),
-  #ifdef RGBLIGHT_ENABLE
-  [1]  = ACTION_FUNCTION(RGBLED_TOGGLE),
-  [2]  = ACTION_FUNCTION(RGBLED_STEP_MODE),
-  [3]  = ACTION_FUNCTION(RGBLED_INCREASE_HUE),
-  [4]  = ACTION_FUNCTION(RGBLED_DECREASE_HUE),
-  [5]  = ACTION_FUNCTION(RGBLED_INCREASE_SAT),
-  [6]  = ACTION_FUNCTION(RGBLED_DECREASE_SAT),
-  [7]  = ACTION_FUNCTION(RGBLED_INCREASE_VAL),
-  [8]  = ACTION_FUNCTION(RGBLED_DECREASE_VAL),
-  #endif
-};
-
-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;
-    //led operations
-    #ifdef RGBLIGHT_ENABLE
-    case RGBLED_TOGGLE:
-      if (record->event.pressed) {
-        rgblight_toggle();
-      }
-
-      break;
-    case RGBLED_INCREASE_HUE:
-      if (record->event.pressed) {
-        rgblight_increase_hue();
-      }
-      break;
-    case RGBLED_DECREASE_HUE:
-      if (record->event.pressed) {
-        rgblight_decrease_hue();
-      }
-      break;
-    case RGBLED_INCREASE_SAT:
-      if (record->event.pressed) {
-        rgblight_increase_sat();
-      }
-      break;
-    case RGBLED_DECREASE_SAT:
-      if (record->event.pressed) {
-        rgblight_decrease_sat();
-      }
-      break;
-    case RGBLED_INCREASE_VAL:
-      if (record->event.pressed) {
-        rgblight_increase_val();
-      }
-      break;
-    case RGBLED_DECREASE_VAL:
-      if (record->event.pressed) {
-        rgblight_decrease_val();
-      }
-      break;
-    case RGBLED_STEP_MODE:
-      if (record->event.pressed) {
-        rgblight_step();
-      }
-      break;
-    #endif
-  }
-}

keyboards/clueboard2/keymaps/max/Makefile

@@ -1,11 +0,0 @@
-
-
-# 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
-#
-RGBLIGHT_ENABLE = yes        # Enable WS2812 RGB underlight.  Do not enable this with audio at the same time.
-
-ifndef QUANTUM_DIR
-	include ../../../../Makefile
-endif

keyboards/cluepad/Makefile

@@ -1,8 +1,4 @@
 
-
-# # project specific files
-SRC = backlight.c
-
 # MCU name
 #MCU = at90usb1287
 MCU = atmega32u4

keyboards/cluepad/backlight.c

@@ -1,54 +0,0 @@
-#include <avr/io.h>
-#include "backlight.h"
-#include "led.h"
-
-#include "print.h"
-
-int pwm_level;
-
-void led_set_kb(uint8_t usb_led)
-{
-    print("led_set\n");
-}
-
-void init_backlight_pin(void)
-{
-    // Set C7 to output
-    DDRC |= (1<<7);
-
-    // Initialize the timer
-    TC4H = 0x03;
-    OCR4C = 0xFF;
-    TCCR4A = 0b10000010;
-    TCCR4B = 0b00000001;
-}
-
-void backlight_set(uint8_t level)
-{
-    // Determine the PWM level
-    switch (level)
-    {
-        case 0:
-            // 33%
-            pwm_level = 0x54;
-            break;
-        case 1:
-            // 66%
-            pwm_level = 0xA8;
-            break;
-        case 2:
-            // 100%
-            pwm_level = 0xFF;
-            break;
-        case 3:
-            // 0%
-            pwm_level = 0x00;
-            break;
-        default:
-            xprintf("Unknown level: %d\n", level);
-    }
-
-    // Write the PWM level to the timer
-    TC4H = pwm_level >> 8;
-    OCR4A = 0xFF & pwm_level;
-}

keyboards/cluepad/cluepad.c

@@ -1,15 +1,60 @@
 #include "cluepad.h"
 
+int pwm_level;
+
 void matrix_init_kb(void) {
     // put your keyboard start-up code here
     // runs once when the firmware starts up
     matrix_init_user();
 
-    #ifdef BACKLIGHT_ENABLE
-        init_backlight_pin();
-    #endif
-
     // JTAG disable for PORT F. write JTD bit twice within four cycles.
     MCUCR |= (1<<JTD);
     MCUCR |= (1<<JTD);
 };
+
+void led_set_kb(uint8_t usb_led)
+{
+    print("led_set\n");
+}
+
+void backlight_init_ports(void)
+{
+    // Set C7 to output
+    DDRC |= (1<<7);
+
+    // Initialize the timer
+    TC4H = 0x03;
+    OCR4C = 0xFF;
+    TCCR4A = 0b10000010;
+    TCCR4B = 0b00000001;
+}
+
+void backlight_set(uint8_t level)
+{
+    // Determine the PWM level
+    switch (level)
+    {
+        case 0:
+            // 33%
+            pwm_level = 0x54;
+            break;
+        case 1:
+            // 66%
+            pwm_level = 0xA8;
+            break;
+        case 2:
+            // 100%
+            pwm_level = 0xFF;
+            break;
+        case 3:
+            // 0%
+            pwm_level = 0x00;
+            break;
+        default:
+            xprintf("Unknown level: %d\n", level);
+    }
+
+    // Write the PWM level to the timer
+    TC4H = pwm_level >> 8;
+    OCR4A = 0xFF & pwm_level;
+}

keyboards/cluepad/cluepad.h

@@ -1,9 +1,7 @@
 #ifndef CLUEPAD_H
 #define CLUEPAD_H
 
-#include "matrix.h"
+#include "quantum.h"
-#include "keymap.h"
-#include <stddef.h>
 
 
 /* Cluepad matrix layout

keyboards/ergodox_ez/matrix.c

@@ -187,8 +187,7 @@ uint8_t matrix_scan(void)
         }
     }
 
-
+    matrix_scan_quantum();
-    matrix_scan_kb();
 
     return 1;
 }

keyboards/handwired/Makefile

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

keyboards/handwired/fivethirteen/Makefile

@@ -0,0 +1,73 @@
+
+# MCU name
+MCU = atmega32u4
+
+# Processor frequency.
+#     This will define a symbol, F_CPU, in all source code files equal to the
+#     processor frequency in Hz. You can then use this symbol in your source code to
+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#     automatically to create a 32-bit value in your source code.
+#
+#     This will be an integer division of F_USB below, as it is sourced by
+#     F_USB after it has run through any CPU prescalers. Note that this value
+#     does not *change* the processor frequency - it should merely be updated to
+#     reflect the processor speed set externally so that the code can use accurate
+#     software delays.
+F_CPU = 16000000
+
+
+#
+# LUFA specific
+#
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+# Input clock frequency.
+#     This will define a symbol, F_USB, in all source code files equal to the
+#     input clock frequency (before any prescaling is performed) in Hz. This value may
+#     differ from F_CPU if prescaling is used on the latter, and is required as the
+#     raw input clock is fed directly to the PLL sections of the AVR for high speed
+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
+#     at the end, this will be done automatically to create a 32-bit value in your
+#     source code.
+#
+#     If no clock division is performed on the input clock inside the AVR (via the
+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
+F_USB = $(F_CPU)
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+
+# Boot Section Size in *bytes*
+#   Teensy halfKay   512
+#   Teensy++ halfKay 1024
+#   Atmel DFU loader 4096
+#   LUFA bootloader  4096
+#   USBaspLoader     2048
+OPT_DEFS += -DBOOTLOADER_SIZE=512
+
+
+# Build Options
+#   change yes to no to disable
+#
+BOOTMAGIC_ENABLE ?= no      # Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE ?= yes       # Mouse keys(+4700)
+EXTRAKEY_ENABLE ?= yes       # Audio control and System control(+450)
+CONSOLE_ENABLE ?= yes        # Console for debug(+400)
+COMMAND_ENABLE ?= yes        # Commands for debug and configuration
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+SLEEP_LED_ENABLE ?= no       # Breathing sleep LED during USB suspend
+# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+NKRO_ENABLE ?= no            # USB Nkey Rollover
+BACKLIGHT_ENABLE ?= no       # Enable keyboard backlight functionality on B7 by default
+MIDI_ENABLE ?= no            # MIDI controls
+UNICODE_ENABLE ?= no         # Unicode
+BLUETOOTH_ENABLE ?= no       # Enable Bluetooth with the Adafruit EZ-Key HID
+AUDIO_ENABLE ?= no           # Audio output on port C6
+
+ifndef QUANTUM_DIR
+	include ../../../Makefile
+endif
+
+

keyboards/handwired/fivethirteen/README.md

@@ -0,0 +1,28 @@
+fivethirteen keyboard firmware
+======================
+
+## Quantum MK Firmware
+
+For the full Quantum feature list, see [the parent readme.md](/doc/readme.md).
+
+## Building
+
+Download or clone the whole firmware and navigate to the keyboards/handwired/fivethirteen folder.
+Once your dev env is setup, you'll be able to type `make` to generate your .hex - you can then use
+the Teensy Loader to program your .hex file.
+
+Depending on which keymap you would like to use, you will have to compile slightly differently.
+
+### Default
+
+To build with the default keymap, simply run `make`.
+
+### Other Keymaps
+
+To build the firmware binary hex file with a keymap just do `make` with `keymap` option like:
+
+```
+$ make keymap=[default|jack|<name>]
+```
+
+Keymaps follow the format **__keymap.c__** and are stored in folders in the `keymaps` folder, eg `keymaps/my_keymap/`

keyboards/handwired/fivethirteen/config.h

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

keyboards/handwired/fivethirteen/fivethirteen.c

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

keyboards/handwired/fivethirteen/fivethirteen.h

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

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

@@ -0,0 +1,49 @@
+#include "fivethirteen.h"
+
+#define _______ KC_TRNS
+
+#define HDN 1
+#define OSY 2
+#define MOS 3
+#define CTL_ESC CTL_T(KC_ESC)
+#define SFT_BSP SFT_T(KC_BSPC)
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+[0] = KEYMAP(
+  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_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, \
+  CTL_ESC, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_ENT,  \
+  KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_UP,   KC_BSLS, \
+  MO(MOS), KC_LCTL, KC_LALT, KC_LGUI, MO(HDN),    KC_SPC    ,    SFT_BSP, MO(OSY), MO(HDN), KC_LEFT, KC_DOWN, KC_RGHT  \
+),
+[HDN] = KEYMAP(
+  _______,  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_EXLM, KC_AT,   KC_HASH, KC_DLR,  KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, _______, _______, \
+  _______, KC_TILD, KC_GRV,  KC_BSLS, KC_PIPE, KC_MINS, KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT, KC_TILD, KC_GRV,  _______, \
+  _______, _______, _______, _______, _______, _______, _______, KC_ENT,  _______, _______, _______, KC_PGUP, _______, \
+  _______, _______, _______, _______, _______,      KC_UNDS    , KC_DEL,  _______, _______, KC_HOME, KC_PGDN, KC_END   \
+),
+[OSY] = KEYMAP(
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+  _______, KC_VOLD, KC_VOLU, KC_MUTE, KC_PWR,  _______, _______, _______, _______, _______, _______, _______, _______, \
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+  _______, _______, _______, _______, _______,      _______,     _______, _______, _______, _______, _______, _______  \
+),
+[MOS] = KEYMAP(
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+  _______, _______, _______, _______, _______, _______, _______, KC_BTN1, KC_BTN2, _______, _______, _______, _______, \
+  _______, _______, _______, _______, _______, _______, KC_MS_L, KC_MS_D, KC_MS_U, KC_MS_R, _______, _______, _______, \
+  _______, _______, _______, _______, _______, _______, _______, KC_WH_D, KC_WH_U, _______, _______, _______, _______, \
+  _______, _______, _______, _______, _______,      _______,     _______, _______, _______, _______, _______, _______  \
+)
+};
+
+
+const uint16_t PROGMEM fn_actions[] = {
+
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
+  return MACRO_NONE;
+};

keyboards/handwired/handwired.c

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

keyboards/handwired/handwired.h

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

keyboards/handwired/onekey/Makefile

@@ -52,18 +52,14 @@ OPT_DEFS += -DBOOTLOADER_SIZE=4096
 # Build Options
 #   comment out to disable the options.
 #
-BOOTMAGIC_ENABLE ?= yes	# Virtual DIP switch configuration(+1000)
+BOOTMAGIC_ENABLE ?= no	# Virtual DIP switch configuration(+1000)
-MOUSEKEY_ENABLE ?= no	# Mouse keys(+4700)
+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
-NKRO_ENABLE ?= yes		# USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+#SLEEP_LED_ENABLE = yes  # Breathing sleep LED during USB suspend
-AUDIO_ENABLE ?= no
+#NKRO_ENABLE = yes	# USB Nkey Rollover - not yet supported in LUFA
-RGBLIGHT_ENABLE ?= no   # Enable keyboard underlight functionality
-MIDI_ENABLE ?= no 		# MIDI controls
-UNICODE_ENABLE ?= no 		# Unicode
-BLUETOOTH_ENABLE ?= no # Enable Bluetooth with the Adafruit EZ-Key HID
 
 ifndef QUANTUM_DIR
-	include ../../Makefile
+	include ../../../Makefile
-endif
+endif

keyboards/handwired/onekey/config.h

@@ -1,5 +1,5 @@
 /*
-Copyright 2012 Jun Wako <wakojun@gmail.com>
+Copyright 2015 Jun Wako <wakojun@gmail.com>
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -21,38 +21,26 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "config_common.h"
 
 /* USB Device descriptor parameter */
-#define VENDOR_ID       0xC1ED
+#define VENDOR_ID       0xFEED
-#define PRODUCT_ID      0x2320
+#define PRODUCT_ID      0x6464
 #define DEVICE_VER      0x0001
-#define MANUFACTURER    Clueboard
+#define MANUFACTURER    none
-#define PRODUCT         Clueboard with RGB Underlighting
+#define PRODUCT         onekey
-#define DESCRIPTION     QMK keyboard firmware for Clueboard
+#define DESCRIPTION     test board for qmk
 
 /* key matrix size */
-#define MATRIX_ROWS 10
+#define MATRIX_ROWS 1
-#define MATRIX_COLS 8
+#define MATRIX_COLS 1
 
-// ROWS: Top to bottom, COLS: Left to right
+#define MATRIX_COL_PINS {  B0 }
-/* Row pin configuration
+#define MATRIX_ROW_PINS {  D0 }
-* row: 0  1  2  3  4  5  6  7  8  9
-* pin: B2 C7 C6 B6 B5 B0 B3 D5 D3 D2
-*/
-#define MATRIX_ROW_PINS { B2, C7, C6, B6, B5, B0, B3, D5, D3, D2 }
-/* Column pin configuration
- * col: 0  1  2  3  4  5  6  7
- * pin: F0 F1 F4 F5 F6 F7 E6 B1
- */
-#define MATRIX_COL_PINS { F0, F1, F4, F5, F6, F7, E6, B1 }
 #define UNUSED_PINS
 
-/* COL2ROW or ROW2COL */
-#define DIODE_DIRECTION COL2ROW
-
 /* define if matrix has ghost */
 //#define MATRIX_HAS_GHOST
 
 /* Set 0 if debouncing isn't needed */
-#define DEBOUNCING_DELAY 5
+#define DEBOUNCE    5
 
 /* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
 #define LOCKING_SUPPORT_ENABLE
@@ -64,19 +52,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
     keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
 )
 
-/* Backlight configuration
- */
-#define BACKLIGHT_LEVELS 1
 
-/* Underlight configuration
- */
- #define ws2812_PORTREG PORTD
- #define ws2812_DDRREG DDRD
- #define ws2812_pin 7
- #define RGBLED_NUM 14     // Number of LEDs
- #define RGBLIGHT_HUE_STEP 10
- #define RGBLIGHT_SAT_STEP 17
- #define RGBLIGHT_VAL_STEP 17
 
 /*
  * Feature disable options

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

@@ -0,0 +1,5 @@
+#include "onekey.h"
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    { KC_A }
+};

keyboards/handwired/onekey/onekey.c

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

keyboards/handwired/onekey/onekey.h

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

keyboards/hhkb/matrix.c

@@ -71,6 +71,14 @@ void matrix_init(void)
     matrix_prev = _matrix1;
 }
 
+__attribute__ ((weak))
+void matrix_scan_user(void) {
+}
+
+void matrix_scan_kb(void) {
+  matrix_scan_user();
+}
+
 uint8_t matrix_scan(void)
 {
     uint8_t *tmp;
@@ -150,6 +158,9 @@ uint8_t matrix_scan(void)
         KEY_POWER_OFF();
         suspend_power_down();
     }
+
+    matrix_scan_quantum();
+
     return 1;
 }
 

keyboards/planck/Makefile

@@ -1,4 +1,5 @@
 
+SUBPROJECT_DEFAULT = rev4
 
 # MCU name
 #MCU = at90usb1287

keyboards/planck/config.h

@@ -23,7 +23,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* USB Device descriptor parameter */
 #define VENDOR_ID       0xFEED
 #define PRODUCT_ID      0x6060
-#define DEVICE_VER      0x0001
 #define MANUFACTURER    Ortholinear Keyboards
 #define PRODUCT         The Planck Keyboard
 #define DESCRIPTION     A compact ortholinear keyboard
@@ -79,4 +78,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //#define NO_ACTION_MACRO
 //#define NO_ACTION_FUNCTION
 
+#ifdef SUBPROJECT_rev3
+    #include "rev3/config.h"
+#endif
+#ifdef SUBPROJECT_rev4
+    #include "rev4/config.h"
+#endif
+
 #endif

keyboards/planck/keymaps/experimental/config.h

@@ -4,5 +4,6 @@
 #include "../../config.h"
 
 #define LEADER_TIMEOUT 300
+#define BACKLIGHT_BREATHING
 
 #endif

keyboards/planck/keymaps/experimental/keymap.c

@@ -23,15 +23,16 @@ extern keymap_config_t keymap_config;
 #define _PLOVER 5
 #define _ADJUST 16
 
-// Macro name shortcuts
+enum planck_keycodes {
-#define QWERTY M(_QWERTY)
+  QWERTY = SAFE_RANGE,
-#define COLEMAK M(_COLEMAK)
+  COLEMAK,
-#define DVORAK M(_DVORAK)
+  DVORAK,
-#define LOWER M(_LOWER)
+  PLOVER,
-#define RAISE M(_RAISE)
+  LOWER,
-#define M_BL 5
+  RAISE,
-#define PLOVER M(12)
+  BACKLIT,
-#define EXT_PLV M(13)
+  EXT_PLV
+};
 
 // Fillers to make layering more clear
 #define _______ KC_TRNS
@@ -54,7 +55,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   {KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_BSPC},
   {KC_ESC,  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT},
   {KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ENT },
-  {M(M_BL), KC_LCTL, KC_LALT, KC_LGUI, LOWER,   KC_SPC,  KC_SPC,  RAISE,   KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT}
+  {KC_LEAD, KC_LCTL, KC_LALT, KC_LGUI, LOWER,   KC_SPC,  KC_SPC,  RAISE,   KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT}
 },
 
 /* Colemak
@@ -90,7 +91,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   {KC_TAB,  KC_QUOT, KC_COMM, KC_DOT,  KC_P,    KC_Y,    KC_F,    KC_G,    KC_C,    KC_R,    KC_L,    KC_BSPC},
   {KC_ESC,  KC_A,    KC_O,    KC_E,    KC_U,    KC_I,    KC_D,    KC_H,    KC_T,    KC_N,    KC_S,    KC_SLSH},
   {KC_LSFT, KC_SCLN, KC_Q,    KC_J,    KC_K,    KC_X,    KC_B,    KC_M,    KC_W,    KC_V,    KC_Z,    KC_ENT },
-  {M(M_BL), KC_LCTL, KC_LALT, KC_LGUI, LOWER,   KC_SPC,  KC_SPC,  RAISE,   KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT}
+  {KC_LEAD, KC_LCTL, KC_LALT, KC_LGUI, LOWER,   KC_SPC,  KC_SPC,  RAISE,   KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT}
 },
 
 /* Lower
@@ -193,10 +194,10 @@ 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(id) {
+  switch (keycode) {
-        case _QWERTY:
+        case QWERTY:
           if (record->event.pressed) {
             #ifdef AUDIO_ENABLE
               PLAY_NOTE_ARRAY(tone_qwerty, false, 0);
@@ -204,7 +205,8 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
             persistant_default_layer_set(1UL<<_QWERTY);
           }
           break;
-        case _COLEMAK:
+      return false;
+        case COLEMAK:
           if (record->event.pressed) {
             #ifdef AUDIO_ENABLE
               PLAY_NOTE_ARRAY(tone_colemak, false, 0);
@@ -212,7 +214,8 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
             persistant_default_layer_set(1UL<<_COLEMAK);
           }
           break;
-        case _DVORAK:
+      return false;
+        case DVORAK:
           if (record->event.pressed) {
             #ifdef AUDIO_ENABLE
               PLAY_NOTE_ARRAY(tone_dvorak, false, 0);
@@ -220,7 +223,8 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
             persistant_default_layer_set(1UL<<_DVORAK);
           }
           break;
-        case _LOWER:
+      return false;
+        case LOWER:
           if (record->event.pressed) {
             layer_on(_LOWER);
             #ifdef BACKLIGHT_ENABLE
@@ -233,7 +237,8 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
             update_tri_layer(_LOWER, _RAISE, _ADJUST);
           }
           break;
-        case _RAISE:
+      return false;
+        case RAISE:
           if (record->event.pressed) {
             layer_on(_RAISE);
             #ifdef BACKLIGHT_ENABLE
@@ -246,7 +251,8 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
             update_tri_layer(_LOWER, _RAISE, _ADJUST);
           }
           break;
-        case M_BL:
+      return false;
+        case BACKLIT:
           if (record->event.pressed) {
             register_code(KC_RSFT);
             #ifdef BACKLIGHT_ENABLE
@@ -256,7 +262,8 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
             unregister_code(KC_RSFT);
           }
         break;
-        case 12:
+      return false;
+        case PLOVER:
           if (record->event.pressed) {
             #ifdef AUDIO_ENABLE
               stop_all_notes();
@@ -274,7 +281,8 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
             eeconfig_update_keymap(keymap_config.raw);
           }
         break;
-        case 13:
+      return false;
+        case EXT_PLV:
           if (record->event.pressed) {
             #ifdef AUDIO_ENABLE
               PLAY_NOTE_ARRAY(tone_plover_gb, false, 0);
@@ -282,9 +290,10 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
             layer_off(_PLOVER);
           }
         break;
+      return false;
 
       }
-    return MACRO_NONE;
+  return true;
 };
 
 void matrix_init_user(void) {
@@ -326,6 +335,17 @@ void matrix_scan_user(void) {
     leading = false;
     leader_end(); 
 
+    SEQ_ONE_KEY (KC_R) {
+      tap_random_base64();
+      tap_random_base64();
+      tap_random_base64();
+      tap_random_base64();
+      tap_random_base64();
+      tap_random_base64();
+      tap_random_base64();
+      tap_random_base64();
+      tap_random_base64();
+    }
     SEQ_ONE_KEY (KC_V) {
       SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
     }

keyboards/planck/keymaps/yang/Makefile

@@ -3,6 +3,7 @@
 #   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.
+AUDIO_ENABLE = no
 
 ifndef QUANTUM_DIR
 	include ../../../../Makefile

keyboards/planck/planck.h

@@ -1,6 +1,13 @@
 #ifndef PLANCK_H
 #define PLANCK_H
 
+#ifdef SUBPROJECT_rev3
+    #include "rev3.h"
+#endif
+#ifdef SUBPROJECT_rev4
+    #include "rev4.h"
+#endif
+
 #include "quantum.h"
 
 #define PLANCK_MIT( \

keyboards/planck/rev3/Makefile

@@ -0,0 +1,5 @@
+AUDIO_ENABLE ?= no           # Audio output on port C6
+
+ifndef QUANTUM_DIR
+	include ../../../Makefile
+endif

keyboards/planck/rev3/config.h

@@ -0,0 +1,8 @@
+#ifndef REV3_CONFIG_H
+#define REV3_CONFIG_H
+
+#include "../config.h"
+
+#define DEVICE_VER 0x0003
+
+#endif

keyboards/planck/rev3/rev3.c

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

keyboards/planck/rev3/rev3.h

@@ -0,0 +1,6 @@
+#ifndef REV3_H
+#define REV3_H
+
+#include "../planck.h"
+
+#endif

keyboards/planck/rev4/Makefile

@@ -0,0 +1,5 @@
+AUDIO_ENABLE ?= yes           # Audio output on port C6
+
+ifndef QUANTUM_DIR
+	include ../../../Makefile
+endif

keyboards/planck/rev4/config.h

@@ -0,0 +1,8 @@
+#ifndef REV4_CONFIG_H
+#define REV4_CONFIG_H
+
+#include "../config.h"
+
+#define DEVICE_VER 0x0004
+
+#endif

keyboards/planck/rev4/rev4.c

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

keyboards/planck/rev4/rev4.h

@@ -0,0 +1,6 @@
+#ifndef REV4_H
+#define REV4_H
+
+#include "../planck.h"
+
+#endif

keyboards/readme.md

@@ -23,8 +23,7 @@ Made in Taiwan using advanced robotic manufacturing, the ErgoDox EZ is a fully-a
 
 Designed and built in Felton, CA, Clueboards keyboard emphasize quality and locally sourced components, available on [clueboard.co](http://clueboard.co)
 
-* [Clueboard rev.1](/keyboards/clueboard1/) - The old Clueboard.
+* [Clueboard](/keyboards/clueboard/) - The 66% custom keyboard.
-* [Clueboard rev.2](/keyboards/clueboard2/) - New and improved! The Clueboard, revision 2.
 * [Cluepad](/keyboards/cluepad/) - A mechanical numpad with QMK superpowers.
 
 

keyboards/satan/satan.c

@@ -22,9 +22,9 @@ void led_init_ports(void) {
 void led_set_kb(uint8_t usb_led) {
     if (usb_led & (1<<USB_LED_CAPS_LOCK)) {
         // Turn capslock on
-        PORTB |= (1<<2);
+        PORTB &= ~(1<<2);
     } else {
         // Turn capslock off
-        PORTB &= ~(1<<2);
+        PORTB |= (1<<2);
     }
 }

keyboards/sixkeyboard/matrix.c

@@ -87,7 +87,7 @@ uint8_t matrix_scan(void)
     matrix[0] = (PINC&(1<<7) ? 0 : (1<<0)) | (PINB&(1<<7) ? 0 : (1<<1)) | (PINB&(1<<5) ? 0 : (1<<2));
     matrix[1] = (PIND&(1<<6) ? 0 : (1<<0)) | (PIND&(1<<1) ? 0 : (1<<1)) | (PIND&(1<<4) ? 0 : (1<<2));
 
-    matrix_scan_kb();
+    matrix_scan_quantum();
 
     return 1;
 }

quantum/audio/audio.h

@@ -1,3 +1,6 @@
+#ifndef AUDIO_H
+#define AUDIO_H
+
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/io.h>
@@ -7,9 +10,6 @@
 #include "voices.h"
 #include "quantum.h"
 
-#ifndef AUDIO_H
-#define AUDIO_H
-
 // Largely untested PWM audio mode (doesn't sound as good)
 // #define PWM_AUDIO
 

quantum/keymap.h

@@ -77,6 +77,8 @@ enum quantum_keycodes {
 #endif
     QK_MOD_TAP            = 0x6000,
     QK_MOD_TAP_MAX        = 0x6FFF,
+    QK_TAP_DANCE          = 0x7100,
+    QK_TAP_DANCE_MAX      = 0x71FF,
 #ifdef UNICODE_ENABLE
     QK_UNICODE            = 0x8000,
     QK_UNICODE_MAX        = 0xFFFF,

quantum/keymap_midi.c

@@ -1,109 +0,0 @@
-/*
-Copyright 2015 Jack Humbert <jack.humb@gmail.com>
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "keymap.h"
-#include "keymap_midi.h"
-
-uint8_t starting_note = 0x0C;
-int offset = 7;
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt)
-{
-	if (id != 0) {
-	    if (record->event.pressed) {
-	    	midi_send_noteon(&midi_device, opt, (id & 0xFF), 127);
-	    } else {
-	        midi_send_noteoff(&midi_device, opt, (id & 0xFF), 127);
-	    }
-	}
-
-    if (record->event.key.col == (MATRIX_COLS - 1) && record->event.key.row == (MATRIX_ROWS - 1)) {
-        if (record->event.pressed) {
-            starting_note++;
-            play_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[0 + offset])/12.0+(MATRIX_ROWS - 1)), 0xC);
-            midi_send_cc(&midi_device, 0, 0x7B, 0);
-            midi_send_cc(&midi_device, 1, 0x7B, 0);
-            midi_send_cc(&midi_device, 2, 0x7B, 0);
-            midi_send_cc(&midi_device, 3, 0x7B, 0);
-            midi_send_cc(&midi_device, 4, 0x7B, 0);
-            return;
-        } else {
-            stop_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[0 + offset])/12.0+(MATRIX_ROWS - 1)));
-            stop_all_notes();
-            return;
-        }
-    }
-    if (record->event.key.col == (MATRIX_COLS - 2) && record->event.key.row == (MATRIX_ROWS - 1)) {
-        if (record->event.pressed) {
-            starting_note--;
-            play_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[0 + offset])/12.0+(MATRIX_ROWS - 1)), 0xC);
-            midi_send_cc(&midi_device, 0, 0x7B, 0);
-            midi_send_cc(&midi_device, 1, 0x7B, 0);
-            midi_send_cc(&midi_device, 2, 0x7B, 0);
-            midi_send_cc(&midi_device, 3, 0x7B, 0);
-            midi_send_cc(&midi_device, 4, 0x7B, 0);
-            return;
-        } else {
-            stop_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[0 + offset])/12.0+(MATRIX_ROWS - 1)));
-            stop_all_notes();
-            return;
-        }
-    }
-
-    if (record->event.key.col == (MATRIX_COLS - 3) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
-        offset++;
-        midi_send_cc(&midi_device, 0, 0x7B, 0);
-        midi_send_cc(&midi_device, 1, 0x7B, 0);
-        midi_send_cc(&midi_device, 2, 0x7B, 0);
-        midi_send_cc(&midi_device, 3, 0x7B, 0);
-        midi_send_cc(&midi_device, 4, 0x7B, 0);
-        stop_all_notes();
-        for (int i = 0; i <= 7; i++) {
-            play_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[i + offset])/12.0+(MATRIX_ROWS - 1)), 0xC);
-            _delay_us(80000);
-            stop_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[i + offset])/12.0+(MATRIX_ROWS - 1)));
-            _delay_us(8000);
-        }
-        return;
-    }
-    if (record->event.key.col == (MATRIX_COLS - 4) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
-        offset--;
-        midi_send_cc(&midi_device, 0, 0x7B, 0);
-        midi_send_cc(&midi_device, 1, 0x7B, 0);
-        midi_send_cc(&midi_device, 2, 0x7B, 0);
-        midi_send_cc(&midi_device, 3, 0x7B, 0);
-        midi_send_cc(&midi_device, 4, 0x7B, 0);
-        stop_all_notes();
-        for (int i = 0; i <= 7; i++) {
-            play_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[i + offset])/12.0+(MATRIX_ROWS - 1)), 0xC);
-            _delay_us(80000);
-            stop_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[i + offset])/12.0+(MATRIX_ROWS - 1)));
-            _delay_us(8000);
-        }
-        return;
-    }
-
-    if (record->event.pressed) {
-    	// midi_send_noteon(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
-        // midi_send_noteon(&midi_device, 0, (starting_note + SCALE[record->event.key.col + offset])+12*(MATRIX_ROWS - record->event.key.row), 127);
-        play_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[record->event.key.col + offset])/12.0+(MATRIX_ROWS - record->event.key.row)), 0xF);
-    } else {
-        // midi_send_noteoff(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
-        // midi_send_noteoff(&midi_device, 0, (starting_note + SCALE[record->event.key.col + offset])+12*(MATRIX_ROWS - record->event.key.row), 127);
-        stop_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[record->event.key.col + offset])/12.0+(MATRIX_ROWS - record->event.key.row)));
-    }
-}

quantum/matrix.c

@@ -86,29 +86,29 @@ uint8_t matrix_cols(void) {
     return MATRIX_COLS;
 }
 
-void matrix_power_up(void) {
+// void matrix_power_up(void) {
-#if DIODE_DIRECTION == COL2ROW
+// #if DIODE_DIRECTION == COL2ROW
-    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+//     for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
-        /* DDRxn */
+//         /* DDRxn */
-        _SFR_IO8((row_pins[r] >> 4) + 1) |= _BV(row_pins[r] & 0xF);
+//         _SFR_IO8((row_pins[r] >> 4) + 1) |= _BV(row_pins[r] & 0xF);
-        toggle_row(r);
+//         toggle_row(r);
-    }
+//     }
-    for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
+//     for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
-        /* PORTxn */
+//         /* PORTxn */
-        _SFR_IO8((col_pins[c] >> 4) + 2) |= _BV(col_pins[c] & 0xF);
+//         _SFR_IO8((col_pins[c] >> 4) + 2) |= _BV(col_pins[c] & 0xF);
-    }
+//     }
-#else
+// #else
-    for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
+//     for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
-        /* DDRxn */
+//         /* DDRxn */
-        _SFR_IO8((col_pins[c] >> 4) + 1) |= _BV(col_pins[c] & 0xF);
+//         _SFR_IO8((col_pins[c] >> 4) + 1) |= _BV(col_pins[c] & 0xF);
-        toggle_col(c);
+//         toggle_col(c);
-    }
+//     }
-    for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+//     for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
-        /* PORTxn */
+//         /* PORTxn */
-        _SFR_IO8((row_pins[r] >> 4) + 2) |= _BV(row_pins[r] & 0xF);
+//         _SFR_IO8((row_pins[r] >> 4) + 2) |= _BV(row_pins[r] & 0xF);
-    }
+//     }
-#endif
+// #endif
-}
+// }
 
 void matrix_init(void) {
     /* frees PORTF by setting the JTD bit twice within four cycles */

quantum/process_keycode/process_chording.c

@@ -0,0 +1,60 @@
+#include "process_chording.h"
+
+bool keys_chord(uint8_t keys[]) {
+  uint8_t keys_size = sizeof(keys)/sizeof(keys[0]);
+  bool pass = true;
+  uint8_t in = 0;
+  for (uint8_t i = 0; i < chord_key_count; i++) {
+    bool found = false;
+    for (uint8_t j = 0; j < keys_size; j++) {
+      if (chord_keys[i] == (keys[j] & 0xFF)) {
+        in++; // detects key in chord
+        found = true;
+        break;
+      }
+    }
+    if (found)
+      continue;
+    if (chord_keys[i] != 0)  {
+      pass = false; // makes sure rest are blank
+    }
+  }
+  return (pass && (in == keys_size));
+}
+
+bool process_chording(uint16_t keycode, keyrecord_t *record) {
+  if (keycode >= QK_CHORDING && keycode <= QK_CHORDING_MAX) {
+    if (record->event.pressed) {
+      if (!chording) {
+        chording = true;
+        for (uint8_t i = 0; i < CHORDING_MAX; i++)
+          chord_keys[i] = 0;
+        chord_key_count = 0;
+        chord_key_down = 0;
+      }
+      chord_keys[chord_key_count] = (keycode & 0xFF);
+      chord_key_count++;
+      chord_key_down++;
+      return false;
+    } else {
+      if (chording) {
+        chord_key_down--;
+        if (chord_key_down == 0) {
+          chording = false;
+          // Chord Dictionary
+          if (keys_chord((uint8_t[]){KC_ENTER, KC_SPACE})) {
+            register_code(KC_A);
+            unregister_code(KC_A);
+            return false;
+          }
+          for (uint8_t i = 0; i < chord_key_count; i++) {
+            register_code(chord_keys[i]);
+            unregister_code(chord_keys[i]);
+            return false;
+          }
+        }
+      }
+    }
+  }
+  return true;
+}

quantum/process_keycode/process_chording.h

@@ -0,0 +1,16 @@
+#ifndef PROCESS_CHORDING_H
+#define PROCESS_CHORDING_H
+
+#include "quantum.h"
+
+// Chording stuff
+#define CHORDING_MAX 4
+bool chording = false;
+
+uint8_t chord_keys[CHORDING_MAX] = {0};
+uint8_t chord_key_count = 0;
+uint8_t chord_key_down = 0;
+
+bool process_chording(uint16_t keycode, keyrecord_t *record);
+
+#endif

quantum/process_keycode/process_leader.c

@@ -0,0 +1,38 @@
+#include "process_leader.h"
+
+__attribute__ ((weak))
+void leader_start(void) {}
+
+__attribute__ ((weak))
+void leader_end(void) {}
+
+// Leader key stuff
+bool leading = false;
+uint16_t leader_time = 0;
+
+uint16_t leader_sequence[5] = {0, 0, 0, 0, 0};
+uint8_t leader_sequence_size = 0;
+
+bool process_leader(uint16_t keycode, keyrecord_t *record) {
+  // Leader key set-up
+  if (record->event.pressed) {
+    if (!leading && keycode == KC_LEAD) {
+      leader_start();
+      leading = true;
+      leader_time = timer_read();
+      leader_sequence_size = 0;
+      leader_sequence[0] = 0;
+      leader_sequence[1] = 0;
+      leader_sequence[2] = 0;
+      leader_sequence[3] = 0;
+      leader_sequence[4] = 0;
+      return false;
+    }
+    if (leading && timer_elapsed(leader_time) < LEADER_TIMEOUT) {
+      leader_sequence[leader_sequence_size] = keycode;
+      leader_sequence_size++;
+      return false;
+    }
+  }
+  return true;
+}

quantum/process_keycode/process_leader.h

@@ -0,0 +1,23 @@
+#ifndef PROCESS_LEADER_H
+#define PROCESS_LEADER_H
+
+#include "quantum.h"
+
+bool process_leader(uint16_t keycode, keyrecord_t *record);
+
+void leader_start(void);
+void leader_end(void);
+
+#ifndef LEADER_TIMEOUT
+  #define LEADER_TIMEOUT 200
+#endif
+#define SEQ_ONE_KEY(key) if (leader_sequence[0] == (key) && leader_sequence[1] == 0 && leader_sequence[2] == 0 && leader_sequence[3] == 0 && leader_sequence[4] == 0)
+#define SEQ_TWO_KEYS(key1, key2) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == 0 && leader_sequence[3] == 0 && leader_sequence[4] == 0)
+#define SEQ_THREE_KEYS(key1, key2, key3) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == (key3) && leader_sequence[3] == 0 && leader_sequence[4] == 0)
+#define SEQ_FOUR_KEYS(key1, key2, key3, key4) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == (key3) && leader_sequence[3] == (key4) && leader_sequence[4] == 0)
+#define SEQ_FIVE_KEYS(key1, key2, key3, key4, key5) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == (key3) && leader_sequence[3] == (key4) && leader_sequence[4] == (key5))
+
+#define LEADER_EXTERNS() extern bool leading; extern uint16_t leader_time; extern uint16_t leader_sequence[5]; extern uint8_t leader_sequence_size
+#define LEADER_DICTIONARY() if (leading && timer_elapsed(leader_time) > LEADER_TIMEOUT)
+
+#endif

quantum/process_keycode/process_midi.c

@@ -0,0 +1,66 @@
+#include "process_midi.h"
+
+bool midi_activated = false;
+uint8_t starting_note = 0x0C;
+int offset = 7;
+
+bool process_midi(uint16_t keycode, keyrecord_t *record) {
+    if (keycode == MI_ON && record->event.pressed) {
+      midi_activated = true;
+      music_scale_user();
+      return false;
+    }
+
+    if (keycode == MI_OFF && record->event.pressed) {
+      midi_activated = false;
+      midi_send_cc(&midi_device, 0, 0x7B, 0);
+      return false;
+    }
+
+    if (midi_activated) {
+      if (record->event.key.col == (MATRIX_COLS - 1) && record->event.key.row == (MATRIX_ROWS - 1)) {
+          if (record->event.pressed) {
+              starting_note++; // Change key
+              midi_send_cc(&midi_device, 0, 0x7B, 0);
+          }
+          return false;
+      }
+      if (record->event.key.col == (MATRIX_COLS - 2) && record->event.key.row == (MATRIX_ROWS - 1)) {
+          if (record->event.pressed) {
+              starting_note--; // Change key
+              midi_send_cc(&midi_device, 0, 0x7B, 0);
+          }
+          return false;
+      }
+      if (record->event.key.col == (MATRIX_COLS - 3) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
+          offset++; // Change scale
+          midi_send_cc(&midi_device, 0, 0x7B, 0);
+          return false;
+      }
+      if (record->event.key.col == (MATRIX_COLS - 4) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
+          offset--; // Change scale
+          midi_send_cc(&midi_device, 0, 0x7B, 0);
+          return false;
+      }
+      // basic
+      // uint8_t note = (starting_note + SCALE[record->event.key.col + offset])+12*(MATRIX_ROWS - record->event.key.row);
+      // advanced
+      // uint8_t note = (starting_note + record->event.key.col + offset)+12*(MATRIX_ROWS - record->event.key.row);
+      // guitar
+      uint8_t note = (starting_note + record->event.key.col + offset)+5*(MATRIX_ROWS - record->event.key.row);
+      // violin
+      // uint8_t note = (starting_note + record->event.key.col + offset)+7*(MATRIX_ROWS - record->event.key.row);
+
+      if (record->event.pressed) {
+        // midi_send_noteon(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
+        midi_send_noteon(&midi_device, 0, note, 127);
+      } else {
+        // midi_send_noteoff(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
+        midi_send_noteoff(&midi_device, 0, note, 127);
+      }
+
+      if (keycode < 0xFF) // ignores all normal keycodes, but lets RAISE, LOWER, etc through
+        return false;
+    }
+  return true;
+}

quantum/process_keycode/process_midi.h

@@ -1,24 +1,9 @@
-/*
+#ifndef PROCESS_MIDI_H
-Copyright 2015 Jack Humbert <jack.humb@gmail.com>
+#define PROCESS_MIDI_H
 
-This program is free software: you can redistribute it and/or modify
+#include "quantum.h"
-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,
+bool process_midi(uint16_t keycode, keyrecord_t *record);
-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 KEYMAP_MIDI_H
-#define KEYMAP_MIDI_H
-
-#include <lufa.h>
 
 #define MIDI(n) ((n) | 0x6000)
 #define MIDI12 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000

quantum/process_keycode/process_music.c

@@ -0,0 +1,171 @@
+#include "process_music.h"
+
+bool music_activated = false;
+uint8_t starting_note = 0x0C;
+int offset = 7;
+
+// music sequencer
+static bool music_sequence_recording = false;
+static bool music_sequence_playing = false;
+static float music_sequence[16] = {0};
+static uint8_t music_sequence_count = 0;
+static uint8_t music_sequence_position = 0;
+
+static uint16_t music_sequence_timer = 0;
+static uint16_t music_sequence_interval = 100;
+
+bool process_music(uint16_t keycode, keyrecord_t *record) {
+
+    if (keycode == AU_ON && record->event.pressed) {
+      audio_on();
+      return false;
+    }
+
+    if (keycode == AU_OFF && record->event.pressed) {
+      audio_off();
+      return false;
+    }
+
+    if (keycode == AU_TOG && record->event.pressed) {
+        if (is_audio_on())
+        {
+            audio_off();
+        }
+        else
+        {
+            audio_on();
+        }
+      return false;
+    }
+
+    if (keycode == MU_ON && record->event.pressed) {
+        music_on();
+        return false;
+    }
+
+    if (keycode == MU_OFF && record->event.pressed) {
+        music_off();
+        return false;
+    }
+
+    if (keycode == MU_TOG && record->event.pressed) {
+        if (music_activated)
+        {
+            music_off();
+        }
+        else
+        {
+            music_on();
+        }
+        return false;
+    }
+
+    if (keycode == MUV_IN && record->event.pressed) {
+        voice_iterate();
+        music_scale_user();
+        return false;
+    }
+
+    if (keycode == MUV_DE && record->event.pressed) {
+        voice_deiterate();
+        music_scale_user();
+        return false;
+    }
+
+    if (music_activated) {
+
+      if (keycode == KC_LCTL && record->event.pressed) { // Start recording
+        stop_all_notes();
+        music_sequence_recording = true;
+        music_sequence_playing = false;
+        music_sequence_count = 0;
+        return false;
+      }
+
+      if (keycode == KC_LALT && record->event.pressed) { // Stop recording/playing
+        stop_all_notes();
+        music_sequence_recording = false;
+        music_sequence_playing = false;
+        return false;
+      }
+
+      if (keycode == KC_LGUI && record->event.pressed) { // Start playing
+        stop_all_notes();
+        music_sequence_recording = false;
+        music_sequence_playing = true;
+        music_sequence_position = 0;
+        music_sequence_timer = 0;
+        return false;
+      }
+
+      if (keycode == KC_UP) {
+        if (record->event.pressed)
+            music_sequence_interval-=10;
+        return false;
+      }
+
+      if (keycode == KC_DOWN) {
+        if (record->event.pressed)
+            music_sequence_interval+=10;
+        return false;
+      }
+
+      float freq = ((float)220.0)*pow(2.0, -5.0)*pow(2.0,(starting_note + SCALE[record->event.key.col + offset])/12.0+(MATRIX_ROWS - record->event.key.row));
+      if (record->event.pressed) {
+        play_note(freq, 0xF);
+        if (music_sequence_recording) {
+          music_sequence[music_sequence_count] = freq;
+          music_sequence_count++;
+        }
+      } else {
+        stop_note(freq);
+      }
+
+      if (keycode < 0xFF) // ignores all normal keycodes, but lets RAISE, LOWER, etc through
+        return false;
+    }
+  return true;
+}
+
+bool is_music_on(void) {
+    return (music_activated != 0);
+}
+
+void music_toggle(void) {
+    if (!music_activated) {
+        music_on();
+    } else {
+        music_off();
+    }
+}
+
+void music_on(void) {
+    music_activated = 1;
+    music_on_user();
+}
+
+void music_off(void) {
+    music_activated = 0;
+    stop_all_notes();
+}
+
+
+__attribute__ ((weak))
+void music_on_user() {}
+
+__attribute__ ((weak))
+void audio_on_user() {}
+
+__attribute__ ((weak))
+void music_scale_user() {}
+
+void matrix_scan_music(void) {
+  if (music_sequence_playing) {
+    if ((music_sequence_timer == 0) || (timer_elapsed(music_sequence_timer) > music_sequence_interval)) {
+      music_sequence_timer = timer_read();
+      stop_note(music_sequence[(music_sequence_position - 1 < 0)?(music_sequence_position - 1 + music_sequence_count):(music_sequence_position - 1)]);
+      play_note(music_sequence[music_sequence_position], 0xF);
+      music_sequence_position = (music_sequence_position + 1) % music_sequence_count;
+    }
+  }
+}

quantum/process_keycode/process_music.h

@@ -0,0 +1,27 @@
+#ifndef PROCESS_MUSIC_H
+#define PROCESS_MUSIC_H
+
+#include "quantum.h"
+
+bool process_music(uint16_t keycode, keyrecord_t *record);
+
+bool is_music_on(void);
+void music_toggle(void);
+void music_on(void);
+void music_off(void);
+
+void audio_on_user(void);
+void music_on_user(void);
+void music_scale_user(void);
+
+void matrix_scan_music(void);
+
+#ifndef SCALE
+#define SCALE (int8_t []){ 0 + (12*0), 2 + (12*0), 4 + (12*0), 5 + (12*0), 7 + (12*0), 9 + (12*0), 11 + (12*0), \
+                           0 + (12*1), 2 + (12*1), 4 + (12*1), 5 + (12*1), 7 + (12*1), 9 + (12*1), 11 + (12*1), \
+                           0 + (12*2), 2 + (12*2), 4 + (12*2), 5 + (12*2), 7 + (12*2), 9 + (12*2), 11 + (12*2), \
+                           0 + (12*3), 2 + (12*3), 4 + (12*3), 5 + (12*3), 7 + (12*3), 9 + (12*3), 11 + (12*3), \
+                           0 + (12*4), 2 + (12*4), 4 + (12*4), 5 + (12*4), 7 + (12*4), 9 + (12*4), 11 + (12*4), }
+#endif
+
+#endif

quantum/process_keycode/process_tap_dance.c

@@ -0,0 +1,90 @@
+#include "quantum.h"
+
+static qk_tap_dance_state_t qk_tap_dance_state;
+
+static void _process_tap_dance_action_pair (qk_tap_dance_state_t *state,
+                                            uint16_t kc1, uint16_t kc2) {
+  uint16_t kc;
+
+  if (state->count == 0)
+    return;
+
+  kc = (state->count == 1) ? kc1 : kc2;
+
+  register_code (kc);
+  unregister_code (kc);
+
+  if (state->count >= 2) {
+    reset_tap_dance (state);
+  }
+}
+
+static void _process_tap_dance_action_fn (qk_tap_dance_state_t *state,
+                                          qk_tap_dance_user_fn_t fn)
+{
+  fn(state);
+}
+
+void process_tap_dance_action (uint16_t keycode)
+{
+  uint16_t idx = keycode - QK_TAP_DANCE;
+  qk_tap_dance_action_t action;
+
+  action = tap_dance_actions[idx];
+
+  switch (action.type) {
+  case QK_TAP_DANCE_TYPE_PAIR:
+    _process_tap_dance_action_pair (&qk_tap_dance_state,
+                                    action.pair.kc1, action.pair.kc2);
+    break;
+  case QK_TAP_DANCE_TYPE_FN:
+    _process_tap_dance_action_fn (&qk_tap_dance_state, action.fn);
+    break;
+
+  default:
+    break;
+  }
+}
+
+bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
+  bool r = true;
+
+  switch(keycode) {
+  case QK_TAP_DANCE ... QK_TAP_DANCE_MAX:
+    if (qk_tap_dance_state.keycode && qk_tap_dance_state.keycode != keycode) {
+      process_tap_dance_action (qk_tap_dance_state.keycode);
+    } else {
+      r = false;
+    }
+
+    if (record->event.pressed) {
+      qk_tap_dance_state.keycode = keycode;
+      qk_tap_dance_state.timer = timer_read ();
+      qk_tap_dance_state.count++;
+    }
+    break;
+
+  default:
+    if (qk_tap_dance_state.keycode) {
+      process_tap_dance_action (qk_tap_dance_state.keycode);
+
+      reset_tap_dance (&qk_tap_dance_state);
+    }
+    break;
+  }
+
+  return r;
+}
+
+void matrix_scan_tap_dance () {
+  if (qk_tap_dance_state.keycode && timer_elapsed (qk_tap_dance_state.timer) > TAPPING_TERM) {
+    process_tap_dance_action (qk_tap_dance_state.keycode);
+
+    reset_tap_dance (&qk_tap_dance_state);
+  }
+}
+
+void reset_tap_dance (qk_tap_dance_state_t *state) {
+  state->keycode = 0;
+  state->count = 0;
+}

quantum/process_keycode/process_tap_dance.h

@@ -0,0 +1,62 @@
+#ifndef PROCESS_TAP_DANCE_H
+#define PROCESS_TAP_DANCE_H
+
+#ifdef TAP_DANCE_ENABLE
+
+#include <stdbool.h>
+#include <inttypes.h>
+
+typedef struct
+{
+  uint8_t count;
+  uint16_t keycode;
+  uint16_t timer;
+} qk_tap_dance_state_t;
+
+#define TD(n) (QK_TAP_DANCE + n)
+
+typedef enum
+{
+  QK_TAP_DANCE_TYPE_PAIR,
+  QK_TAP_DANCE_TYPE_FN,
+} qk_tap_dance_type_t;
+
+typedef void (*qk_tap_dance_user_fn_t) (qk_tap_dance_state_t *state);
+
+typedef struct
+{
+  qk_tap_dance_type_t type;
+  union {
+    struct {
+      uint16_t kc1;
+      uint16_t kc2;
+    } pair;
+    qk_tap_dance_user_fn_t fn;
+  };
+} qk_tap_dance_action_t;
+
+#define ACTION_TAP_DANCE_DOUBLE(kc1, kc2) { \
+    .type = QK_TAP_DANCE_TYPE_PAIR,         \
+    .pair = { kc1, kc2 }                    \
+  }
+
+#define ACTION_TAP_DANCE_FN(user_fn) { \
+    .type = QK_TAP_DANCE_TYPE_FN, \
+    .fn = user_fn                 \
+  }
+
+extern const qk_tap_dance_action_t tap_dance_actions[];
+
+/* To be used internally */
+
+bool process_tap_dance(uint16_t keycode, keyrecord_t *record);
+void matrix_scan_tap_dance (void);
+void reset_tap_dance (qk_tap_dance_state_t *state);
+
+#else
+
+#define TD(n) KC_NO
+
+#endif
+
+#endif

quantum/process_keycode/process_unicode.c

@@ -0,0 +1,57 @@
+#include "process_unicode.h"
+
+static uint8_t input_mode;
+
+uint16_t hex_to_keycode(uint8_t hex)
+{
+  if (hex == 0x0) {
+    return KC_0;
+  } else if (hex < 0xA) {
+    return KC_1 + (hex - 0x1);
+  } else {
+    return KC_A + (hex - 0xA);
+  }
+}
+
+void set_unicode_mode(uint8_t os_target)
+{
+  input_mode = os_target;
+}
+
+bool process_unicode(uint16_t keycode, keyrecord_t *record) {
+  if (keycode > QK_UNICODE && record->event.pressed) {
+    uint16_t unicode = keycode & 0x7FFF;
+    switch(input_mode) {
+      case UC_OSX:
+        register_code(KC_LALT);
+        break;
+      case UC_LNX:
+        register_code(KC_LCTL);
+        register_code(KC_LSFT);
+        register_code(KC_U);
+        unregister_code(KC_U);
+        break;
+      case UC_WIN:
+        register_code(KC_LALT);
+        register_code(KC_PPLS);
+        unregister_code(KC_PPLS);
+        break;
+    }
+    for(int i = 3; i >= 0; i--) {
+        uint8_t digit = ((unicode >> (i*4)) & 0xF);
+        register_code(hex_to_keycode(digit));
+        unregister_code(hex_to_keycode(digit));
+    }
+    switch(input_mode) {
+      case UC_OSX:
+      case UC_WIN:
+        unregister_code(KC_LALT);
+        break;
+      case UC_LNX:
+        unregister_code(KC_LCTL);
+        unregister_code(KC_LSFT);
+        break;
+    }
+  }
+  return true;
+}

quantum/process_keycode/process_unicode.h

@@ -1,22 +1,16 @@
-/*
+#ifndef PROCESS_UNICODE_H
-Copyright 2016 Jack Humbert <jack.humb@gmail.com>
+#define PROCESS_UNICODE_H
-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 UNICODE_H
-#define UNICODE_H
 
 #include "quantum.h"
-#include <math.h>
+
+#define UC_OSX 0
+#define UC_LNX 1
+#define UC_WIN 2
+#define UC_BSD 3
+
+void set_unicode_input_mode(uint8_t os_target);
+
+bool process_unicode(uint16_t keycode, keyrecord_t *record);
 
 #define UC_BSPC	UC(0x0008)
 

quantum/quantum.c

@@ -15,54 +15,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   return true;
 }
 
-__attribute__ ((weak))
-void leader_start(void) {}
-
-__attribute__ ((weak))
-void leader_end(void) {}
-
-uint8_t starting_note = 0x0C;
-int offset = 7;
-
-
-#ifdef AUDIO_ENABLE
-  bool music_activated = false;
-
-  // music sequencer
-  static bool music_sequence_recording = false;
-  static bool music_sequence_playing = false;
-  static float music_sequence[16] = {0};
-  static uint8_t music_sequence_count = 0;
-  static uint8_t music_sequence_position = 0;
-
-  static uint16_t music_sequence_timer = 0;
-  static uint16_t music_sequence_interval = 100;
-
-#endif
-
-#ifdef MIDI_ENABLE
-  bool midi_activated = false;
-#endif
-
-// Leader key stuff
-bool leading = false;
-uint16_t leader_time = 0;
-
-uint16_t leader_sequence[5] = {0, 0, 0, 0, 0};
-uint8_t leader_sequence_size = 0;
-
-// Chording stuff
-#define CHORDING_MAX 4
-bool chording = false;
-
-uint8_t chord_keys[CHORDING_MAX] = {0};
-uint8_t chord_key_count = 0;
-uint8_t chord_key_down = 0;
-
-#ifdef UNICODE_ENABLE
-  static uint8_t input_mode;
-#endif
-
 // Shift / paren setup
 
 #ifndef LSPO_KEY
@@ -74,48 +26,6 @@ uint8_t chord_key_down = 0;
 
 static bool shift_interrupted[2] = {0, 0};
 
-bool keys_chord(uint8_t keys[]) {
-  uint8_t keys_size = sizeof(keys)/sizeof(keys[0]);
-  bool pass = true;
-  uint8_t in = 0;
-  for (uint8_t i = 0; i < chord_key_count; i++) {
-    bool found = false;
-    for (uint8_t j = 0; j < keys_size; j++) {
-      if (chord_keys[i] == (keys[j] & 0xFF)) {
-        in++; // detects key in chord
-        found = true;
-        break;
-      }
-    }
-    if (found)
-      continue;
-    if (chord_keys[i] != 0)  {
-      pass = false; // makes sure rest are blank
-    }
-  }
-  return (pass && (in == keys_size));
-}
-
-#ifdef UNICODE_ENABLE
-
-uint16_t hex_to_keycode(uint8_t hex)
-{
-  if (hex == 0x0) {
-    return KC_0;
-  } else if (hex < 0xA) {
-    return KC_1 + (hex - 0x1);
-  } else {
-    return KC_A + (hex - 0xA);
-  }
-}
-
-void set_unicode_mode(uint8_t os_target)
-{
-  input_mode = os_target;
-}
-
-#endif
-
 bool process_record_quantum(keyrecord_t *record) {
 
   /* This gets the keycode from the key pressed */
@@ -136,9 +46,6 @@ bool process_record_quantum(keyrecord_t *record) {
     keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
   #endif
 
-  if (!process_record_kb(keycode, record))
-    return false;
-
     // This is how you use actions here
     // if (keycode == KC_LEAD) {
     //   action_t action;
@@ -147,278 +54,30 @@ bool process_record_quantum(keyrecord_t *record) {
     //   return false;
     // }
 
+  if (!(
+    process_record_kb(keycode, record) &&
   #ifdef MIDI_ENABLE
-    if (keycode == MI_ON && record->event.pressed) {
+    process_midi(keycode, record) &&
-      midi_activated = true;
-      music_scale_user();
-      return false;
-    }
-
-    if (keycode == MI_OFF && record->event.pressed) {
-      midi_activated = false;
-      midi_send_cc(&midi_device, 0, 0x7B, 0);
-      return false;
-    }
-
-    if (midi_activated) {
-      if (record->event.key.col == (MATRIX_COLS - 1) && record->event.key.row == (MATRIX_ROWS - 1)) {
-          if (record->event.pressed) {
-              starting_note++; // Change key
-              midi_send_cc(&midi_device, 0, 0x7B, 0);
-          }
-          return false;
-      }
-      if (record->event.key.col == (MATRIX_COLS - 2) && record->event.key.row == (MATRIX_ROWS - 1)) {
-          if (record->event.pressed) {
-              starting_note--; // Change key
-              midi_send_cc(&midi_device, 0, 0x7B, 0);
-          }
-          return false;
-      }
-      if (record->event.key.col == (MATRIX_COLS - 3) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
-          offset++; // Change scale
-          midi_send_cc(&midi_device, 0, 0x7B, 0);
-          return false;
-      }
-      if (record->event.key.col == (MATRIX_COLS - 4) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
-          offset--; // Change scale
-          midi_send_cc(&midi_device, 0, 0x7B, 0);
-          return false;
-      }
-      // basic
-      // uint8_t note = (starting_note + SCALE[record->event.key.col + offset])+12*(MATRIX_ROWS - record->event.key.row);
-      // advanced
-      // uint8_t note = (starting_note + record->event.key.col + offset)+12*(MATRIX_ROWS - record->event.key.row);
-      // guitar
-      uint8_t note = (starting_note + record->event.key.col + offset)+5*(MATRIX_ROWS - record->event.key.row);
-      // violin
-      // uint8_t note = (starting_note + record->event.key.col + offset)+7*(MATRIX_ROWS - record->event.key.row);
-
-      if (record->event.pressed) {
-        // midi_send_noteon(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
-        midi_send_noteon(&midi_device, 0, note, 127);
-      } else {
-        // midi_send_noteoff(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
-        midi_send_noteoff(&midi_device, 0, note, 127);
-      }
-
-      if (keycode < 0xFF) // ignores all normal keycodes, but lets RAISE, LOWER, etc through
-        return false;
-    }
   #endif
-
   #ifdef AUDIO_ENABLE
-    if (keycode == AU_ON && record->event.pressed) {
+    process_music(keycode, record) &&
-      audio_on();
-      return false;
-    }
-
-    if (keycode == AU_OFF && record->event.pressed) {
-      audio_off();
-      return false;
-    }
-
-    if (keycode == AU_TOG && record->event.pressed) {
-        if (is_audio_on())
-        {
-            audio_off();
-        }
-        else
-        {
-            audio_on();
-        }
-      return false;
-    }
-
-    if (keycode == MU_ON && record->event.pressed) {
-        music_on();
-        return false;
-    }
-
-    if (keycode == MU_OFF && record->event.pressed) {
-        music_off();
-        return false;
-    }
-
-    if (keycode == MU_TOG && record->event.pressed) {
-        if (music_activated)
-        {
-            music_off();
-        }
-        else
-        {
-            music_on();
-        }
-        return false;
-    }
-
-    if (keycode == MUV_IN && record->event.pressed) {
-        voice_iterate();
-        music_scale_user();
-        return false;
-    }
-
-    if (keycode == MUV_DE && record->event.pressed) {
-        voice_deiterate();
-        music_scale_user();
-        return false;
-    }
-
-    if (music_activated) {
-
-      if (keycode == KC_LCTL && record->event.pressed) { // Start recording
-        stop_all_notes();
-        music_sequence_recording = true;
-        music_sequence_playing = false;
-        music_sequence_count = 0;
-        return false;
-      }
-
-      if (keycode == KC_LALT && record->event.pressed) { // Stop recording/playing
-        stop_all_notes();
-        music_sequence_recording = false;
-        music_sequence_playing = false;
-        return false;
-      }
-
-      if (keycode == KC_LGUI && record->event.pressed) { // Start playing
-        stop_all_notes();
-        music_sequence_recording = false;
-        music_sequence_playing = true;
-        music_sequence_position = 0;
-        music_sequence_timer = 0;
-        return false;
-      }
-
-      if (keycode == KC_UP) {
-        if (record->event.pressed)
-            music_sequence_interval-=10;
-        return false;
-      }
-
-      if (keycode == KC_DOWN) {
-        if (record->event.pressed)
-            music_sequence_interval+=10;
-        return false;
-      }
-
-      float freq = ((float)220.0)*pow(2.0, -5.0)*pow(2.0,(starting_note + SCALE[record->event.key.col + offset])/12.0+(MATRIX_ROWS - record->event.key.row));
-      if (record->event.pressed) {
-        play_note(freq, 0xF);
-        if (music_sequence_recording) {
-          music_sequence[music_sequence_count] = freq;
-          music_sequence_count++;
-        }
-      } else {
-        stop_note(freq);
-      }
-
-      if (keycode < 0xFF) // ignores all normal keycodes, but lets RAISE, LOWER, etc through
-        return false;
-    }
   #endif
-
+  #ifdef TAP_DANCE_ENABLE
-#ifndef DISABLE_LEADER
+    process_tap_dance(keycode, record) &&
-  // Leader key set-up
+  #endif
-  if (record->event.pressed) {
+  #ifndef DISABLE_LEADER
-    if (!leading && keycode == KC_LEAD) {
+    process_leader(keycode, record) &&
-      leader_start();
+  #endif
-      leading = true;
+  #ifndef DISABLE_CHORDING
-      leader_time = timer_read();
+    process_chording(keycode, record) &&
-      leader_sequence_size = 0;
+  #endif
-      leader_sequence[0] = 0;
+  #ifdef UNICODE_ENABLE
-      leader_sequence[1] = 0;
+    process_unicode(keycode, record) &&
-      leader_sequence[2] = 0;
+  #endif
-      leader_sequence[3] = 0;
+      true)) {
-      leader_sequence[4] = 0;
+    return false;
-      return false;
-    }
-    if (leading && timer_elapsed(leader_time) < LEADER_TIMEOUT) {
-      leader_sequence[leader_sequence_size] = keycode;
-      leader_sequence_size++;
-      return false;
-    }
-  }
-#endif
-
-#define DISABLE_CHORDING
-#ifndef DISABLE_CHORDING
-
-  if (keycode >= QK_CHORDING && keycode <= QK_CHORDING_MAX) {
-    if (record->event.pressed) {
-      if (!chording) {
-        chording = true;
-        for (uint8_t i = 0; i < CHORDING_MAX; i++)
-          chord_keys[i] = 0;
-        chord_key_count = 0;
-        chord_key_down = 0;
-      }
-      chord_keys[chord_key_count] = (keycode & 0xFF);
-      chord_key_count++;
-      chord_key_down++;
-      return false;
-    } else {
-      if (chording) {
-        chord_key_down--;
-        if (chord_key_down == 0) {
-          chording = false;
-          // Chord Dictionary
-          if (keys_chord((uint8_t[]){KC_ENTER, KC_SPACE})) {
-            register_code(KC_A);
-            unregister_code(KC_A);
-            return false;
-          }
-          for (uint8_t i = 0; i < chord_key_count; i++) {
-            register_code(chord_keys[i]);
-            unregister_code(chord_keys[i]);
-            return false;
-          }
-        }
-      }
-    }
-  }
-
-#endif
-
-#ifdef UNICODE_ENABLE
-
-  if (keycode > QK_UNICODE && record->event.pressed) {
-    uint16_t unicode = keycode & 0x7FFF;
-    switch(input_mode) {
-      case UC_OSX:
-        register_code(KC_LALT);
-        break;
-      case UC_LNX:
-        register_code(KC_LCTL);
-        register_code(KC_LSFT);
-        register_code(KC_U);
-        unregister_code(KC_U);
-        break;
-      case UC_WIN:
-        register_code(KC_LALT);
-        register_code(KC_PPLS);
-        unregister_code(KC_PPLS);
-        break;
-    }
-    for(int i = 3; i >= 0; i--) {
-        uint8_t digit = ((unicode >> (i*4)) & 0xF);
-        register_code(hex_to_keycode(digit));
-        unregister_code(hex_to_keycode(digit));
-    }
-    switch(input_mode) {
-      case UC_OSX:
-      case UC_WIN:
-        unregister_code(KC_LALT);
-        break;
-      case UC_LNX:
-        unregister_code(KC_LCTL);
-        unregister_code(KC_LSFT);
-        break;
-    }
   }
 
-#endif
-
   // Shift / paren setup
 
   switch(keycode) {
@@ -648,6 +307,44 @@ void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
   }
 }
 
+void tap_random_base64(void) {
+  #if defined(__AVR_ATmega32U4__)
+    uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
+  #else
+    uint8_t key = rand() % 64;
+  #endif
+  switch (key) {
+    case 0 ... 25:
+      register_code(KC_LSFT);
+      register_code(key + KC_A);
+      unregister_code(key + KC_A);
+      unregister_code(KC_LSFT);
+      break;
+    case 26 ... 51:
+      register_code(key - 26 + KC_A);
+      unregister_code(key - 26 + KC_A);
+      break;
+    case 52:
+      register_code(KC_0);
+      unregister_code(KC_0);
+      break;
+    case 53 ... 61:
+      register_code(key - 53 + KC_1);
+      unregister_code(key - 53 + KC_1);
+      break;
+    case 62:
+      register_code(KC_LSFT);
+      register_code(KC_EQL);
+      unregister_code(KC_EQL);
+      unregister_code(KC_LSFT);
+      break;
+    case 63:
+      register_code(KC_SLSH);
+      unregister_code(KC_SLSH);
+      break;
+  }
+}
+
 void matrix_init_quantum() {
   #ifdef BACKLIGHT_ENABLE
     backlight_init_ports();
@@ -657,46 +354,15 @@ void matrix_init_quantum() {
 
 void matrix_scan_quantum() {
   #ifdef AUDIO_ENABLE
-  if (music_sequence_playing) {
+    matrix_scan_music();
-    if ((music_sequence_timer == 0) || (timer_elapsed(music_sequence_timer) > music_sequence_interval)) {
-      music_sequence_timer = timer_read();
-      stop_note(music_sequence[(music_sequence_position - 1 < 0)?(music_sequence_position - 1 + music_sequence_count):(music_sequence_position - 1)]);
-      play_note(music_sequence[music_sequence_position], 0xF);
-      music_sequence_position = (music_sequence_position + 1) % music_sequence_count;
-    }
-  }
-
   #endif
 
+  #ifdef TAP_DANCE_ENABLE
+    matrix_scan_tap_dance();
+  #endif
   matrix_scan_kb();
 }
 
-#ifdef AUDIO_ENABLE
-  bool is_music_on(void) {
-      return (music_activated != 0);
-  }
-
-  void music_toggle(void) {
-      if (!music_activated) {
-          music_on();
-      } else {
-          music_off();
-      }
-  }
-
-  void music_on(void) {
-      music_activated = 1;
-      music_on_user();
-  }
-
-  void music_off(void) {
-      music_activated = 0;
-      stop_all_notes();
-  }
-
-#endif
-
-
 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
 
 static const uint8_t backlight_pin = BACKLIGHT_PIN;
@@ -1048,13 +714,4 @@ void startup_user() {}
 __attribute__ ((weak))
 void shutdown_user() {}
 
-__attribute__ ((weak))
-void music_on_user() {}
-
-__attribute__ ((weak))
-void audio_on_user() {}
-
-__attribute__ ((weak))
-void music_scale_user() {}
-
 //------------------------------------------------------------------------------

quantum/quantum.h

@@ -10,15 +10,6 @@
 #ifdef RGBLIGHT_ENABLE
   #include "rgblight.h"
 #endif
-#ifdef AUDIO_ENABLE
-  #include "audio.h"
-#endif
-#ifdef MIDI_ENABLE
-	#include <lufa.h>
-#endif
-#ifdef UNICODE_ENABLE
-	#include "unicode.h"
-#endif
 
 #include "action_layer.h"
 #include "eeconfig.h"
@@ -31,6 +22,8 @@
 #include <avr/interrupt.h>
 #include "led.h"
 #include "action_util.h"
+#include <stdlib.h>
+
 
 extern uint32_t default_layer_state;
 
@@ -38,41 +31,39 @@ extern uint32_t default_layer_state;
 	extern uint32_t layer_state;
 #endif
 
+#ifdef MIDI_ENABLE
+	#include <lufa.h>
+	#include "process_midi.h"
+#endif
+
 #ifdef AUDIO_ENABLE
-	bool music_activated;
+ 	#include "audio.h"
+	#include "process_music.h"
 #endif
 
-#ifdef UNICODE_ENABLE
+#ifndef DISABLE_LEADER
-	#define UC_OSX 0
+	#include "process_leader.h"
-	#define UC_LNX 1
+#endif
-	#define UC_WIN 2
-	#define UC_BSD 3
 
-	void set_unicode_input_mode(uint8_t os_target);
+#define DISABLE_CHORDING
+#ifndef DISABLE_CHORDING
+	#include "process_chording.h"
 #endif
 
-#ifndef DISABLE_LEADER
+#ifdef UNICODE_ENABLE
-	void leader_start(void);
+	#include "process_unicode.h"
-	void leader_end(void);
-
-	#ifndef LEADER_TIMEOUT
-		#define LEADER_TIMEOUT 200
-	#endif
-	#define SEQ_ONE_KEY(key) if (leader_sequence[0] == (key) && leader_sequence[1] == 0 && leader_sequence[2] == 0 && leader_sequence[3] == 0 && leader_sequence[4] == 0)
-	#define SEQ_TWO_KEYS(key1, key2) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == 0 && leader_sequence[3] == 0 && leader_sequence[4] == 0)
-	#define SEQ_THREE_KEYS(key1, key2, key3) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == (key3) && leader_sequence[3] == 0 && leader_sequence[4] == 0)
-	#define SEQ_FOUR_KEYS(key1, key2, key3, key4) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == (key3) && leader_sequence[3] == (key4) && leader_sequence[4] == 0)
-	#define SEQ_FIVE_KEYS(key1, key2, key3, key4, key5) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == (key3) && leader_sequence[3] == (key4) && leader_sequence[4] == (key5))
-
-	#define LEADER_EXTERNS() extern bool leading; extern uint16_t leader_time; extern uint16_t leader_sequence[5]; extern uint8_t leader_sequence_size
-	#define LEADER_DICTIONARY() if (leading && timer_elapsed(leader_time) > LEADER_TIMEOUT)
 #endif
 
+#include "process_tap_dance.h"
+
 #define SEND_STRING(str) send_string(PSTR(str))
 void send_string(const char *str);
 
 // For tri-layer
 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3);
+
+void tap_random_base64(void);
+
 #define IS_LAYER_ON(layer)  (layer_state & (1UL << (layer)))
 #define IS_LAYER_OFF(layer) (~layer_state & (1UL << (layer)))
 
@@ -84,16 +75,8 @@ bool process_action_kb(keyrecord_t *record);
 bool process_record_kb(uint16_t keycode, keyrecord_t *record);
 bool process_record_user(uint16_t keycode, keyrecord_t *record);
 
-bool is_music_on(void);
-void music_toggle(void);
-void music_on(void);
-void music_off(void);
-
 void startup_user(void);
 void shutdown_user(void);
-void audio_on_user(void);
-void music_on_user(void);
-void music_scale_user(void);
 
 #ifdef BACKLIGHT_ENABLE
 void backlight_init_ports(void);

readme.md

@@ -14,8 +14,7 @@ For an easy-to-read version of this document and the repository, check out [http
 * [Preonic](/keyboards/preonic/)
 * [Atomic](/keyboards/atomic/)
 * [ErgoDox EZ](/keyboards/ergodox_ez/)
-* [Clueboard rev.1](/keyboards/clueboard1/)
+* [Clueboard](/keyboards/clueboard/)
-* [Clueboard rev.2](/keyboards/clueboard2/)
 * [Cluepad](/keyboards/cluepad/)
 
 The project also includes community support for [lots of other keyboards](/keyboards/).

tmk_core/common.mk

@@ -17,10 +17,11 @@ SRC +=	$(COMMON_DIR)/host.c \
 
 # Option modules
 ifeq ($(strip $(BOOTMAGIC_ENABLE)), yes)
+    OPT_DEFS += -DBOOTMAGIC_ENABLE
     SRC += $(COMMON_DIR)/bootmagic.c
     SRC += $(COMMON_DIR)/avr/eeconfig.c
-    OPT_DEFS += -DBOOTMAGIC_ENABLE
 else
+    OPT_DEFS += -DMAGIC_ENABLE
     SRC += $(COMMON_DIR)/magic.c
     SRC += $(COMMON_DIR)/avr/eeconfig.c
 endif
@@ -51,18 +52,6 @@ ifeq ($(strip $(NKRO_ENABLE)), yes)
     OPT_DEFS += -DNKRO_ENABLE
 endif
 
-ifeq ($(strip $(MIDI_ENABLE)), yes)
-    OPT_DEFS += -DMIDI_ENABLE
-endif
-
-ifeq ($(strip $(AUDIO_ENABLE)), yes)
-    OPT_DEFS += -DAUDIO_ENABLE
-endif
-
-ifeq ($(strip $(UNICODE_ENABLE)), yes)
-    OPT_DEFS += -DUNICODE_ENABLE
-endif
-
 ifeq ($(strip $(USB_6KRO_ENABLE)), yes)
     OPT_DEFS += -DUSB_6KRO_ENABLE
 endif

tmk_core/rules.mk

@@ -51,6 +51,13 @@ ifeq ($(COLOR),true)
 	BOLD=\033[1m
 endif
 
+ifdef quick
+	QUICK = $(quick)
+endif
+
+QUICK ?= false
+AUTOGEN ?= false
+
 ifneq ($(shell awk --version 2>/dev/null),)
 	AWK=awk
 else
@@ -68,10 +75,10 @@ endif
 TAB_LOG = printf "\n$$LOG\n\n" | $(AWK) '{ sub(/^/," | "); print }'
 TAB_LOG_PLAIN = printf "$$LOG\n"
 AWK_STATUS = $(AWK) '{ printf " %-10s\n", $$1; }'
-AWK_CMD = $(AWK) '{ printf "%-69s", $$0; }'
+AWK_CMD = $(AWK) '{ printf "%-99s", $$0; }'
 PRINT_ERROR = ($(SILENT) ||printf " $(ERROR_STRING)" | $(AWK_STATUS)) && $(TAB_LOG) && false
 PRINT_WARNING = ($(SILENT) || printf " $(WARN_STRING)" | $(AWK_STATUS)) && $(TAB_LOG)
-PRINT_ERROR_PLAIN = ($(SILENT) ||printf " $(ERROR_STRING)" | $(AWK_STATUS)) && $(TAB_LOG_PLAIN) && false
+PRINT_ERROR_PLAIN = ($(SILENT) ||printf " $(ERROR_STRING)" | $(AWK_STATUS)) && $(TAB_LOG_PLAIN) && false && break
 PRINT_WARNING_PLAIN = ($(SILENT) || printf " $(WARN_STRING)" | $(AWK_STATUS)) && $(TAB_LOG_PLAIN)
 PRINT_OK = $(SILENT) || printf " $(OK_STRING)" | $(AWK_STATUS)
 BUILD_CMD = LOG=$$($(CMD) 2>&1) ; if [ $$? -gt 0 ]; then $(PRINT_ERROR); elif [ "$$LOG" != "" ] ; then $(PRINT_WARNING); else $(PRINT_OK); fi;
@@ -524,7 +531,12 @@ extcoff: $(BUILD_DIR)/$(TARGET).elf
 	@$(SILENT) || printf "$(MSG_FLASH) $@" | $(AWK_CMD)
 	$(eval CMD=$(OBJCOPY) -O $(FORMAT) -R .eeprom -R .fuse -R .lock -R .signature $< $@)
 	@$(BUILD_CMD)
-	@$(COPY) $@ $(TARGET).hex
+	@if $(AUTOGEN); then \
+		$(SILENT) || printf "Copying $(TARGET).hex to keymaps/$(KEYMAP)/$(KEYBOARD)_$(KEYMAP).hex\n"; \
+		$(COPY) $@ $(KEYMAP_PATH)/$(KEYBOARD)_$(KEYMAP).hex; \
+	else \
+		$(COPY) $@ $(TARGET).hex; \
+	fi
 
 %.eep: %.elf
 	@$(SILENT) || printf "$(MSG_EEPROM) $@" | $(AWK_CMD)
@@ -570,7 +582,7 @@ $(OBJDIR)/%.o : %.c
 $(OBJDIR)/%.o : %.cpp
 	@mkdir -p $(@D)
 	@$(SILENT) || printf "$(MSG_COMPILING_CPP) $<" | $(AWK_CMD)
-	$(CC) -c $(ALL_CPPFLAGS) $< -o $@
+	$(eval CMD=$(CC) -c $(ALL_CPPFLAGS) $< -o $@)
 	@$(BUILD_CMD)
 
 # Compile: create assembler files from C source files.
@@ -600,15 +612,20 @@ $(OBJDIR)/%.o : %.S
 clean: begin clean_list end
 
 clean_list :
-	$(REMOVE) -r $(TOP_DIR)/$(BUILD_DIR)
+	@$(REMOVE) -r $(BUILD_DIR)
-	$(REMOVE) -r $(KEYBOARD_PATH)/$(BUILD_DIR)
+	@$(REMOVE) -r $(TOP_DIR)/$(BUILD_DIR)
-	$(REMOVE) -r $(KEYMAP_PATH)/$(BUILD_DIR)
+	@$(REMOVE) -r $(KEYBOARD_PATH)/$(BUILD_DIR)
+	@if $$SUBPROJECT; then $(REMOVE) -r $(SUBPROJECT_PATH)/$(BUILD_DIR); fi
+	@$(REMOVE) -r $(KEYMAP_PATH)/$(BUILD_DIR)
 
 show_path:
 	@echo VPATH=$(VPATH)
 	@echo SRC=$(SRC)
 
-SUBDIRS := $(sort $(dir $(wildcard $(TOP_DIR)/keyboards/*/.)))
+SUBDIRS := $(filter-out %/util/ %/doc/ %/keymaps/ %/old_keymap_files/,$(dir $(wildcard $(TOP_DIR)/keyboards/**/*/.)))
+SUBDIRS := $(SUBDIRS) $(dir $(wildcard $(TOP_DIR)/keyboards/*/.))
+SUBDIRS := $(sort $(SUBDIRS))
+# $(error $(SUBDIRS))
 all-keyboards-defaults-%:
 	@for x in $(SUBDIRS) ; do \
 		printf "Compiling with default: $$x" | $(AWK_CMD); \
@@ -625,9 +642,12 @@ all-keyboards: all-keyboards-all
 
 define make_keyboard
 $(eval KEYBOARD=$(patsubst /keyboards/%,%,$1))
-$(eval KEYMAPS=$(notdir $(patsubst %/.,%,$(wildcard $(TOP_DIR)$1/keymaps/*/.))))
+$(eval SUBPROJECT=$(lastword $(subst /, ,$(KEYBOARD))))
+$(eval KEYBOARD=$(firstword $(subst /, ,$(KEYBOARD))))
+$(eval KEYMAPS=$(notdir $(patsubst %/.,%,$(wildcard $(TOP_DIR)/keyboards/$(KEYBOARD)/keymaps/*/.))))
+$(eval KEYMAPS+=$(notdir $(patsubst %/.,%,$(wildcard $(TOP_DIR)/keyboards/$(KEYBOARD)/$(SUBPROJECT)/keymaps/*/.))))
 @for x in $(KEYMAPS) ; do \
-	printf "Compiling $(BOLD)$(KEYBOARD)$(NO_COLOR) with $(BOLD)$$x$(NO_COLOR)" | $(AWK) '{ printf "%-88s", $$0; }'; \
+	printf "Compiling $(BOLD)$(KEYBOARD)/$(SUBPROJECT)$(NO_COLOR) with $(BOLD)$$x$(NO_COLOR)" | $(AWK) '{ printf "%-118s", $$0; }'; \
 	LOG=$$($(MAKE) -C $(TOP_DIR)$1 $2 keymap=$$x VERBOSE=$(VERBOSE) COLOR=$(COLOR) SILENT=true 2>&1) ; if [ $$? -gt 0 ]; then $(PRINT_ERROR_PLAIN); elif [ "$$LOG" != "" ] ; then $(PRINT_WARNING_PLAIN); else $(PRINT_OK); fi; \
 done
 endef
@@ -650,7 +670,7 @@ all-keymaps-%:
 	$(eval MAKECONFIG=$(call get_target,all-keymaps,$@))
 	$(eval KEYMAPS=$(notdir $(patsubst %/.,%,$(wildcard $(TOP_DIR)/keyboards/$(KEYBOARD)/keymaps/*/.))))
 	@for x in $(KEYMAPS) ; do \
-		printf "Compiling $(BOLD)$(KEYBOARD)$(NO_COLOR) with $(BOLD)$$x$(NO_COLOR)" | $(AWK) '{ printf "%-88s", $$0; }'; \
+		printf "Compiling $(BOLD)$(KEYBOARD)$(NO_COLOR) with $(BOLD)$$x$(NO_COLOR)" | $(AWK) '{ printf "%-118s", $$0; }'; \
 		LOG=$$($(MAKE) $(subst all-keymaps-,,$@) keyboard=$(KEYBOARD) keymap=$$x VERBOSE=$(VERBOSE) COLOR=$(COLOR) SILENT=true 2>&1) ; if [ $$? -gt 0 ]; then $(PRINT_ERROR_PLAIN); elif [ "$$LOG" != "" ] ; then $(PRINT_WARNING_PLAIN); else $(PRINT_OK); fi; \
 	done
 

util/travis_compiled_push.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+set -o errexit -o nounset
+
+rev=$(git rev-parse --short HEAD)
+
+git config --global user.name "Travis CI"
+git config --global user.email "jack.humb+travis.ci@gmail.com"
+
+find . -name ".build" | xargs rm -rf
+cd ..
+git clone https://$GH_TOKEN@github.com/jackhumbert/qmk.fm.git
+cd qmk.fm
+git submodule update --init --recursive
+rm -rf keyboard
+rm -rf keyboards
+cp -r ../qmk_firmware/keyboards .
+cp ../qmk_firmware/readme.md qmk_readme.md
+./generate.sh
+
+git add -A
+git commit -m "generated from qmk_firmware/$TRAVIS_BRANCH@${rev}" 
+git push