adds documentation for console in

* zweihander-osx: Remove app keys, etc.

- add right command keys
- add F16 on ;' for Siri
- remove command-Q (too easy to hit)

* Zweihander: update readme

docs/custom_quantum_functions.md

@@ -36,7 +36,7 @@ enum my_keycodes {
 
 ## Programming the Behavior of Any Keycode
 
-When you want to override the behavior of an existing key, or define the behavior for a new key, you should use the `process_record_kb()` and `process_record_user()` functions. These are called by QMK during key processing before the actual key event is handled. If these functions return `true` QMK will process the keycodes as usual. That can be handy for extending the functionality of a key rather than replacing it. If these functions return `false` QMK will skip the normal key handling, and it will be up you to send any key up or down events that are required.
+When you want to override the behavior of an existing key, or define the behavior for a new key, you should use the `process_record_kb()` and `process_record_user()` functions. These are called by QMK during key processing before the actual key event is handled. If these functions return `true` QMK will process the keycodes as usual. That can be handy for extending the functionality of a key rather than replacing it. If these functions return `false` QMK will skip the normal key handling, and it will be up to you to send any key up or down events that are required.
 
 These function are called every time a key is pressed or released.
 

docs/feature_auto_shift.md

@@ -110,6 +110,9 @@ Map three keys temporarily in your keymap:
 | KC_ASDN  | Lower the Auto Shift timeout variable (down)        |
 | KC_ASUP  | Raise the Auto Shift timeout variable (up)          |
 | KC_ASRP  | Report your current Auto Shift timeout value        |
+| KC_ASON  | Turns on the Auto Shift Function                    |
+| KC_ASOFF | Turns off the Auto Shift Function                   |
+| KC_ASTG  | Toggles the statn of the Auto Shift feature         |
 
 Compile and upload your new firmware.
 

docs/feature_console_in.md

@@ -0,0 +1,26 @@
+# Console In
+
+The "Console" in QMK refers to PJRC's vendor page of `0xFF31` and usage page of `0x74` - this is mainly used for sending debug statements to the computer that can be read via the QMK Toolbox (recommended), or HID listen.
+
+When `#define CONSOLE_IN_ENABLE` is placed in the `config.h` file, the keyboard will also listen to messages sent to the keyboard, will be able to respond in a custom way, defined at the `quantum`, `kb`, or `user` level. A keymap's example might look like this:
+
+```c
+void process_console_data_user(uint8_t * data, uint8_t length) {
+  switch (data[0]) {
+    case 0x05:
+      print("Sending back a message to the computer\n");
+      break;
+  }
+}
+```
+
+Which will execute when a report is sent to the keyboard when the first byte is `0x05`.
+
+## Default actions (defined at the `quantum` level)
+
+When the first byte is:
+
+* `0x01`: Print "Saying hello\n" via the console, and play the audio on song
+* `0xFE`: Enter the bootloader - only works when `CONSOLE_IN_BOOTLOADER` is defined in the `config.h`
+
+This needs to be fleshed out a bit more with some sort of versioning.

keyboards/jj40/jj40.h

@@ -18,6 +18,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef KEYMAP_COMMON_H
 #define KEYMAP_COMMON_H
 
+#include "quantum.h"
 #include "quantum_keycodes.h"
 #include "keycode.h"
 #include "action.h"

keyboards/jj40/keymaps/oscillope/keymap.c

@@ -26,6 +26,10 @@ enum custom_keycodes {
   QWERTY = SAFE_RANGE,
   LOWER,
   RAISE,
+  CC_ARRW,
+  CC_PRN,
+  CC_BRC,
+  CC_CBR,
 };
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
@@ -51,7 +55,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * ,-----------------------------------------------------------------------------------.
  * |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |  F7  |  F8  |  F9  | F10  | F11  | F12  |
  * |------+------+------+------+------+-------------+------+------+------+------+------|
- * | Ins  |      |      |      |      |      | Left | Down |  Up  |Right |      |      |
+ * | Ins  |      |      |  ()  |  []  |  {}  | Left | Down |  Up  |Right |      |      |
  * |------+------+------+------+------+------|------+------+------+------+------+------|
  * |PrScr | Back | Fwd  |      |      |      |      |      | Mute | Vol- | Vol+ |      |
  * |------+------+------+------+------+------+------+------+------+------+------+------|
@@ -60,7 +64,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  */
 [_LOWER] = 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_INS,  _______, _______, _______, _______, _______, KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT, _______, _______, \
+  KC_INS,  _______, _______, CC_PRN,  CC_BRC,  CC_CBR,  KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT, _______, _______, \
   KC_PSCR, KC_WBAK, KC_WFWD, _______, _______, _______, _______, _______, KC_MUTE, KC_VOLD, KC_VOLU, _______, \
   _______, _______, _______, _______, KC_LOCK, _______, _______, KC_MPRV, KC_MSTP, KC_MPLY, KC_MNXT \
 ),
@@ -71,7 +75,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |------+------+------+------+------+-------------+------+------+------+------+------|
  * | Tab  |   $  |   %  |   ^  |   [  |   ]  |   4  |   5  |   6  |   -  |   +  |Enter |
  * |------+------+------+------+------+------|------+------+------+------+------+------|
- * |   `  |   !  |   @  |   #  |   {  |   }  |   1  |   2  |   3  |   .  |   \  |  |   |
+ * |  ->  |   !  |   @  |   #  |   {  |   }  |   1  |   2  |   3  |   .  |   \  |  |   |
  * |------+------+------+------+------+------+------+------+------+------+------+------|
  * | Ctrl |  OS  | Alt  |      |Shift |      |      0      | Home | PgDn | PgUp | End  |
  * `-----------------------------------------------------------------------------------'
@@ -79,7 +83,27 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 [_RAISE] = KEYMAP( \
   KC_CAPS, KC_AMPR, KC_ASTR, KC_UNDS, KC_LPRN, KC_RPRN, KC_7,    KC_8,    KC_9,    KC_EQL,  KC_BSPC, KC_DEL, \
   KC_TAB,  KC_DLR,  KC_PERC, KC_CIRC, KC_LBRC, KC_RBRC, KC_4,    KC_5,    KC_6,    KC_MINS, KC_PLUS, _______, \
-  _______, KC_EXLM, KC_AT,   KC_HASH, KC_LCBR, KC_RCBR, KC_1,    KC_2,    KC_3,    _______, KC_BSLS, KC_PIPE, \
+  CC_ARRW, KC_EXLM, KC_AT,   KC_HASH, KC_LCBR, KC_RCBR, KC_1,    KC_2,    KC_3,    _______, KC_BSLS, KC_PIPE, \
   _______, _______, _______, _______, _______, _______, KC_0,    KC_HOME, KC_PGDN, KC_PGUP, KC_END \
 )
 };
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  if (record->event.pressed) {
+    switch(keycode) {
+      case CC_ARRW:
+        SEND_STRING("->");
+        return false;
+      case CC_PRN:
+        SEND_STRING("()"SS_TAP(X_LEFT));
+        return false;
+      case CC_BRC:
+        SEND_STRING("[]"SS_TAP(X_LEFT));
+        return false;
+      case CC_CBR:
+        SEND_STRING("{}"SS_TAP(X_LEFT));
+        return false;
+    }
+  }
+  return true;
+}

keyboards/k_type/keymaps/belak/keymap.c

@@ -0,0 +1,37 @@
+#include "k_type.h"
+
+#define _______ KC_TRNS
+
+#define _QW 0
+#define _L1 1
+
+const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    [_QW] = KEYMAP(
+      KC_ESC,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,           KC_PSCR, KC_SLCK, KC_PAUS, \
+      KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, KC_INS,  KC_HOME, 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_DEL,  KC_END,  KC_PGDN, \
+      MO(_L1), KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_ENT, \
+      KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,                            KC_UP, \
+      KC_LCTL, KC_LGUI, KC_LALT,          KC_SPC,                    KC_RALT, KC_RGUI, MO(_L1), KC_RCTL,                            KC_LEFT, KC_DOWN, KC_RGHT),
+    [_L1] = KEYMAP(
+      _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,          _______, _______, _______, \
+      _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_MPLY, KC_MNXT, KC_VOLU, \
+      _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_MSTP, KC_MPRV, KC_VOLD, \
+      _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+      _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,                            KC_PGUP, \
+      _______, _______, _______,          _______,                   _______, _______, _______, _______,                            KC_HOME, KC_PGDN, KC_END),
+};
+
+const uint16_t fn_actions[] = {
+
+};
+
+// Runs just one time when the keyboard initializes.
+void matrix_init_user(void) {
+
+};
+
+// Runs constantly in the background, in a loop.
+void matrix_scan_user(void) {
+
+};

keyboards/lets_split/keymaps/poker/config.h

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

keyboards/lets_split/keymaps/poker/keymap.c

@@ -0,0 +1,241 @@
+#include "lets_split.h"
+#include "action_layer.h"
+#include "eeconfig.h"
+
+extern keymap_config_t keymap_config;
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+#define _QWERTY 0
+#define _COLEMAK 1
+#define _DVORAK 2
+#define _LOWER 3
+#define _RAISE 4
+#define _FN 5
+#define _ADJUST 16
+
+enum custom_keycodes {
+  QWERTY = SAFE_RANGE,
+  COLEMAK,
+  DVORAK,
+  LOWER,
+  RAISE,
+  FN,
+  ADJUST
+};
+
+// Fillers to make layering more clear
+#define _______ KC_TRNS
+#define XXXXXXX KC_NO
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+/* Qwerty
+ * ,-----------------------------------------------------------------------------------.
+ * | Tab  |   Q  |   W  |   E  |   R  |   T  |   Y  |   U  |   I  |   O  |   P  | Bksp |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Func |   A  |   S  |   D  |   F  |   G  |   H  |   J  |   K  |   L  |   ;  |  "   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * | Shift|   Z  |   X  |   C  |   V  |   B  |   N  |   M  |   ,  |   .  |   /  |Enter |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * | Ctrl | GUI  | Esc  | Alt  |Lower |  Esc |Space |Raise | Left | Up   | Down |Right |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_QWERTY] = KEYMAP( \
+  KC_TAB         , KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_BSPC, \
+  FN             , KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, \
+  SFT_T(KC_ESC)  , KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, MT(MOD_RSFT, KC_ENT), \
+  KC_LCTL        , KC_LGUI, KC_ESC,  KC_LALT, LOWER,   KC_ESC,  KC_SPC,  RAISE,   KC_LEFT, KC_UP,   KC_DOWN, KC_RGHT \
+),
+
+/* Colemak
+ * ,-----------------------------------------------------------------------------------.
+ * | Tab  |   Q  |   W  |   F  |   P  |   G  |   J  |   L  |   U  |   Y  |   ;  | Bksp |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Func |   A  |   R  |   S  |   T  |   D  |   H  |   N  |   E  |   I  |   O  |  "   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * | Shift|   Z  |   X  |   C  |   V  |   B  |   K  |   M  |   ,  |   .  |   /  |Enter |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * | Ctrl | GUI  | Esc  | Alt  |Lower |  Esc |Space |Raise | Left | Down |  Up  |Right |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_COLEMAK] = KEYMAP( \
+  KC_TAB         , KC_Q,    KC_W,    KC_F,    KC_P,    KC_G,    KC_J,    KC_L,    KC_U,    KC_Y,    KC_SCLN, KC_BSPC, \
+  FN             , KC_A,    KC_R,    KC_S,    KC_T,    KC_D,    KC_H,    KC_N,    KC_E,    KC_I,    KC_O,    KC_QUOT, \
+  SFT_T(KC_ESC)  , KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_K,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, MT(MOD_RSFT, KC_ENT), \
+  KC_LCTL        , KC_LGUI, KC_ESC,  KC_LALT, LOWER,   KC_ESC,  KC_SPC,  RAISE,   KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT \
+),
+
+/* Dvorak
+ * ,-----------------------------------------------------------------------------------.
+ * | Tab  |   "  |   ,  |   .  |   P  |   Y  |   F  |   G  |   C  |   R  |   L  | Bksp |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Func |   A  |   O  |   E  |   U  |   I  |   D  |   H  |   T  |   N  |   S  |  /   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * | Shift|   ;  |   Q  |   J  |   K  |   X  |   B  |   M  |   W  |   V  |   Z  |Enter |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * | Ctrl | GUI  | Esc  | Alt  |Lower |  Esc |Space |Raise | Left | Down |  Up  |Right |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_DVORAK] = KEYMAP( \
+  KC_TAB         , KC_QUOT, KC_COMM, KC_DOT,  KC_P,    KC_Y,    KC_F,    KC_G,    KC_C,    KC_R,    KC_L,    KC_BSPC, \
+  FN             , KC_A,    KC_O,    KC_E,    KC_U,    KC_I,    KC_D,    KC_H,    KC_T,    KC_N,    KC_S,    KC_SLSH, \
+  SFT_T(KC_ESC)  , KC_SCLN, KC_Q,    KC_J,    KC_K,    KC_X,    KC_B,    KC_M,    KC_W,    KC_V,    KC_Z,    MT(MOD_RSFT, KC_ENT), \
+  KC_LCTL        , KC_LGUI, KC_ESC,  KC_LALT, LOWER,   KC_ESC,  KC_SPC,  RAISE,   KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT \
+),
+
+/* Lower
+ * ,-----------------------------------------------------------------------------------.
+ * |   ~  |   !  |   @  |   #  |   $  |   %  |   ^  |   &  |   *  |   (  |   )  | Del  |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |      |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |   _  |   +  |   {  |   }  |  |   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |      |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 |ISO ~ |ISO | | Home | End  |      |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      |      |      |      |      |      |      |      | Home |Pg Up |Pg Dn | End  |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_LOWER] = KEYMAP( \
+  KC_TILD, KC_EXLM, KC_AT,   KC_HASH, KC_DLR,  KC_PERC, KC_CIRC, KC_AMPR,    KC_ASTR,    KC_LPRN, KC_RPRN, KC_DEL , \
+  _______, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_UNDS,    KC_PLUS,    KC_LCBR, KC_RCBR, KC_PIPE, \
+  _______, KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  S(KC_NUHS), S(KC_NUBS), KC_HOME, KC_END,  _______, \
+  _______, _______, _______, _______, _______, _______, _______, _______,    KC_HOME,    KC_PGUP, KC_PGDN, KC_END \
+),
+
+/* Raise
+ * ,-----------------------------------------------------------------------------------.
+ * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Del  |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |      |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |   -  |   =  |   [  |   ]  |  \   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |      |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 |ISO # |ISO / |Pg Up |Pg Dn |      |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      |      |      |      |      |      |      |      | Home |Pg Up |Pg Dn | End  |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_RAISE] = KEYMAP( \
+  KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_DEL , \
+  _______, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_MINS, KC_EQL,  KC_LBRC, KC_RBRC, KC_BSLS, \
+  _______, KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_NUHS, KC_NUBS, KC_PGUP, KC_PGDN, _______, \
+  _______, _______, _______, _______, _______, _______, _______, _______, KC_HOME, KC_PGUP, KC_PGDN, KC_END \
+),
+
+/* Function
+ * ,-----------------------------------------------------------------------------------.
+ * | Esc  |      | Prev | Play | Next |      |      |Pg Up |  Up  |Pg Dn |Prt Sc| Del  |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |      |      | Vol- | Mute | Vol+ |      | Home | Left | Down |Right | End  |      |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |      |      |      |      |      |      |      |      |      |      |      |      |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      |      |      |      | Esc  |      |      | Esc  | Home |Pg Up |Pg Dn | End  |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_FN] = KEYMAP( \
+  KC_ESC , _______, KC_MPRV, KC_MPLY, KC_MNXT, _______, _______, KC_PGUP, KC_UP,   KC_PGDN, KC_PSCR, KC_DEL, \
+  _______, _______, KC_VOLD, KC_MUTE, KC_VOLU, _______, KC_HOME, KC_LEFT, KC_DOWN, KC_RGHT, KC_END , _______, \
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+  _______, _______, _______, _______, KC_ESC , _______, _______, KC_ESC , KC_HOME, KC_PGUP, KC_PGDN, KC_END \
+),
+
+/* Adjust (Lower + Raise)
+ * ,-----------------------------------------------------------------------------------.
+ * |      | Reset|      |      |      |      |      |      |      |      |      |  Del |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |      |      |      |Aud on|Audoff|AGnorm|AGswap|Qwerty|Colemk|Dvorak|      |      |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * | Caps |Voice-|Voice+|Mus on|Musoff|MIDIon|MIDIof|      |      |      |      | Caps |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      |      |      |      |      |      |      |      |      |      |      |      |
+ * `-----------------------------------------------------------------------------------'
+ */
+ [_ADJUST] = KEYMAP( \
+  _______, RESET,   DEBUG,   _______, _______, _______, _______, _______, _______, _______, _______, KC_DEL , \
+  _______, _______, MU_MOD,  AU_ON,   AU_OFF,  AG_NORM, AG_SWAP, QWERTY,  COLEMAK, DVORAK,  _______,  _______, \
+  KC_CAPS, MUV_DE,  MUV_IN,  MU_ON,   MU_OFF,  MI_ON,   MI_OFF,  _______, _______, _______, _______, KC_CAPS, \
+  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ \
+ )
+
+};
+
+#ifdef AUDIO_ENABLE
+float tone_qwerty[][2]     = SONG(QWERTY_SOUND);
+float tone_dvorak[][2]     = SONG(DVORAK_SOUND);
+float tone_colemak[][2]    = SONG(COLEMAK_SOUND);
+#endif
+
+void persistent_default_layer_set(uint16_t default_layer) {
+  eeconfig_update_default_layer(default_layer);
+  default_layer_set(default_layer);
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case QWERTY:
+      if (record->event.pressed) {
+        #ifdef AUDIO_ENABLE
+          PLAY_SONG(tone_qwerty);
+        #endif
+        persistent_default_layer_set(1UL<<_QWERTY);
+      }
+      return false;
+      break;
+    case COLEMAK:
+      if (record->event.pressed) {
+        #ifdef AUDIO_ENABLE
+          PLAY_SONG(tone_colemak);
+        #endif
+        persistent_default_layer_set(1UL<<_COLEMAK);
+      }
+      return false;
+      break;
+    case DVORAK:
+      if (record->event.pressed) {
+        #ifdef AUDIO_ENABLE
+          PLAY_SONG(tone_dvorak);
+        #endif
+        persistent_default_layer_set(1UL<<_DVORAK);
+      }
+      return false;
+      break;
+    case LOWER:
+      if (record->event.pressed) {
+        layer_on(_LOWER);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      } else {
+        layer_off(_LOWER);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      }
+      return false;
+      break;
+    case RAISE:
+      if (record->event.pressed) {
+        layer_on(_RAISE);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      } else {
+        layer_off(_RAISE);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      }
+      return false;
+      break;
+    case FN:
+      if (record->event.pressed) {
+        layer_on(_FN);
+      } else {
+        layer_off(_FN);
+      }
+      return false;
+      break;
+    case ADJUST:
+      if (record->event.pressed) {
+        layer_on(_ADJUST);
+      } else {
+        layer_off(_ADJUST);
+      }
+      return false;
+      break;
+  }
+  return true;
+}

keyboards/lets_split/keymaps/poker/rules.mk

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

keyboards/octagon/octagon.c

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

keyboards/octagon/octagon.h

@@ -0,0 +1,14 @@
+#ifndef OCTAGON_H
+#define OCTAGON_H
+
+#include "quantum.h"
+
+#ifdef KEYBOARD_octagon_v1
+    #include "v1.h"
+#endif
+
+#ifdef KEYBOARD_octagon_v2
+    #include "v2.h"
+#endif
+
+#endif

keyboards/octagon/readme.md

@@ -0,0 +1,11 @@
+# Duck Octagon
+
+Non official firmware for custom Korean keyboard with 75% key layout made by Duck.
+
+See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
+
+Newest version is the [Octagon V2](http://duck0113.tistory.com/127)
+
+Make example for this keyboard (after setting up your build environment):
+
+    make octagon/v2:default

keyboards/octagon/rules.mk

@@ -0,0 +1 @@
+DEFAULT_FOLDER = octagon/v2

keyboards/octagon/v1/config.h

@@ -0,0 +1,54 @@
+/*
+Copyright 2017 MechMerlin <mechmerlin@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      0x6050
+#define DEVICE_VER      0x0104
+#define MANUFACTURER    Duck
+#define PRODUCT         Octagon V1
+#define DESCRIPTION     Duck Octagon V1
+
+/* key matrix size */
+#define MATRIX_ROWS 6
+#define MATRIX_COLS 16
+
+#define DIODE_DIRECTION COL2ROW
+
+/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
+#define DEBOUNCING_DELAY 5
+
+/* number of backlight levels */
+#define BACKLIGHT_LEVELS 1
+
+/* key combination for magic key command */
+#define IS_COMMAND() ( \
+    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
+)
+
+#define RGBLIGHT_ANIMATIONS
+#define RGB_DI_PIN D6
+#define RGBLED_NUM 17
+
+#define TAPPING_TERM 200
+
+#endif

keyboards/octagon/v1/keymaps/default/keymap.c

@@ -0,0 +1,39 @@
+/* Copyright 2017 MechMerlin <mechmerlin@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 "octagon.h"
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    /* layer 0: qwerty */
+    [0] = KEYMAP(\
+        KC_ESC,  KC_F1,   KC_F2,  KC_F3,  KC_F4,  KC_F5,  KC_F6,  KC_F7,  KC_F8,   KC_F9,  KC_F10,  KC_F11,  KC_F12,  KC_PSCR, KC_PAUS,
+        KC_GRV,  KC_1,    KC_2,   KC_3,   KC_4,   KC_5,   KC_6,   KC_7,   KC_8,    KC_9,   KC_0,    KC_MINS, KC_EQL,  KC_BSPC, KC_HOME,
+        KC_TAB,  KC_Q,    KC_W,   KC_E,   KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,    KC_O,   KC_P,    KC_LBRC, KC_RBRC, KC_BSLS, KC_PGUP,
+        KC_CAPS, KC_A,    KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,    KC_L,   KC_SCLN, KC_QUOT, KC_NO,   KC_ENT,  KC_PGDN,
+        KC_LSFT, KC_Z,    KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP,   KC_END,
+        KC_LCTL, KC_LGUI, KC_LALT,                KC_SPC,                          MO(1),  KC_NO,   KC_RCTL, KC_LEFT, KC_DOWN, KC_RIGHT),
+
+    [1] = KEYMAP(\
+        KC_TRNS, RGB_TOG, RGB_MOD, RGB_VAI, 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, 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, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_NO,   KC_TRNS,
+        KC_TRNS, KC_NO,   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)
+        };
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
+  return MACRO_NONE;
+};

keyboards/octagon/v1/keymaps/default/readme.md

@@ -0,0 +1,8 @@
+# Default Octagon Layout
+
+This is the default implement layout for Duck Octagon V1.
+
+
+## Features
+
+* Default QWERTY layer

keyboards/octagon/v1/matrix.c

@@ -0,0 +1,236 @@
+/*
+Copyright 2017 MechMerlin <mechmerlin@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 <util/delay.h>
+#include <avr/io.h>
+#include <stdio.h>
+#include "matrix.h"
+#include "util.h"
+#include "print.h"
+#include "debug.h"
+
+static uint8_t debouncing = DEBOUNCING_DELAY;
+
+/* matrix state(1:on, 0:off) */
+static matrix_row_t matrix[MATRIX_ROWS];
+static matrix_row_t matrix_debouncing[MATRIX_ROWS];
+
+static uint8_t read_rows(uint8_t col);
+static void init_rows(void);
+static void unselect_cols(void);
+static void select_col(uint8_t col);
+
+__attribute__ ((weak))
+void matrix_init_quantum(void) {
+    matrix_init_kb();
+}
+
+__attribute__ ((weak))
+void matrix_scan_quantum(void) {
+    matrix_scan_kb();
+}
+
+__attribute__ ((weak))
+void matrix_init_kb(void) {
+    matrix_init_user();
+}
+
+__attribute__ ((weak))
+void matrix_scan_kb(void) {
+    matrix_scan_user();
+}
+
+__attribute__ ((weak))
+void matrix_init_user(void) {
+}
+
+__attribute__ ((weak))
+void matrix_scan_user(void) {
+}
+
+void backlight_init_ports(void)
+{
+    DDRB |= 0b00011111;  // PB0 (caps), PB1 (alpha), PB2 (extra), PB3 (modnum), PB4 (caps)
+    DDRD |= 0b11010000;  // PD4, (rgb blue), PD6 (rgb red), PD7 (rgb green)
+    DDRE |= 0b01000000;  // PE6 (frow)
+}
+
+void matrix_init(void) {
+  backlight_init_ports();
+  unselect_cols();
+  init_rows();
+
+  for (uint8_t i=0; i < MATRIX_ROWS; i++)  {
+    matrix[i] = 0;
+    matrix_debouncing[i] = 0;
+  }
+
+  matrix_init_quantum();
+}
+
+uint8_t matrix_scan(void) {
+  for (uint8_t col = 0; col < MATRIX_COLS; col++) {
+    select_col(col);
+    _delay_us(3);
+
+    uint8_t rows = read_rows(col);
+
+    for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
+      bool prev_bit = matrix_debouncing[row] & ((matrix_row_t)1<<col);
+      bool curr_bit = rows & (1<<row);
+      if (prev_bit != curr_bit) {
+        matrix_debouncing[row] ^= ((matrix_row_t)1<<col);
+        debouncing = DEBOUNCING_DELAY;
+      }
+    }
+    unselect_cols();
+  }
+
+  if (debouncing) {
+    if (--debouncing) {
+      _delay_ms(1);
+    } else {
+      for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+        matrix[i] = matrix_debouncing[i];
+      }
+    }
+  }
+
+  matrix_scan_quantum();
+  return 1;
+}
+
+inline matrix_row_t matrix_get_row(uint8_t row) {
+  return matrix[row];
+}
+
+void matrix_print(void) {
+  print("\nr/c 0123456789ABCDEF\n");
+  for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
+    xprintf("%02X: %032lb\n", row, bitrev32(matrix_get_row(row)));
+  }
+}
+
+/* Row pin configuration
+ * row: 0    1    2    3    4    5
+ * pin: PB7  PD0  PD1  PD2  PD3  PD5
+ *
+ * Esc uses its own pin PE2
+ */
+static void init_rows(void) {
+    DDRD  &= ~0b00101111; // PD0, PD1, PD2, PD3, PD5 input
+    PORTD &= ~0b00101111; // PD0, PD1, PD2, PD3, PD5 low
+
+    DDRB  &= ~0b10000000; // PB7 input
+    PORTB &= ~0b10000000; // PB7 low
+
+    DDRE  &= ~0b00000100; // PE2 input
+    PORTE |=  0b00000100; // PE2 high
+}
+
+static uint8_t read_rows(uint8_t col) {
+  if (col == 14) {
+    return PINE&(1<<2) ? 0 : (1<<0);        // PE2 (Row 0)
+  } else {
+      return (PIND&(1<<0) ? (1<<0) : 0) |   // PD0 (Row 0)
+             (PIND&(1<<1) ? (1<<1) : 0) |   // PD1 (Row 1)
+             (PIND&(1<<2) ? (1<<2) : 0) |   // PD2 (Row 2)
+             (PIND&(1<<3) ? (1<<3) : 0) |   // PD3 (Row 3)
+             (PIND&(1<<5) ? (1<<4) : 0) |   // PD5 (Row 4)
+             (PINB&(1<<7) ? (1<<5) : 0);    // PB7 (Row 5)
+    }
+}
+
+uint8_t read_fwkey(void)
+{
+  return PINE&(1<<2) ? 0 : (1<<0);
+}
+
+static void unselect_cols(void) {
+    DDRB  |=  0b01000000; // PB6 (U2) output
+    PORTB &= ~0b01000000; // PB6 (U2) low
+
+    DDRC  |=  0b11000000; // PC6 (U1), PC7 (A2) output
+    PORTC &= ~0b11000000; // PC6 (U1), PC7 (A2) low
+
+    DDRF  |=  0b00000011; // PF0 (A0), PF1 (A1) output
+    PORTF &= ~0b00000011; // PF0 (A0), PF1 (A1) low
+}
+
+static void select_col(uint8_t col) {
+ 
+   switch (col) {
+        case 0:
+            PORTC |= 0b01000000; // PC6 high
+            break;
+        case 1:
+            PORTC |= 0b01000000; // PC6 high
+            PORTF |= 0b00000001; // PF0 high
+            break;
+        case 2:
+            PORTC |= 0b01000000; // PC6 high
+            PORTF |= 0b00000010; // PF1 high
+            break;
+        case 3:
+            PORTC |= 0b01000000; // PC6 high
+            PORTF |= 0b00000011; // PF0, PF1 high
+            break;
+        case 4:
+            PORTC |= 0b11000000; // PC6, PC7 high
+            break;
+        case 5:
+            PORTC |= 0b11000000; // PC6, PC7 high
+            PORTF |= 0b00000001; // PF0 high
+            break;
+        case 6:
+            PORTC |= 0b11000000; // PC6, PC7 high
+            PORTF |= 0b00000010; // PF1 high
+            break;
+        case 7:
+            PORTC |= 0b11000000; // PC6, PC7 high
+            PORTF |= 0b00000011; // PF0, PF1 high
+            break;
+        case 8:
+            PORTB |= 0b01000000; // PB6 high
+            break;
+        case 9:
+            PORTB |= 0b01000000; // PB6 high
+            PORTF |= 0b00000001; // PF0 high
+            break;
+        case 10:
+            PORTB |= 0b01000000; // PB6 high
+            PORTF |= 0b00000010; // PF1 high
+            break;
+        case 11:
+            PORTB |= 0b01000000; // PB6 high
+            PORTF |= 0b00000011; // PF0, PF1 high
+            break;
+        case 12:
+            PORTB |= 0b01000000; // PB6 high
+            PORTC |= 0b10000000; // PC7 high
+            break;
+        case 13:
+            PORTB |= 0b01000000; // PB6 high
+            PORTF |= 0b00000001; // PF0 high
+            PORTC |= 0b10000000; // PC7 high
+            break;
+        case 15:
+            PORTB |= 0b01000000; // PB6 high
+            PORTF |= 0b00000010; // PF1 high
+            PORTC |= 0b10000000; // PC7 high
+            break;
+    }
+}

keyboards/octagon/v1/readme.md

@@ -0,0 +1,28 @@
+# Duck Octagon V1
+
+Non official firmware for custom Korean keyboard with 75% key layout made by Duck.  
+Group buy was run October 2014 via [geekhack](https://geekhack.org/index.php?topic=65036.0) 35 keyboards total. 
+
+Keyboard Maintainer: [MechMerlin](https://github.com/mechmerlin)  
+Hardware Supported: Duck Octagon PCB Ver 1.0, Atmega32u4  
+Hardware Availability: Wait until GB of the next revision
+
+Make example for this keyboard (after setting up your build environment):
+
+    make octagon/v1:default
+
+See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
+
+## Hardware Notes
+
+The Duck Octagon V1 PCB consists of:
+
+### Microchips
+2 74HC237D 3-to-8 line decoders
+1 Atmega32u4 microcontroller
+2 WS2811 LED controller
+
+## Notes
+Thanks to Ralf Schmitt for previous implementations in his [TMK fork](https://github.com/xauser/tmk_keyboard/tree/xauser/) and few helping words.
+
+Based heavily on Rasmus Schults [Duck Lightsaver QMK Port](https://github.com/qmk/qmk_firmware/tree/master/keyboards/lightsaver)

keyboards/octagon/v1/rules.mk

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

keyboards/octagon/v1/v1.c

@@ -0,0 +1,50 @@
+/* Copyright 2017 MechMerlin <mechmerlin@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 "v1.h"
+
+enum BACKLIGHT_AREAS {
+  BACKLIGHT_ALPHA    = 0b0000001,
+  BACKLIGHT_EXTRA    = 0b0000010,
+  BACKLIGHT_MODNUM   = 0b0000100,
+  BACKLIGHT_FROW     = 0b0001000,
+  BACKLIGHT_RGB      = 0b0010000,
+  BACKLIGHT_RGBRED   = 0b0010000,
+  BACKLIGHT_RGBGREEN = 0b0100000,
+  BACKLIGHT_RGBBLUE  = 0b1000000,
+  BACKLIGHT_SWITCH   = 0b0001111
+};
+
+uint8_t backlight_os_state = 0;
+uint32_t backlight_layer_state = 0;
+
+void backlight_set(uint8_t level) {
+  level & BACKLIGHT_ALPHA ? (PORTB |= 0b00000010) : (PORTB &= ~0b00000010);
+  level & BACKLIGHT_EXTRA ? (PORTB |= 0b00000100) : (PORTB &= ~0b00000100);
+  level & BACKLIGHT_MODNUM ? (PORTB |= 0b00001000) : (PORTB &= ~0b00001000);
+  level & BACKLIGHT_FROW ? (PORTE |= 0b01000000) : (PORTE &= ~0b01000000);
+  level & BACKLIGHT_RGBRED ? (PORTD |= 0b01000000) : (PORTD &= ~0b01000000);
+  level & BACKLIGHT_RGBGREEN ? (PORTD |= 0b10000000) : (PORTD &= ~0b10000000);
+  level & BACKLIGHT_RGBBLUE ? (PORTD |= 0b00010000) : (PORTD &= ~0b00010000);
+}
+
+void led_set_kb(uint8_t usb_led) {
+  backlight_os_state & (1<<USB_LED_CAPS_LOCK) ? (PORTB &= ~0b00000001) : (PORTB |= 0b00000001);
+  backlight_os_state & (1<<USB_LED_SCROLL_LOCK) ? (PORTB &= ~0b00010000) : (PORTB |= 0b00010000);
+}
+
+bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
+  return process_record_user(keycode, record);
+}

keyboards/octagon/v1/v1.h

@@ -0,0 +1,36 @@
+/* Copyright 2017 MechMerlin <mechmerlin@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 V1_H
+#define V1_H
+
+#include "../octagon.h"
+
+#define KEYMAP( \
+    K5A, K5B, K5C, K5D, K5E, K5F, K5G, K5H, K5I, K5J, K5K, K5L, K5M, K5N, K5P, \
+    K4A, K4B, K4C, K4D, K4E, K4F, K4G, K4H, K4I, K4J, K4K, K4L, K4M, K4N, K4P, \
+    K3A, K3B, K3C, K3D, K3E, K3F, K3G, K3H, K3I, K3J, K3K, K3L, K3M, K3N, K3P, \
+    K2A, K2B, K2C, K2D, K2E, K2F, K2G, K2H, K2I, K2J, K2K, K2L, K5O, K2N, K2P, \
+    K1A,      K1C, K1D, K1E, K1F, K1G, K1H, K1I, K1J, K1K, K1L, K1M, K1N, K1P, \
+    K0A, K0B, K0C,                K0G,           K0J, K0K, K0L, K0M, K0N, K0P  \
+) { \
+  { K5A, K5B, K5C, K5D,   K5E,   K5F, K5G,   K5H,   K5I, K5J, K5K, K5L,   K5M,   K5N, K5O,   K5P }, \
+  { K4A, K4B, K4C, K4D,   K4E,   K4F, K4G,   K4H,   K4I, K4J, K4K, K4L,   K4M,   K4N, KC_NO, K4P }, \
+  { K3A, K3B, K3C, K3D,   K3E,   K3F, K3G,   K3H,   K3I, K3J, K3K, K3L,   K3M,   K3N, KC_NO, K3P }, \
+  { K2A, K2B, K2C, K2D,   K2E,   K2F, K2G,   K2H,   K2I, K2J, K2K, K2L,   KC_NO, K2N, KC_NO, K2P }, \
+  { K1A, K1C, K1D, K1E,   K1F,   K1G, K1H,   K1I,   K1J, K1K, K1L, KC_NO, K1M,   K1N, KC_NO, K1P }, \
+  { K0A, K0B, K0C, KC_NO, KC_NO, K0G, KC_NO, KC_NO, K0J, K0K, K0L, KC_NO, K0M,   K0N, KC_NO, K0P }  \
+}
+#endif

keyboards/octagon/v2/keymaps/default/keymap.c

@@ -13,7 +13,7 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include "octagon_v2.h"
+#include "octagon.h"
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     /* layer 0: qwerty */
@@ -36,4 +36,4 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
   return MACRO_NONE;
-};
+};

keyboards/octagon/v2/keymaps/default/readme.md

@@ -5,4 +5,4 @@ This is the default implement layout for Duck Octagon V2.
 
 ## Features
 
-* Default QWERTY layer
+* Default QWERTY layer

keyboards/octagon/v2/readme.md

@@ -9,7 +9,7 @@ Hardware Availability: Wait until GB of the next revision
 
 Make example for this keyboard (after setting up your build environment):
 
-    make octagon_v2:default
+    make octagon/v2:default
 
 See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
 
@@ -25,4 +25,4 @@ The Duck Octagon V2 PCB consists of:
 ## Notes
 Thanks to Ralf Schmitt for previous implementations in his [TMK fork](https://github.com/xauser/tmk_keyboard/tree/xauser/) and few helping words.
 
-Based heavily on Rasmus Schults [Duck Lightsaver QMK Port](https://github.com/qmk/qmk_firmware/tree/master/keyboards/lightsaver)
+Based heavily on Rasmus Schults [Duck Lightsaver QMK Port](https://github.com/qmk/qmk_firmware/tree/master/keyboards/lightsaver)

keyboards/octagon/v2/v2.c

@@ -13,7 +13,7 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include "octagon_v2.h"
+#include "v2.h"
 #include "indicator_leds.h"
 
 enum BACKLIGHT_AREAS {

keyboards/octagon/v2/v2.h

@@ -13,10 +13,10 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#ifndef OCTAGON_V2_H
+#ifndef V2_H
-#define OCTAGON_V2_H
+#define V2_H
 
-#include "quantum.h"
+#include "../octagon.h"
 
 #define KEYMAP( \
     K5A, K5B, K5C, K5D, K5E, K5F, K5G, K5H, K5I, K5J, K5K, K5L, K5M, K5N, K5O,     K5Q, \

keyboards/planck/config.h

@@ -44,6 +44,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define AUDIO_VOICES
 #define C6_AUDIO
 
+#define CONSOLE_IN_ENABLE
+
 #define BACKLIGHT_PIN B7
 
 /* COL2ROW or ROW2COL */

keyboards/planck/keymaps/pok3r/config.h

@@ -25,7 +25,7 @@
 /* enable basic MIDI features:
    - MIDI notes can be sent when in Music mode is on
 */
-                                
+
 #define MIDI_BASIC
 
 /* enable advanced MIDI features:

keyboards/planck/keymaps/pok3r/keymap.c

@@ -56,10 +56,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * `-----------------------------------------------------------------------------------'
  */
 [_QWERTY] = {
-  {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_TAB         , KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_BSPC},
-  {FUNCTION,KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT},
+  {FUNCTION       , 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 },
+  {SFT_T(KC_ESC)  , KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, MT(MOD_RSFT, KC_ENT)},
-  {KC_LCTL, KC_LGUI, KC_ESC,  KC_LALT, LOWER,   KC_SPC,  KC_SPC,  RAISE,   KC_LEFT, KC_UP,   KC_DOWN, KC_RGHT}
+  {KC_LCTL        , KC_LGUI, KC_ESC,  KC_LALT, LOWER,   KC_SPC,  KC_SPC,  RAISE,   KC_LEFT, KC_UP,   KC_DOWN, KC_RGHT}
 },
 
 /* Colemak
@@ -74,10 +74,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * `-----------------------------------------------------------------------------------'
  */
 [_COLEMAK] = {
-  {KC_TAB,  KC_Q,    KC_W,    KC_F,    KC_P,    KC_G,    KC_J,    KC_L,    KC_U,    KC_Y,    KC_SCLN, KC_BSPC},
+  {KC_TAB         , KC_Q,    KC_W,    KC_F,    KC_P,    KC_G,    KC_J,    KC_L,    KC_U,    KC_Y,    KC_SCLN, KC_BSPC},
-  {FUNCTION,KC_A,    KC_R,    KC_S,    KC_T,    KC_D,    KC_H,    KC_N,    KC_E,    KC_I,    KC_O,    KC_QUOT},
+  {FUNCTION       , KC_A,    KC_R,    KC_S,    KC_T,    KC_D,    KC_H,    KC_N,    KC_E,    KC_I,    KC_O,    KC_QUOT},
-  {KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_K,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ENT },
+  {SFT_T(KC_ESC)  , KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_K,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, MT(MOD_RSFT, KC_ENT)},
-  {KC_LCTL, KC_LGUI, KC_ESC,  KC_LALT, LOWER,   KC_SPC,  KC_SPC,  RAISE,   KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT}
+  {KC_LCTL        , KC_LGUI, KC_ESC,  KC_LALT, LOWER,   KC_SPC,  KC_SPC,  RAISE,   KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT}
 },
 
 /* Dvorak
@@ -92,10 +92,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * `-----------------------------------------------------------------------------------'
  */
 [_DVORAK] = {
-  {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_TAB         , KC_QUOT, KC_COMM, KC_DOT,  KC_P,    KC_Y,    KC_F,    KC_G,    KC_C,    KC_R,    KC_L,    KC_BSPC},
-  {FUNCTION,KC_A,    KC_O,    KC_E,    KC_U,    KC_I,    KC_D,    KC_H,    KC_T,    KC_N,    KC_S,    KC_SLSH},
+  {FUNCTION       , 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 },
+  {SFT_T(KC_ESC)  , KC_SCLN, KC_Q,    KC_J,    KC_K,    KC_X,    KC_B,    KC_M,    KC_W,    KC_V,    KC_Z,    MT(MOD_RSFT, KC_ENT)},
-  {KC_LCTL, KC_LGUI, KC_ESC,  KC_LALT, LOWER,   KC_SPC,  KC_SPC,  RAISE,   KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT}
+  {KC_LCTL        , KC_LGUI, KC_ESC,  KC_LALT, LOWER,   KC_SPC,  KC_SPC,  RAISE,   KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT}
 },
 
 /* Lower
@@ -159,7 +159,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |------+------+------+------+------+-------------+------+------+------+------+------|
  * |      |      |      |Aud on|Audoff|AGnorm|AGswap|Qwerty|Colemk|Dvorak|Plover|      |
  * |------+------+------+------+------+------|------+------+------+------+------+------|
- * | Caps |Voice-|Voice+|Mus on|Musoff|MIDIon|MIDIof|      |      |      |      |      |
+ * | Caps |Voice-|Voice+|Mus on|Musoff|MIDIon|MIDIof|      |      |      |      | Caps |
  * |------+------+------+------+------+------+------+------+------+------+------+------|
  * |      |      |      |      |      |             |      |      |      |      |      |
  * `-----------------------------------------------------------------------------------'
@@ -167,7 +167,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 [_ADJUST] = {
   {_______, RESET,   DEBUG,   _______, _______, _______, _______, _______, _______, _______, _______, KC_DEL },
   {_______, _______, MU_MOD,  AU_ON,   AU_OFF,  AG_NORM, AG_SWAP, QWERTY,  COLEMAK, DVORAK,  PLOVER,  _______},
-  {KC_CAPS, MUV_DE,  MUV_IN,  MU_ON,   MU_OFF,  MI_ON,   MI_OFF,  _______, _______, _______, _______, _______},
+  {KC_CAPS, MUV_DE,  MUV_IN,  MU_ON,   MU_OFF,  MI_ON,   MI_OFF,  _______, _______, _______, _______, KC_CAPS},
   {_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______}
 },
 
@@ -214,7 +214,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
       if (record->event.pressed) {
         set_single_persistent_default_layer(_DVORAK);
       }
-      return false; 
+      return false;
       break;
     case LOWER:
       if (record->event.pressed) {

keyboards/planck/rules.mk

@@ -65,7 +65,7 @@ CONSOLE_ENABLE = yes         # Console for debug(+400)
 COMMAND_ENABLE = no        # Commands for debug and configuration
 NKRO_ENABLE = yes            # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
 BACKLIGHT_ENABLE = no      # Enable keyboard backlight functionality
-MIDI_ENABLE = yes            # MIDI controls
+MIDI_ENABLE = no            # MIDI controls
 AUDIO_ENABLE = yes           # Audio output on port C6
 UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID

keyboards/preonic/rules.mk

@@ -61,7 +61,7 @@ CONSOLE_ENABLE = yes         # Console for debug(+400)
 COMMAND_ENABLE = no        # Commands for debug and configuration
 NKRO_ENABLE = no            # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
 BACKLIGHT_ENABLE = yes      # Enable keyboard backlight functionality
-MIDI_ENABLE = yes            # MIDI controls
+MIDI_ENABLE = no            # MIDI controls
 AUDIO_ENABLE = yes           # Audio output on port C6
 UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID

layouts/community/ergodox/zweihander-osx/readme.markdown

@@ -20,7 +20,6 @@ I tend to have my mouse in my left hand, but I like to use my other hand to make
 - Open and Close Parent Folder (⌥⌘↓)
 - Go Up and Close Just-Left Folder (⌥⌘↑)
 - Cycle through open windows in current application (⌘\` and ⌘⇧\`)
-- Cycle through tabs in current window (⌥⇥ and ⌥⇧⇥)
 
 Because moving letter-by-letter is way slower than moving word-by-word, I added Option (⌥) to the bottommost button on the left side. This key can be held easily while holding ; (activate media layer) and pressing J and L to move left and right by word.
 
@@ -30,7 +29,6 @@ Because moving letter-by-letter is way slower than moving word-by-word, I added
 I wanted to preserve the feel of a number of shortcuts that involve pressing lots of modifier keys at once; this is why the bottom left of the keyboard has shift, control, option, and command in the usual spaces. Further, some common shortcuts I press have a key on the right side of the keyboard. These shortcuts include:
 
 - Empty Trash Without Asking for Confirmation (⇧⌥⌘⌫)
-- Shut Down Without Asking for Confirmation (⇧⌥⌘ power)
 
 ⇧⌥⌘⌫, when you press the backspace on the right half of the keyboard, is much more satisfying than if you curl your left hand into a claw to press all the keys on the left. Try both; you’ll agree.
 

quantum/process_keycode/process_auto_shift.c

@@ -67,6 +67,30 @@ void autoshift_flush(void) {
   }
 }
 
+bool autoshift_enabled = true;
+
+void autoshift_enable(void) {
+    autoshift_enabled = true;
+}
+void autoshift_disable(void) {
+  autoshift_enabled = false;
+  autoshift_flush();
+}
+
+void autoshift_toggle(void) {
+  if (autoshift_enabled) {
+    autoshift_enabled = false;
+    autoshift_flush();
+  }
+  else {
+    autoshift_enabled = true;
+  }
+}
+
+bool autoshift_state(void) {
+  return autoshift_enabled;
+}
+
 bool process_auto_shift(uint16_t keycode, keyrecord_t *record) {
   static uint8_t any_mod_pressed;
 
@@ -84,6 +108,16 @@ bool process_auto_shift(uint16_t keycode, keyrecord_t *record) {
         autoshift_timer_report();
         return false;
 
+      case KC_ASTG:
+        autoshift_toggle();
+        return false;
+      case KC_ASON:
+        autoshift_enable();
+        return false;
+      case KC_ASOFF:
+        autoshift_disable();
+        return false;
+
 #ifndef NO_AUTO_SHIFT_ALPHA
       case KC_A:
       case KC_B:
@@ -137,7 +171,9 @@ bool process_auto_shift(uint16_t keycode, keyrecord_t *record) {
       case KC_DOT:
       case KC_SLSH:
 #endif
+
         autoshift_flush();
+        if (!autoshift_enabled) return true;
 
         any_mod_pressed = get_mods() & (
           MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)|

quantum/process_keycode/process_auto_shift.h

@@ -25,4 +25,9 @@
 
 bool process_auto_shift(uint16_t keycode, keyrecord_t *record);
 
+void autoshift_enable(void);
+void autoshift_disable(void);
+void autoshift_toggle(void);
+bool autoshift_state(void);
+
 #endif

quantum/quantum.c

@@ -1296,3 +1296,42 @@ __attribute__ ((weak))
 void shutdown_user() {}
 
 //------------------------------------------------------------------------------
+
+#ifdef CONSOLE_IN_ENABLE
+
+__attribute__ ((weak))
+void process_console_data_user(uint8_t * data, uint8_t length) {
+}
+
+__attribute__ ((weak))
+void process_console_data_kb(uint8_t * data, uint8_t length) {
+  process_console_data_user(data, length);
+}
+
+void process_console_data_quantum(uint8_t * data, uint8_t length) {
+  // This can be used for testing - it echos back the information received
+  // print("Received message:\n  ");
+  // while (*data) {
+  //   sendchar(*data);
+  //   data++;
+  // }
+  switch (data[0]) {
+    case 0x01:
+      print("Saying hello\n");
+      #ifdef AUDIO_ENABLE
+        audio_on();
+      #endif
+      break;
+    case 0xFE:
+    #ifdef CONSOLE_IN_BOOTLOADER
+      print("Entering bootloader\n");
+      reset_keyboard();
+    #else
+      print("Unable to enter bootloader\n");
+    #endif
+      break;
+  }
+  process_console_data_kb(data, length);
+}
+
+#endif

quantum/quantum.h

@@ -193,4 +193,10 @@ void led_set_kb(uint8_t usb_led);
 
 void api_send_unicode(uint32_t unicode);
 
+#ifdef CONSOLE_IN_ENABLE
+void process_console_data_user(uint8_t * data, uint8_t length);
+void process_console_data_kb(uint8_t * data, uint8_t length);
+void process_console_data_quantum(uint8_t * data, uint8_t length);
+#endif
+
 #endif

quantum/quantum_keycodes.h

@@ -125,6 +125,9 @@ enum quantum_keycodes {
     KC_ASUP,
     KC_ASDN,
     KC_ASRP,
+    KC_ASTG,
+    KC_ASON,
+    KC_ASOFF,
 
     // Audio on/off/toggle
     AU_ON,

tmk_core/protocol/lufa/descriptor.h

@@ -208,8 +208,11 @@ typedef struct
 
 #ifdef CONSOLE_ENABLE
 #   define CONSOLE_IN_EPNUM         (RAW_OUT_EPNUM + 1)
-//#   define CONSOLE_OUT_EPNUM        (RAW_OUT_EPNUM + 2)
+#   ifdef CONSOLE_IN_ENABLE
-#   define CONSOLE_OUT_EPNUM        (RAW_OUT_EPNUM + 1)
+#       define CONSOLE_OUT_EPNUM        (RAW_OUT_EPNUM + 2)
+#   else
+#       define CONSOLE_OUT_EPNUM        (RAW_OUT_EPNUM + 1)
+#   endif
 #else
 #   define CONSOLE_OUT_EPNUM        RAW_OUT_EPNUM
 #endif

tmk_core/protocol/lufa/lufa.c

@@ -264,6 +264,14 @@ static void raw_hid_task(void)
  * Console
  ******************************************************************************/
 #ifdef CONSOLE_ENABLE
+
+static bool console_flush = false;
+#define CONSOLE_FLUSH_SET(b)   do { \
+  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {\
+    console_flush = b; \
+  } \
+} while (0)
+
 static void Console_Task(void)
 {
     /* Device must be connected and configured for the task to run */
@@ -272,49 +280,62 @@ static void Console_Task(void)
 
     uint8_t ep = Endpoint_GetCurrentEndpoint();
 
-#if 0
+    #ifdef CONSOLE_IN_ENABLE
-    // TODO: impl receivechar()/recvchar()
+      /* Create a temporary buffer to hold the read in report from the host */
-    Endpoint_SelectEndpoint(CONSOLE_OUT_EPNUM);
+      uint8_t ConsoleData[CONSOLE_EPSIZE];
+      bool data_read = false;
 
-    /* Check to see if a packet has been sent from the host */
+      // TODO: impl receivechar()/recvchar()
-    if (Endpoint_IsOUTReceived())
+      Endpoint_SelectEndpoint(CONSOLE_OUT_EPNUM);
-    {
-        /* Check to see if the packet contains data */
-        if (Endpoint_IsReadWriteAllowed())
-        {
-            /* Create a temporary buffer to hold the read in report from the host */
-            uint8_t ConsoleData[CONSOLE_EPSIZE];
 
-            /* Read Console Report Data */
+      /* Check to see if a packet has been sent from the host */
-            Endpoint_Read_Stream_LE(&ConsoleData, sizeof(ConsoleData), NULL);
+      if (Endpoint_IsOUTReceived())
+      {
+          /* Check to see if the packet contains data */
+          if (Endpoint_IsReadWriteAllowed())
+          {
 
+              /* Read Console Report Data */
+              Endpoint_Read_Stream_LE(&ConsoleData, sizeof(ConsoleData), NULL);
+              data_read = true;
+          }
+
+          /* Finalize the stream transfer to send the last packet */
+          Endpoint_ClearOUT();
+
+          if (data_read) {
             /* Process Console Report Data */
-            //ProcessConsoleHIDReport(ConsoleData);
+            process_console_data_quantum(ConsoleData, sizeof(ConsoleData));
-        }
+          }
 
-        /* Finalize the stream transfer to send the last packet */
+      }
-        Endpoint_ClearOUT();
-    }
-#endif
 
-    /* IN packet */
+    #endif
-    Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM);
-    if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
-        Endpoint_SelectEndpoint(ep);
-        return;
-    }
 
-    // fill empty bank
+    if (console_flush) {
-    while (Endpoint_IsReadWriteAllowed())
+      /* IN packet */
-        Endpoint_Write_8(0);
+      Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM);
+      if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
+          Endpoint_SelectEndpoint(ep);
+          return;
+      }
 
-    // flash senchar packet
+      // fill empty bank
-    if (Endpoint_IsINReady()) {
+      while (Endpoint_IsReadWriteAllowed())
-        Endpoint_ClearIN();
+          Endpoint_Write_8(0);
+
+      // flash senchar packet
+      if (Endpoint_IsINReady()) {
+          Endpoint_ClearIN();
+      }
+      // CONSOLE_FLUSH_SET(false);
+      console_flush = false;
     }
 
     Endpoint_SelectEndpoint(ep);
+
 }
+
 #endif
 
 
@@ -380,13 +401,8 @@ void EVENT_USB_Device_WakeUp()
 
 
 
-#ifdef CONSOLE_ENABLE
+// #ifdef CONSOLE_ENABLE
-static bool console_flush = false;
+#if 0
-#define CONSOLE_FLUSH_SET(b)   do { \
-  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {\
-    console_flush = b; \
-  } \
-} while (0)
 
 // called every 1ms
 void EVENT_USB_Device_StartOfFrame(void)
@@ -395,9 +411,9 @@ void EVENT_USB_Device_StartOfFrame(void)
     if (++count % 50) return;
     count = 0;
 
-    if (!console_flush) return;
+    //if (!console_flush) return;
     Console_Task();
-    console_flush = false;
+    //console_flush = false;
 }
 
 #endif
@@ -440,10 +456,10 @@ void EVENT_USB_Device_ConfigurationChanged(void)
     /* Setup Console HID Report Endpoints */
     ConfigSuccess &= ENDPOINT_CONFIG(CONSOLE_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
                                      CONSOLE_EPSIZE, ENDPOINT_BANK_SINGLE);
-#if 0
+  #ifdef CONSOLE_IN_ENABLE
     ConfigSuccess &= ENDPOINT_CONFIG(CONSOLE_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
                                      CONSOLE_EPSIZE, ENDPOINT_BANK_SINGLE);
-#endif
+  #endif
 #endif
 
 #ifdef NKRO_ENABLE
@@ -1101,7 +1117,7 @@ static void setup_usb(void)
     USB_Init();
 
     // for Console_Task
-    USB_Device_EnableSOFEvents();
+    //USB_Device_EnableSOFEvents();
     print_set_sendchar(sendchar);
 }
 
@@ -1216,6 +1232,10 @@ int main(void)
         raw_hid_task();
 #endif
 
+#ifdef CONSOLE_ENABLE
+        Console_Task();
+#endif
+
 #if !defined(INTERRUPT_CONTROL_ENDPOINT)
         USB_USBTask();
 #endif