Features/ws2812 matrix driver (#5418)

* WS2812 driver implementation for RGB Matrix

* Added driver configuration docs

common_features.mk

@@ -114,7 +114,7 @@ ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
     endif
 endif
 
-VALID_MATRIX_TYPES := yes IS31FL3731 IS31FL3733 IS31FL3737 custom
+VALID_MATRIX_TYPES := yes IS31FL3731 IS31FL3733 IS31FL3737 WS2812 custom
 
 LED_MATRIX_ENABLE ?= no
 ifneq ($(strip $(LED_MATRIX_ENABLE)), no)
@@ -172,6 +172,11 @@ ifeq ($(strip $(RGB_MATRIX_ENABLE)), IS31FL3737)
     SRC += i2c_master.c
 endif
 
+ifeq ($(strip $(RGB_MATRIX_ENABLE)), WS2812)
+    OPT_DEFS += -DWS2812
+    SRC += ws2812.c
+endif
+
 ifeq ($(strip $(TAP_DANCE_ENABLE)), yes)
     OPT_DEFS += -DTAP_DANCE_ENABLE
     SRC += $(QUANTUM_DIR)/process_keycode/process_tap_dance.c

docs/feature_macros.md

@@ -195,6 +195,49 @@ This will clear all mods currently pressed.
 
 This will clear all keys besides the mods currently pressed.
 
+## Advanced Example: 
+
+### Super ALT↯TAB
+
+This macro will register `KC_LALT` and tap `KC_TAB`, then wait for 1000ms. If the key is tapped again, it will send another `KC_TAB`; if there is no tap, `KC_LALT` will be unregistered, thus allowing you to cycle through windows. 
+
+```c
+bool is_alt_tab_active = false;    # ADD this near the begining of keymap.c
+uint16_t alt_tab_timer = 0;        # we will be using them soon.
+
+enum custom_keycodes {             # Make sure have the awesome keycode ready
+  ALT_TAB = SAFE_RANGE,
+};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {               # This will do most of the grunt work with the keycodes.
+    case ALT_TAB:
+      if (record->event.pressed) {
+        if (!is_alt_tab_active) {
+          is_alt_tab_active = true;
+          register_code(KC_LALT);
+        } 
+        alt_tab_timer = timer_read();
+        register_code(KC_TAB);
+      } else {
+        unregister_code(KC_TAB);
+      }
+      break;
+  }
+  return true;
+}
+
+void matrix_scan_user(void) {     # The very important timer. 
+  if (is_alt_tab_active) {
+    if (timer_elapsed(alt_tab_timer) > 1000) {
+      unregister_code16(LALT(KC_TAB));
+      is_alt_tab_active = false;
+    }
+  }
+}
+```
+
+---
 
 ##  **(DEPRECATED)** The Old Way: `MACRO()` & `action_get_macro`
 
@@ -273,7 +316,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 ```
 
 
-### Advanced Example: Single-Key Copy/Paste
+## Advanced Example: 
+
+### Single-Key Copy/Paste
 
 This example defines a macro which sends `Ctrl-C` when pressed down, and `Ctrl-V` when released.
 

docs/feature_rgb_matrix.md

@@ -5,7 +5,7 @@ This feature allows you to use RGB LED matrices driven by external drivers. It h
 If you want to use single color LED's you should use the [LED Matrix Subsystem](feature_led_matrix.md) instead.
 
 ## Driver configuration
-
+---
 ### IS31FL3731
 
 There is basic support for addressable RGB matrix lighting with the I2C IS31FL3731 RGB controller. To enable it, add this to your `rules.mk`:
@@ -52,6 +52,7 @@ const is31_led g_is31_leds[DRIVER_LED_TOTAL] = {
 
 Where `Cx_y` is the location of the LED in the matrix defined by [the datasheet](http://www.issi.com/WW/pdf/31FL3731.pdf) and the header file `drivers/issi/is31fl3731.h`. The `driver` is the index of the driver you defined in your `config.h` (`0` or `1` right now).
 
+---
 ###  IS31FL3733/IS31FL3737
 
 !> For the IS31FL3737, replace all instances of `IS31FL3733` below with `IS31FL3737`.
@@ -102,6 +103,27 @@ const is31_led g_is31_leds[DRIVER_LED_TOTAL] = {
 
 Where `X_Y` is the location of the LED in the matrix defined by [the datasheet](http://www.issi.com/WW/pdf/31FL3733.pdf) and the header file `drivers/issi/is31fl3733.h`. The `driver` is the index of the driver you defined in your `config.h` (Only `0` right now).
 
+---
+
+### WS2812 (AVR only)
+
+There is basic support for addressable RGB matrix lighting with a WS2811/WS2812{a,b,c} addressable LED strand. To enable it, add this to your `rules.mk`:
+
+```C
+RGB_MATRIX_ENABLE = WS2812
+```
+
+Configure the hardware via your `config.h`:
+
+```C
+// The pin connected to the data pin of the LEDs
+#define RGB_DI_PIN D7
+// The number of LEDs connected
+#define DRIVER_LED_TOTAL 70
+```
+
+---
+
 From this point forward the configuration is the same for all the drivers. 
 
 ```C

drivers/avr/ws2812.c

@@ -27,6 +27,12 @@
 #include <util/delay.h>
 #include "debug.h"
 
+#if !defined(LED_ARRAY) && defined(RGB_MATRIX_ENABLE)
+// LED color buffer
+LED_TYPE led[DRIVER_LED_TOTAL];
+  #define LED_ARRAY led
+#endif
+
 #ifdef RGBW_BB_TWI
 
 // Port for the I2C
@@ -141,6 +147,25 @@ unsigned char I2C_Write(unsigned char c)
 
 #endif
 
+#ifdef RGB_MATRIX_ENABLE
+// Set an led in the buffer to a color
+void inline ws2812_setled(int i, uint8_t r, uint8_t g, uint8_t b)
+{
+    led[i].r = r;
+    led[i].g = g;
+    led[i].b = b;
+}
+
+void ws2812_setled_all  (uint8_t r, uint8_t g, uint8_t b)
+{
+  for (int i = 0; i < RGBLED_NUM; i++) {
+    led[i].r = r;
+    led[i].g = g;
+    led[i].b = b;
+  }
+}
+#endif
+
 // Setleds for standard RGB
 void inline ws2812_setleds(LED_TYPE *ledarray, uint16_t leds)
 {

drivers/avr/ws2812.h

@@ -30,7 +30,6 @@
 
 #include "rgblight_types.h"
 
-
 /* User Interface
  *
  * Input:
@@ -43,6 +42,10 @@
  *         - Send out the LED data
  *         - Wait 50<35>s to reset the LEDs
  */
+#ifdef RGB_MATRIX_ENABLE
+void ws2812_setled      (int index, uint8_t r, uint8_t g, uint8_t b);
+void ws2812_setled_all  (uint8_t r, uint8_t g, uint8_t b);
+#endif
 
 void ws2812_setleds     (LED_TYPE *ledarray, uint16_t number_of_leds);
 void ws2812_setleds_pin (LED_TYPE *ledarray, uint16_t number_of_leds,uint8_t pinmask);

keyboards/canoe/info.json

@@ -2,7 +2,7 @@
   "keyboard_name": "Canoe",
   "maintainer": "qmk",
   "url": "",
-  "height": 8,
+  "height": 6,
   "width": 15,
   "layouts": {
     "LAYOUT_iso": {

keyboards/clueboard/card/info.json

@@ -4,7 +4,7 @@
   "url": "",
   "maintainer": "skullydazed",
   "width": 10,
-  "height": 7,
+  "height": 8,
   "layouts": {
     "LAYOUT": {
       "layout": [

keyboards/crkbd/info.json

@@ -3,7 +3,7 @@
   "url": "",
   "maintainer": "qmk",
   "width": 15,
-  "height": 4.5,
+  "height": 4.7,
   "layouts": {
     "LAYOUT": {
       "layout": [

keyboards/ergodone/info.json

@@ -1,8 +1,8 @@
 {
     "keyboard_name": "Ergodone",
     "maintainer": "Yu He",
-    "width": 19.5,
-    "height": 9.375,
+    "width": 17,
+    "height": 8,
 
     "layouts": {
       "LAYOUT_ergodox": {

keyboards/ergodox_ez/info.json

@@ -2,8 +2,8 @@
     "keyboard_name": "ErgoDox EZ",
     "url": "ergodox-ez.com",
     "maintainer": "erez",
-    "width": 19.5,
-    "height": 9.375,
+    "width": 17,
+    "height": 8,
 
     "layouts": {
         "LAYOUT_ergodox": {

keyboards/ergodox_infinity/info.json

@@ -1,7 +1,7 @@
 {
     "keyboard_name": "Infinity Ergodox",
-    "width": 19.5,
-    "height": 9.375,
+    "width": 17,
+    "height": 8,
     "layouts": {
       "LAYOUT_ergodox": {
         "layout": [

keyboards/georgi/config.h

@@ -23,15 +23,13 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 /* Defaults */
 
-#define VERSION "Alpha 01: Ted "
+#define VERSION "v1.0: Stenoknight"
 #define VERBOSE
 
 #define FORCE_NKRO
-#define NO_ACTION_MACRO
 #define NO_ACTION_FUNCTION
-#define NO_DEBUG
 #define NO_ACTION_ONESHOT
-#define NO_ACTION_FUNCTION
+#define NO_ACTION_MACRO
 
 /* USB Device descriptor parameter */
 #define VENDOR_ID       0xFEED

keyboards/georgi/keymaps/default/keymap.c

@@ -1,4 +1,4 @@
-/* 
+/*
  * Good on you for modifying your layout, this is the most nonQMK layout you will come across
  * There are three modes, Steno (the default), QWERTY (Toggleable) and a Momentary symbol layer
  *
@@ -15,215 +15,224 @@
 #include "keymap_steno.h"
 #define IGNORE_MOD_TAP_INTERRUPT
 
-int getKeymapCount(void);
-
 // Proper Layers
 #define FUNCT   (LSD | LK | LP | LH)
 #define MEDIA   (LSD | LK | LW | LR)
 #define MOVE    (ST1 | ST2)
 
+// QMK Layers
+#define STENO_LAYER   0
+#define GAMING        1
+#define GAMING_2      2
+
 /* Keyboard Layout
  * ,---------------------------------.    ,------------------------------.
  * | FN  | LSU | LFT | LP | LH | ST1 |    | ST3 | RF | RP | RL | RT | RD |
  * |-----+-----+-----+----+----|-----|    |-----|----+----+----+----+----|
- * | PWR | LSD | LK  | LW | LR | ST2 |    | ST4 | RR | RG | RB | RS | RZ |
+ * | PWR | LSD | LK  | LW | LR | ST2 |    | ST4 | RR | BB | RG | RS | RZ |
  * `---------------------------------'    `------------------------------'
  *                   ,---------------,    .---------------.
- *                   | NUM | LA | LO |    | RE | RU | NUM |
+ *                   | LNO | LA | LO |    | RE | RU | RNO |
  *                   `---------------'    `---------------'
  */
 
-// YOU MUST ORDER THIS!
-// P   Will return from processing on the first match it finds. Therefore
-// PJ  Will run the requested action, remove the matched chord and continue 
-//
-// First any chords that would conflict with PJs need to be checked, then PJs, lastly Ps.
-// For all chords should be ordered by length in their section!
+// Note: You can only use basic keycodes here!
+// P() is just a wrapper to make your life easier.
 //
 // http://docs.gboards.ca
-bool processQwerty(void) {
-	// Place P's that would be trashed by PJ's here
-	P( RT  | RS  | RD  | RZ | NUM,		SEND_STRING(VERSION); SEND_STRING(__DATE__));
-	P( NUM | LA  | LO  | RE | RU,		SEND(KC_MPLY));
-	P( ST1 | ST2 | ST3 | ST4,			SEND(KC_BSPC));
+uint32_t processQwerty(bool lookup) {
+    // Specials
+    P( RT  | RS  | RD  | RZ | LNO,        SEND_STRING(VERSION); SEND_STRING(__DATE__));
+    P( LNO | RNO | LA  | LO | RE | RU,    SEND(KC_MPLY));
+    P( LFT | LK  | LP  | LW,              REPEAT());
+    P( ST1 | ST2 | LW  | ST4,             SEND(KC_BSPC));
 
-	// Thumb Chords
-	P(  LA  | LO  | RE  | RU,			SEND(KC_CAPS));
-	P(  LA  | RU,						SEND(KC_ESC));
-	PJ( LO  | RE,						SEND(KC_LCTL));
-	PJ( NUM | LA | RU,					SEND(KC_LCTL); SEND(KC_LSFT));
-	PJ( NUM | LA | RE,					SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_LALT));
-	
-	// Mods 
-	PJ( RT | RD | RS | RZ,				SEND(KC_LGUI));
-	PJ( RT | RD,						SEND(KC_LCTL));
-	PJ( RS | RZ,						SEND(KC_LALT));
-	PJ( LA | NUM,						SEND(KC_LCTL));
-	PJ( LA | LO,						SEND(KC_LALT));
-	PJ( LO,								SEND(KC_LSFT));
+    // Mouse Keys
+    P( LO  | LSD | LK,    CLICK_MOUSE(KC_MS_BTN2));
+    P( LO  | LR  | LW,    CLICK_MOUSE(KC_MS_BTN1));
 
-	// Function Layer 
-	P( FUNCT | RF | RR,					SEND(KC_F5));
-	P( FUNCT | RP | RB,					SEND(KC_F6));
-	P( FUNCT | RL | RG,					SEND(KC_F7));
-	P( FUNCT | RT | RS,					SEND(KC_F8));
-	P( FUNCT | RF,						SEND(KC_F1));
-	P( FUNCT | RP,						SEND(KC_F2));
-	P( FUNCT | RL,						SEND(KC_F3));
-	P( FUNCT | RT,						SEND(KC_F4));
-	P( FUNCT | RR,						SEND(KC_F9));
-	P( FUNCT | RG,						SEND(KC_F10));
-	P( FUNCT | RB,						SEND(KC_F11));
-	P( FUNCT | RS,						SEND(KC_F12));
+    // Thumb Chords
+    P( LA  | LO  | RE  | RU,    SEND(KC_CAPS));
+    P( LA  | RU,                SEND(KC_ESC));
+    P( LO  | RE,                SEND(KC_LCTL));
+    P( LNO | RNO | LA | RU,     SEND(KC_LCTL); SEND(KC_LSFT));
+    P( LNO | LA  | RE,          SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_LALT));
 
-	// Movement Layer
-	P( MOVE | RF,						SEND(KC_LEFT));
-	P( MOVE | RP,						SEND(KC_DOWN));
-	P( MOVE | RL,						SEND(KC_UP));
-	P( MOVE | RT,						SEND(KC_RIGHT));
-	P( MOVE | ST3,						SEND(KC_PGUP));
-	P( MOVE | ST4,						SEND(KC_PGDN));
+    // Mods
+    P( RT | RD   | RS | RZ,    SEND(KC_LGUI));
+    P( RT | RD,                SEND(KC_LCTL));
+    P( RS | RZ,                SEND(KC_LALT));
+    P( LA | LNO,               SEND(KC_LCTL));
+    P( LA | LO,                SEND(KC_LALT));
+    P( LO,                     SEND(KC_LSFT));
 
-	// Media Layer
-	P( MEDIA | RF,						SEND(KC_MPRV));
-	P( MEDIA | RP,						SEND(KC_MPLY));
-	P( MEDIA | RL,						SEND(KC_MPLY));
-	P( MEDIA | RT,						SEND(KC_MNXT));
-	P( MEDIA | RD,						SEND(KC_VOLU));
-	P( MEDIA | RZ,						SEND(KC_VOLD));
-	P( MEDIA | RS,						SEND(KC_MUTE));
+    // Function Layer
+    P( FUNCT | RF | RR,    SEND(KC_F5));
+    P( FUNCT | RP | RB,    SEND(KC_F6));
+    P( FUNCT | RL | RG,    SEND(KC_F7));
+    P( FUNCT | RT | RS,    SEND(KC_F8));
+    P( FUNCT | RF,         SEND(KC_F1));
+    P( FUNCT | RP,         SEND(KC_F2));
+    P( FUNCT | RL,         SEND(KC_F3));
+    P( FUNCT | RT,         SEND(KC_F4));
+    P( FUNCT | RR,         SEND(KC_F9));
+    P( FUNCT | RG,         SEND(KC_F10));
+    P( FUNCT | RB,         SEND(KC_F11));
+    P( FUNCT | RS,         SEND(KC_F12));
 
-	// Mouse Keys
-	P( LP | LH,							clickMouse(KC_MS_BTN1));
-	P( LW | LR,							clickMouse(KC_MS_BTN2));
-	
-	// Number Row
-	P( NUM | LSU,						SEND(KC_1));
-	P( NUM | LFT,						SEND(KC_2));
-	P( NUM | LP,						SEND(KC_3));
-	P( NUM | LH,						SEND(KC_4));
-	P( NUM | ST1,						SEND(KC_5));
-	P( NUM | ST3,						SEND(KC_6));
-	P( NUM | RF,						SEND(KC_7));
-	P( NUM | RP,						SEND(KC_8));
-	P( NUM | RL,						SEND(KC_9));
-	P( NUM | RT,						SEND(KC_0));
-	P( NUM | LA,						SEND(KC_5));
-	P( NUM | RT,						SEND(KC_0));
-	
-	// Specials
-	P( LA | NUM,						SEND(KC_ESC));
-	P( RU | NUM,						SEND(KC_TAB));
-	P( RE | RU,							SEND(KC_BSPC));
-	P( RD | RZ,							SEND(KC_ENT));
-	P( RE,								SEND(KC_ENT));
-	P( RD,								SEND(KC_BSPC));	
-	P( NUM,								SEND(KC_BSPC));
-	P( LA,								SEND(KC_SPC));
-	P( RU,								SEND(KC_SPC));
-	P( RZ,								SEND(KC_ESC));
+    // Movement Layer
+    P( MOVE | RF,     SEND(KC_LEFT));
+    P( MOVE | RP,     SEND(KC_DOWN));
+    P( MOVE | RL,     SEND(KC_UP));
+    P( MOVE | RT,     SEND(KC_RIGHT));
+    P( MOVE | ST3,    SEND(KC_PGUP));
+    P( MOVE | ST4,    SEND(KC_PGDN));
 
-	// Letters
-	P( LSU | LSD,						SEND(KC_A));
-	P( LFT | LK,						SEND(KC_S));
-	P( LP  | LW,						SEND(KC_D));
-	P( LH  | LR,						SEND(KC_F));
-	P( ST1 | ST2,						SEND(KC_G));
-	P( ST3 | ST4,						SEND(KC_H));
-	P( RF  | RR,						SEND(KC_J));
-	P( RT  | RS,						SEND(KC_SCLN))
-	P( RG  | RL,						SEND(KC_L));
-	P( RP  | RB,						SEND(KC_K));
-	P( LSU,								SEND(KC_Q));
-	P( LSD,								SEND(KC_Z));
-	P( LFT,								SEND(KC_W));
-	P( LK,								SEND(KC_X));
-	P( LP,								SEND(KC_E));
-	P( LW,								SEND(KC_C));
-	P( LH,								SEND(KC_R));
-	P( LR,								SEND(KC_V));
-	P( ST1,								SEND(KC_T));
-	P( ST2,								SEND(KC_B));
-	P( ST3,								SEND(KC_Y));
-	P( ST4,								SEND(KC_N));
-	P( RF,								SEND(KC_U));
-	P( RR,								SEND(KC_M));
-	P( RP,								SEND(KC_I));
-	P( RB,								SEND(KC_COMM));
-	P( RL,								SEND(KC_O));
-	P( RG,								SEND(KC_DOT));
-	P( RT,								SEND(KC_P));
-	P( RS,								SEND(KC_SLSH));
+    // Media Layer
+    P( MEDIA | RF,    SEND(KC_MPRV));
+    P( MEDIA | RP,    SEND(KC_MPLY));
+    P( MEDIA | RL,    SEND(KC_MPLY));
+    P( MEDIA | RT,    SEND(KC_MNXT));
+    P( MEDIA | RD,    SEND(KC_VOLU));
+    P( MEDIA | RZ,    SEND(KC_VOLD));
+    P( MEDIA | RS,    SEND(KC_MUTE));
 
-	// Symbols and Numbers
-	P( PWR | RE | RU,					SEND(KC_ENT));
-	P( PWR | LA | LO,					SEND(KC_SPC));
-	P( PWR | LP | LW,					SEND(KC_LSFT); SEND(KC_9));			// (
-	P( PWR | LH | LR,					SEND(KC_LSFT); SEND(KC_0));			// )
-	P( PWR | ST1 | ST2,					SEND(KC_GRV));						// `
-	P( PWR | RD | RZ,					SEND(KC_ESC));							
-	P( PWR | LSU | LSD,					SEND(KC_LSFT); SEND(KC_3));			// #
-	P( PWR | LFT | LK,					SEND(KC_LSFT); SEND(KC_4));			// $
-	P( PWR | LSU,						SEND(KC_LSFT); SEND(KC_1));			// !
-	P( PWR | LSD,						SEND(KC_LSFT); SEND(KC_5));			// %
-	P( PWR | LFT,						SEND(KC_LSFT); SEND(KC_2));			// @
-	P( PWR | LK,						SEND(KC_LSFT); SEND(KC_6));			// ^
-	P( PWR | LP,						SEND(KC_LSFT); SEND(KC_LBRC));		// {
-	P( PWR | LW,						SEND(KC_LBRC));
-	P( PWR | LH,						SEND(KC_LSFT); SEND(KC_RBRC));		// }
-	P( PWR | LR,						SEND(KC_RBRC));
-	P( PWR | ST1,						SEND(KC_LSFT); SEND(KC_BSLS));		// |
-	P( PWR | ST2,						SEND(KC_LSFT); SEND(KC_GRV));		// ~
-	P( PWR | ST3,						SEND(KC_QUOT));
-	P( PWR | ST4,						SEND(KC_LSFT); SEND(KC_QUOT));		// "
-	P( PWR | RF,						SEND(KC_KP_PLUS));
-	P( PWR | RR,						SEND(KC_LSFT); SEND(KC_7));			// &
-	P( PWR | RP,						SEND(KC_MINS));
-	P( PWR | RB,						SEND(KC_EQL));
-	P( PWR | RL,						SEND(KC_SLSH));
-	P( PWR | RG,						SEND(KC_COMM));
-	P( PWR | RT,						SEND(KC_PAST));
-	P( PWR | RS,						SEND(KC_DOT));
-	P( PWR | RD,						SEND(KC_TAB));
-	P( PWR | LA,						SEND(KC_SCLN));
-	P( PWR | LO,						SEND(KC_SLSH));
-	P( PWR | RE,						SEND(KC_SCLN));
-	P( PWR | RU,						SEND(KC_SLSH));
+    // Number Row, Left
+    P( LNO | LSU,    SEND(KC_1));
+    P( LNO | LFT,    SEND(KC_2));
+    P( LNO | LP,     SEND(KC_3));
+    P( LNO | LH,     SEND(KC_4));
+    P( LNO | ST1,    SEND(KC_5));
+    P( LNO | ST3,    SEND(KC_6));
+    P( LNO | RF,     SEND(KC_7));
+    P( LNO | RP,     SEND(KC_8));
+    P( LNO | RL,     SEND(KC_9));
+    P( LNO | RT,     SEND(KC_0));
 
+    // Number Row, Right
+    P( RNO | LSU,    SEND(KC_1));
+    P( RNO | LFT,    SEND(KC_2));
+    P( RNO | LP,     SEND(KC_3));
+    P( RNO | LH,     SEND(KC_4));
+    P( RNO | ST1,    SEND(KC_5));
+    P( RNO | ST3,    SEND(KC_6));
+    P( RNO | RF,     SEND(KC_7));
+    P( RNO | RP,     SEND(KC_8));
+    P( RNO | RL,     SEND(KC_9));
+    P( RNO | RT,     SEND(KC_0));
+    P( RNO | LA,     SEND(KC_5));
 
-	// If we make here, send as a steno chord
-	// If plover is running we can hook that host side
-	return false;
+    // Specials
+    P( RU | RNO,    SEND(KC_TAB));
+    P( RE | RU,     SEND(KC_BSPC));
+    P( RD | RZ,     SEND(KC_ENT));
+    P( RE,          SEND(KC_ENT));
+    P( RD,          SEND(KC_BSPC));
+    P( LNO,         SEND(KC_BSPC));
+    P( RNO,         SEND(KC_BSPC));
+    P( LA,          SEND(KC_SPC));
+    P( RU,          SEND(KC_SPC));
+    P( RZ,          SEND(KC_ESC));
+
+    // Symbols and Numbers
+    P( PWR | RE | RU,      SEND(KC_ENT));
+    P( PWR | LA | LO,      SEND(KC_SPC));
+    P( PWR | LP | LW,      SEND(KC_LSFT); SEND(KC_9));       // (
+    P( PWR | LH | LR,      SEND(KC_LSFT); SEND(KC_0));       // )
+    P( PWR | ST1 | ST2,    SEND(KC_GRV));                    // `
+    P( PWR | RD | RZ,      SEND(KC_ESC));
+    P( PWR | LSU | LSD,    SEND(KC_LSFT); SEND(KC_3));       // #
+    P( PWR | LFT | LK,     SEND(KC_LSFT); SEND(KC_4));       // $
+    P( PWR | LSU,          SEND(KC_LSFT); SEND(KC_1));       // !
+    P( PWR | LSD,          SEND(KC_LSFT); SEND(KC_5));       // %
+    P( PWR | LFT,          SEND(KC_LSFT); SEND(KC_2));       // @
+    P( PWR | LK,           SEND(KC_LSFT); SEND(KC_6));       // ^
+    P( PWR | LP,           SEND(KC_LSFT); SEND(KC_LBRC));    // {
+    P( PWR | LW,           SEND(KC_LBRC));
+    P( PWR | LH,           SEND(KC_LSFT); SEND(KC_RBRC));    // }
+    P( PWR | LR,           SEND(KC_RBRC));
+    P( PWR | ST1,          SEND(KC_LSFT); SEND(KC_BSLS));    // |
+    P( PWR | ST2,          SEND(KC_LSFT); SEND(KC_GRV));     // ~
+    P( PWR | ST3,          SEND(KC_QUOT));
+    P( PWR | ST4,          SEND(KC_LSFT); SEND(KC_QUOT));    // "
+    P( PWR | RF,           SEND(KC_KP_PLUS));
+    P( PWR | RR,           SEND(KC_LSFT); SEND(KC_7));       // &
+    P( PWR | RP,           SEND(KC_MINS));
+    P( PWR | RB,           SEND(KC_EQL));
+    P( PWR | RL,           SEND(KC_SLSH));
+    P( PWR | RG,           SEND(KC_COMM));
+    P( PWR | RT,           SEND(KC_PAST));
+    P( PWR | RS,           SEND(KC_DOT));
+    P( PWR | RD,           SEND(KC_TAB));
+    P( PWR | LA,           SEND(KC_LSFT));
+    P( PWR | LO,           SEND(KC_SLSH));
+    P( PWR | RE,           SEND(KC_SCLN));
+    P( PWR | RU,           SEND(KC_BSLS));
+    P( PWR | LNO,          SEND(KC_BSLS));
+
+    // Letters
+    P( LSU | LSD,    SEND(KC_A));
+    P( LFT | LK,     SEND(KC_S));
+    P( LP  | LW,     SEND(KC_D));
+    P( LH  | LR,     SEND(KC_F));
+    P( ST1 | ST2,    SEND(KC_G));
+    P( ST3 | ST4,    SEND(KC_H));
+    P( RF  | RR,     SEND(KC_J));
+    P( RT  | RS,     SEND(KC_SCLN));
+    P( RG  | RL,     SEND(KC_L));
+    P( RP  | RB,     SEND(KC_K));
+    P( LSU,          SEND(KC_Q));
+    P( LSD,          SEND(KC_Z));
+    P( LFT,          SEND(KC_W));
+    P( LK,           SEND(KC_X));
+    P( LP,           SEND(KC_E));
+    P( LW,           SEND(KC_C));
+    P( LH,           SEND(KC_R));
+    P( LR,           SEND(KC_V));
+    P( ST1,          SEND(KC_T));
+    P( ST2,          SEND(KC_B));
+    P( ST3,          SEND(KC_Y));
+    P( ST4,          SEND(KC_N));
+    P( RF,           SEND(KC_U));
+    P( RR,           SEND(KC_M));
+    P( RP,           SEND(KC_I));
+    P( RB,           SEND(KC_COMM));
+    P( RL,           SEND(KC_O));
+    P( RG,           SEND(KC_DOT));
+    P( RT,           SEND(KC_P));
+    P( RS,           SEND(KC_SLSH));
+    P( RNO,          SEND(KC_BSPC));
+    P( LNO,          SEND(KC_BSPC));
+
+    return 0;
 }
 
-#define STENO_LAYER  	0
-#define GAMING			1
-#define GAMING_2		2
-
 // "Layers"
 // Steno layer should be first in your map.
-// When PWR | FN | RR | RG | RB | RS is pressed, the layer is increased to the next map. You must return to STENO_LAYER at the end.
-// If you have only a single layer, you must set SINGLELAYER = yes in your rules.mk, otherwise you may experince undefined behaviour
+// When PWR | FN | ST3 | ST4 is pressed, the layer is increased to the next map. You must return to STENO_LAYER at the end.
+// If you need more space for chords, remove the two gaming layers.
+// Note: If using NO_ACTION_TAPPING, LT will not work!
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-// Main layer, everything goes through here
-[STENO_LAYER] = LAYOUT_georgi(  
-STN_FN,  STN_S1, STN_TL, STN_PL, STN_HL, STN_ST1,       STN_ST3, STN_FR, STN_PR, STN_LR, STN_TR, STN_DR,
-STN_PWR, STN_S2, STN_KL, STN_WL, STN_RL, STN_ST2,       STN_ST4, STN_RR, STN_BR, STN_GR, STN_SR, STN_ZR,
-						 STN_N1, STN_A,  STN_O,			STN_E,   STN_U,  STN_N1)
-,
-// Gaming layer with Numpad, Very limited
-[GAMING] = LAYOUT_georgi(  
-KC_LSFT, KC_Q, KC_W, KC_E, KC_R, KC_T,       KC_Y,   KC_U, KC_I, KC_O, KC_P,    KC_ENT,
-KC_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G,       KC_H,   KC_J, KC_K, KC_L, KC_SCLN, KC_DQUO,
-KC_LALT, KC_SPC, LT(GAMING_2, KC_ENT),	     KC_DEL, KC_ASTR,  TO(STENO_LAYER)), 
+    // Main layer, everything goes through here
+    [STENO_LAYER] = LAYOUT_georgi(
+        STN_FN,  STN_S1,  STN_TL,  STN_PL,  STN_HL,  STN_ST1,       STN_ST3, STN_FR,  STN_PR,  STN_LR,  STN_TR,  STN_DR,
+        STN_PWR, STN_S2,  STN_KL,  STN_WL,  STN_RL,  STN_ST2,       STN_ST4, STN_RR,  STN_BR,  STN_GR,  STN_SR,  STN_ZR,
+                                   STN_N1,  STN_A,   STN_O,         STN_E,   STN_U,   STN_N7
+    ),
+    // Gaming layer with Numpad, Very limited
+    [GAMING] = LAYOUT_georgi(
+        KC_LSFT, KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,                       KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_ENT,
+        KC_LCTL, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,                       KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_DQUO,
+                                   KC_LALT, KC_SPC,  LT(GAMING_2, KC_ENT),       KC_DEL,  KC_ASTR, TO(STENO_LAYER)
+    ),
 
-[GAMING_2] = LAYOUT_georgi(  
-KC_LSFT, KC_1, KC_2, KC_3, KC_4, KC_5,       KC_6, KC_7, KC_8,  KC_9,  KC_0, KC_MINS,
-KC_LCTL, KC_Z, KC_X, KC_C, KC_V, KC_B,       KC_N, KC_M, KC_LT, KC_GT, KC_QUES, KC_RSFT,
-			  KC_LALT, KC_SPC, KC_ENT,	     KC_DEL, KC_ASTR,  TO(STENO_LAYER))
-}; 
+    [GAMING_2] = LAYOUT_georgi(
+        KC_LSFT, KC_1,    KC_2,    KC_3,    KC_4,    KC_5,          KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS,
+        KC_LCTL, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,          KC_N,    KC_M,    KC_LT,   KC_GT,   KC_QUES, KC_RSFT,
+                                   KC_LALT, KC_SPC,  KC_ENT,        KC_DEL,  KC_ASTR, TO(STENO_LAYER)
+    )
+};
 
-int getKeymapCount(void) {
-	return sizeof(keymaps)/sizeof(keymaps[0]);
-}
+// Don't fuck with this, thanks.
+size_t keymapsCount  = sizeof(keymaps)/sizeof(keymaps[0]);

keyboards/georgi/keymaps/default/rules.mk

@@ -1,18 +1,23 @@
 #----------------------------------------------------------------------------
-# make georgi:extrakey:dfu
+# make georgi:default:dfu
 # Make sure you have dfu-programmer installed!
 #----------------------------------------------------------------------------
 
-#Debug options
+NO_REPEAT				 = no
 VERBOSE					 = yes
-CONSOLE_ENABLE			 = yes
-DEBUG_MATRIX_SCAN_RATE   = no
-DEBUG_MATRIX			 = no
 KEYBOARD_SHARED_EP       = yes
 CUSTOM_MATRIX			 = yes
-MOUSEKEY_ENABLE			 = yes
-SINGLE_LAYER			 = no
 
+#Firmware reduction options
+MOUSEKEY_ENABLE			 = yes 		# 1500 bytes
+NO_TAPPING				 = no 	    # 2000 bytes
+NO_PRINT				 = yes		
+
+#Debug options
+CONSOLE_ENABLE			 = no
+DEBUG_MATRIX_SCAN_RATE   = no
+DEBUG_MATRIX			 = no
+ONLY_QWERTY				 = no
 
 # A bunch of stuff that you shouldn't touch unless you
 # know what you're doing.
@@ -22,6 +27,15 @@ SRC += matrix.c i2c_master.c
 ifeq ($(strip $(DEBUG_MATRIX)), yes)
     OPT_DEFS += -DDEBUG_MATRIX
 endif
-ifeq ($(strip $(SINGLE_LAYER)), yes)
-    OPT_DEFS += -DSINGLE_LAYER
+ifeq ($(strip $(NO_REPEAT)), yes)
+    OPT_DEFS += -DNO_REPEAT
+endif
+ifeq ($(strip $(NO_PRINT)), yes)
+    OPT_DEFS += -DNO_PRINT -DNO_DEBUG
+endif
+ifeq ($(strip $(ONLY_QWERTY)), yes)
+    OPT_DEFS += -DONLYQWERTY
+endif
+ifeq ($(strip $(NO_TAPPING)), yes)
+    OPT_DEFS += -DNO_ACTION_TAPPING
 endif

keyboards/georgi/keymaps/minimal/keymap.c

@@ -0,0 +1,223 @@
+/*
+ * Good on you for modifying your layout, this is the most nonQMK layout you will come across
+ * There are three modes, Steno (the default), QWERTY (Toggleable) and a Momentary symbol layer
+ *
+ * Don't modify the steno layer directly, instead add chords using the keycodes and macros
+ * from sten.h to the layout you want to modify.
+ *
+ * Observe the comment above processQWERTY!
+ *
+ * http://docs.gboards.ca
+ */
+
+#include QMK_KEYBOARD_H
+#include "sten.h"
+#include "keymap_steno.h"
+#define IGNORE_MOD_TAP_INTERRUPT
+
+// Proper Layers
+#define FUNCT   (LSD | LK | LP | LH)
+#define MEDIA   (LSD | LK | LW | LR)
+#define MOVE    (ST1 | ST2)
+
+// QMK Layers
+#define STENO_LAYER   0
+
+/* Keyboard Layout
+ * ,---------------------------------.    ,------------------------------.
+ * | FN  | LSU | LFT | LP | LH | ST1 |    | ST3 | RF | RP | RL | RT | RD |
+ * |-----+-----+-----+----+----|-----|    |-----|----+----+----+----+----|
+ * | PWR | LSD | LK  | LW | LR | ST2 |    | ST4 | RR | BB | RG | RS | RZ |
+ * `---------------------------------'    `------------------------------'
+ *                   ,---------------,    .---------------.
+ *                   | LNO | LA | LO |    | RE | RU | RNO |
+ *                   `---------------'    `---------------'
+ */
+
+// Note: You can only use basic keycodes here!
+// P() is just a wrapper to make your life easier.
+//
+// http://docs.gboards.ca
+uint32_t processQwerty(bool lookup) {
+    // Specials
+    P( RT  | RS  | RD  | RZ | LNO,        SEND_STRING(VERSION); SEND_STRING(__DATE__));
+    P( LNO | RNO | LA  | LO | RE | RU,    SEND(KC_MPLY));
+    P( LFT | LK  | LP  | LW,              REPEAT());
+    P( ST1 | ST2 | LW  | ST4,             SEND(KC_BSPC));
+
+    // Mouse Keys
+    P( LO  | LSD | LK,    CLICK_MOUSE(KC_MS_BTN2));
+    P( LO  | LR  | LW,    CLICK_MOUSE(KC_MS_BTN1));
+
+    // Thumb Chords
+    P( LA  | LO  | RE  | RU,    SEND(KC_CAPS));
+    P( LA  | RU,                SEND(KC_ESC));
+    P( LO  | RE,                SEND(KC_LCTL));
+    P( LNO | RNO | LA | RU,     SEND(KC_LCTL); SEND(KC_LSFT));
+    P( LNO | LA  | RE,          SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_LALT));
+
+    // Mods
+    P( RT | RD   | RS | RZ,    SEND(KC_LGUI));
+    P( RT | RD,                SEND(KC_LCTL));
+    P( RS | RZ,                SEND(KC_LALT));
+    P( LA | LNO,               SEND(KC_LCTL));
+    P( LA | LO,                SEND(KC_LALT));
+    P( LO,                     SEND(KC_LSFT));
+
+    // Function Layer
+    P( FUNCT | RF | RR,    SEND(KC_F5));
+    P( FUNCT | RP | RB,    SEND(KC_F6));
+    P( FUNCT | RL | RG,    SEND(KC_F7));
+    P( FUNCT | RT | RS,    SEND(KC_F8));
+    P( FUNCT | RF,         SEND(KC_F1));
+    P( FUNCT | RP,         SEND(KC_F2));
+    P( FUNCT | RL,         SEND(KC_F3));
+    P( FUNCT | RT,         SEND(KC_F4));
+    P( FUNCT | RR,         SEND(KC_F9));
+    P( FUNCT | RG,         SEND(KC_F10));
+    P( FUNCT | RB,         SEND(KC_F11));
+    P( FUNCT | RS,         SEND(KC_F12));
+
+    // Movement Layer
+    P( MOVE | RF,     SEND(KC_LEFT));
+    P( MOVE | RP,     SEND(KC_DOWN));
+    P( MOVE | RL,     SEND(KC_UP));
+    P( MOVE | RT,     SEND(KC_RIGHT));
+    P( MOVE | ST3,    SEND(KC_PGUP));
+    P( MOVE | ST4,    SEND(KC_PGDN));
+
+    // Media Layer
+    P( MEDIA | RF,    SEND(KC_MPRV));
+    P( MEDIA | RP,    SEND(KC_MPLY));
+    P( MEDIA | RL,    SEND(KC_MPLY));
+    P( MEDIA | RT,    SEND(KC_MNXT));
+    P( MEDIA | RD,    SEND(KC_VOLU));
+    P( MEDIA | RZ,    SEND(KC_VOLD));
+    P( MEDIA | RS,    SEND(KC_MUTE));
+
+    // Number Row, Left
+    P( LNO | LSU,    SEND(KC_1));
+    P( LNO | LFT,    SEND(KC_2));
+    P( LNO | LP,     SEND(KC_3));
+    P( LNO | LH,     SEND(KC_4));
+    P( LNO | ST1,    SEND(KC_5));
+    P( LNO | ST3,    SEND(KC_6));
+    P( LNO | RF,     SEND(KC_7));
+    P( LNO | RP,     SEND(KC_8));
+    P( LNO | RL,     SEND(KC_9));
+    P( LNO | RT,     SEND(KC_0));
+
+    // Number Row, Right
+    P( RNO | LSU,    SEND(KC_1));
+    P( RNO | LFT,    SEND(KC_2));
+    P( RNO | LP,     SEND(KC_3));
+    P( RNO | LH,     SEND(KC_4));
+    P( RNO | ST1,    SEND(KC_5));
+    P( RNO | ST3,    SEND(KC_6));
+    P( RNO | RF,     SEND(KC_7));
+    P( RNO | RP,     SEND(KC_8));
+    P( RNO | RL,     SEND(KC_9));
+    P( RNO | RT,     SEND(KC_0));
+    P( RNO | LA,     SEND(KC_5));
+
+    // Specials
+    P( RU | RNO,    SEND(KC_TAB));
+    P( RE | RU,     SEND(KC_BSPC));
+    P( RD | RZ,     SEND(KC_ENT));
+    P( RE,          SEND(KC_ENT));
+    P( RD,          SEND(KC_BSPC));
+    P( LNO,         SEND(KC_BSPC));
+    P( RNO,         SEND(KC_BSPC));
+    P( LA,          SEND(KC_SPC));
+    P( RU,          SEND(KC_SPC));
+    P( RZ,          SEND(KC_ESC));
+
+    // Symbols and Numbers
+    P( PWR | RE | RU,      SEND(KC_ENT));
+    P( PWR | LA | LO,      SEND(KC_SPC));
+    P( PWR | LP | LW,      SEND(KC_LSFT); SEND(KC_9));       // (
+    P( PWR | LH | LR,      SEND(KC_LSFT); SEND(KC_0));       // )
+    P( PWR | ST1 | ST2,    SEND(KC_GRV));                    // `
+    P( PWR | RD | RZ,      SEND(KC_ESC));
+    P( PWR | LSU | LSD,    SEND(KC_LSFT); SEND(KC_3));       // #
+    P( PWR | LFT | LK,     SEND(KC_LSFT); SEND(KC_4));       // $
+    P( PWR | LSU,          SEND(KC_LSFT); SEND(KC_1));       // !
+    P( PWR | LSD,          SEND(KC_LSFT); SEND(KC_5));       // %
+    P( PWR | LFT,          SEND(KC_LSFT); SEND(KC_2));       // @
+    P( PWR | LK,           SEND(KC_LSFT); SEND(KC_6));       // ^
+    P( PWR | LP,           SEND(KC_LSFT); SEND(KC_LBRC));    // {
+    P( PWR | LW,           SEND(KC_LBRC));
+    P( PWR | LH,           SEND(KC_LSFT); SEND(KC_RBRC));    // }
+    P( PWR | LR,           SEND(KC_RBRC));
+    P( PWR | ST1,          SEND(KC_LSFT); SEND(KC_BSLS));    // |
+    P( PWR | ST2,          SEND(KC_LSFT); SEND(KC_GRV));     // ~
+    P( PWR | ST3,          SEND(KC_QUOT));
+    P( PWR | ST4,          SEND(KC_LSFT); SEND(KC_QUOT));    // "
+    P( PWR | RF,           SEND(KC_KP_PLUS));
+    P( PWR | RR,           SEND(KC_LSFT); SEND(KC_7));       // &
+    P( PWR | RP,           SEND(KC_MINS));
+    P( PWR | RB,           SEND(KC_EQL));
+    P( PWR | RL,           SEND(KC_SLSH));
+    P( PWR | RG,           SEND(KC_COMM));
+    P( PWR | RT,           SEND(KC_PAST));
+    P( PWR | RS,           SEND(KC_DOT));
+    P( PWR | RD,           SEND(KC_TAB));
+    P( PWR | LA,           SEND(KC_LSFT));
+    P( PWR | LO,           SEND(KC_SLSH));
+    P( PWR | RE,           SEND(KC_SCLN));
+    P( PWR | RU,           SEND(KC_BSLS));
+    P( PWR | LNO,          SEND(KC_BSLS));
+
+    // Letters
+    P( LSU | LSD,    SEND(KC_A));
+    P( LFT | LK,     SEND(KC_S));
+    P( LP  | LW,     SEND(KC_D));
+    P( LH  | LR,     SEND(KC_F));
+    P( ST1 | ST2,    SEND(KC_G));
+    P( ST3 | ST4,    SEND(KC_H));
+    P( RF  | RR,     SEND(KC_J));
+    P( RT  | RS,     SEND(KC_SCLN));
+    P( RG  | RL,     SEND(KC_L));
+    P( RP  | RB,     SEND(KC_K));
+    P( LSU,          SEND(KC_Q));
+    P( LSD,          SEND(KC_Z));
+    P( LFT,          SEND(KC_W));
+    P( LK,           SEND(KC_X));
+    P( LP,           SEND(KC_E));
+    P( LW,           SEND(KC_C));
+    P( LH,           SEND(KC_R));
+    P( LR,           SEND(KC_V));
+    P( ST1,          SEND(KC_T));
+    P( ST2,          SEND(KC_B));
+    P( ST3,          SEND(KC_Y));
+    P( ST4,          SEND(KC_N));
+    P( RF,           SEND(KC_U));
+    P( RR,           SEND(KC_M));
+    P( RP,           SEND(KC_I));
+    P( RB,           SEND(KC_COMM));
+    P( RL,           SEND(KC_O));
+    P( RG,           SEND(KC_DOT));
+    P( RT,           SEND(KC_P));
+    P( RS,           SEND(KC_SLSH));
+    P( RNO,          SEND(KC_BSPC));
+    P( LNO,          SEND(KC_BSPC));
+
+    return 0;
+}
+
+// "Layers"
+// Steno layer should be first in your map.
+// When PWR | FN | ST3 | ST4 is pressed, the layer is increased to the next map. You must return to STENO_LAYER at the end.
+// If you need more space for chords, remove the two gaming layers.
+// Note: If using NO_ACTION_TAPPING, LT will not work!
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    // Main layer, everything goes through here
+    [STENO_LAYER] = LAYOUT_georgi(
+    STN_FN,  STN_S1,  STN_TL,  STN_PL,  STN_HL,  STN_ST1,       STN_ST3, STN_FR,  STN_PR,  STN_LR,  STN_TR,  STN_DR,
+    STN_PWR, STN_S2,  STN_KL,  STN_WL,  STN_RL,  STN_ST2,       STN_ST4, STN_RR,  STN_BR,  STN_GR,  STN_SR,  STN_ZR,
+                               STN_N1,  STN_A,   STN_O,         STN_E,   STN_U,  STN_N7
+    )
+};
+// Don't fuck with this, thanks.
+size_t keymapsCount  = sizeof(keymaps)/sizeof(keymaps[0]);

keyboards/georgi/keymaps/minimal/readme.md

@@ -0,0 +1,11 @@
+# Georgi QWERTY/Steno firmware
+
+This is the default keymap for Georgi, it's based heavily off of the naps62 ErgoDox and the Gergo layout. 
+It is both a ergonomic and programmer friendly keymap.
+
+Ideally you should copy this directory and make your changes there. If you come up with a good layout submit a PR!
+
+## Space issues
+If you find yourself running out of space for dictionary entries, disabling mousekeys in rules.mk will save
+you about 4k for entries!
+Get a free 1k by deleting the Gaming layers from the keymap!

keyboards/georgi/keymaps/minimal/rules.mk

@@ -0,0 +1,41 @@
+#----------------------------------------------------------------------------
+# make georgi:default:dfu
+# Make sure you have dfu-programmer installed!
+#----------------------------------------------------------------------------
+
+NO_REPEAT				 = no
+VERBOSE					 = yes
+KEYBOARD_SHARED_EP       = yes
+CUSTOM_MATRIX			 = yes
+
+#Firmware reduction options
+MOUSEKEY_ENABLE			 = no 		# 1500 bytes
+NO_TAPPING				 = yes		# 2000 bytes
+NO_PRINT				 = yes		
+
+#Debug options
+CONSOLE_ENABLE			 = no
+DEBUG_MATRIX_SCAN_RATE   = no
+DEBUG_MATRIX			 = no
+ONLY_QWERTY				 = no
+
+# A bunch of stuff that you shouldn't touch unless you
+# know what you're doing.
+#
+# No touchy, capiche?
+SRC += matrix.c i2c_master.c
+ifeq ($(strip $(DEBUG_MATRIX)), yes)
+    OPT_DEFS += -DDEBUG_MATRIX
+endif
+ifeq ($(strip $(NO_REPEAT)), yes)
+    OPT_DEFS += -DNO_REPEAT
+endif
+ifeq ($(strip $(NO_PRINT)), yes)
+    OPT_DEFS += -DNO_PRINT -DNO_DEBUG
+endif
+ifeq ($(strip $(ONLY_QWERTY)), yes)
+    OPT_DEFS += -DONLYQWERTY
+endif
+ifeq ($(strip $(NO_TAPPING)), yes)
+    OPT_DEFS += -DNO_ACTION_TAPPING
+endif

keyboards/georgi/keymaps/norman/keymap.c

@@ -0,0 +1,267 @@
+/*
+ * Good on you for modifying your layout, this is the most nonQMK layout you will come across
+ * There are three modes, Steno (the default), QWERTY (Toggleable) and a Momentary symbol layer
+ *
+ * Don't modify the steno layer directly, instead add chords using the keycodes and macros
+ * from sten.h to the layout you want to modify.
+ *
+ * Observe the comment above processQWERTY!
+ *
+ * http://docs.gboards.ca
+ */
+
+#include QMK_KEYBOARD_H
+#include "sten.h"
+#include "keymap_steno.h"
+#define IGNORE_MOD_TAP_INTERRUPT
+
+// Proper Layers
+#define FUNCT   (LSD | LK | LP | LH)
+#define MEDIA   (LSD | LK | LW | LR)
+#define MOVE    (LH | ST2)
+
+/* Keyboard Layout
+ * ,---------------------------------.    ,------------------------------.
+ * | FN  | LSU | LFT | LP | LH | ST1 |    | ST3 | RF | RP | RL | RT | RD |
+ * |-----+-----+-----+----+----|-----|    |-----|----+----+----+----+----|
+ * | PWR | LSD | LK  | LW | LR | ST2 |    | ST4 | RR | RB | RG | RS | RZ |
+ * `---------------------------------'    `------------------------------'
+ *                   ,---------------,    .---------------.
+ *                   | LNO | LA | LO |    | RE | RU | RNO |
+ *                   `---------------'    `---------------'
+ */
+
+// YOU MUST ORDER THIS!
+// Order your chords from longest to shortest!
+// You can only use basic keycodes here!
+//
+// P() is just a wrapper to make your life easier.
+//
+// http://docs.gboards.ca
+uint32_t processQwerty(bool lookup) {
+	// Specials
+	P( RT  | RS  | RD  | RZ | LNO,		SEND_STRING(VERSION); SEND_STRING(__DATE__));
+	P( LNO | LA  | LO  | RE | RU,		SEND(KC_MPLY));
+	P( ST1 | ST2 | ST3 | ST4,			SEND(KC_BSPC));
+
+	// Thumb Chords
+	P(  LA  | LO  | RE  | RU,			SEND(KC_CAPS));
+	P(  LA  | RU,						SEND(KC_ESC));
+	P( LO  | RE,						SEND(KC_LCTL));
+	P( LNO | LA | RU,					SEND(KC_LCTL); SEND(KC_LSFT));
+	P( LNO | LA | RE,					SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_LALT));
+
+	// Mods
+	P( RT | RD | RS | RZ,				SEND(KC_LGUI));
+	P( RT | RD,						SEND(KC_LCTL));
+	P( RS | RZ,						SEND(KC_LALT));
+	P( LA | LNO,						SEND(KC_LCTL));
+	P( LA | LO,						SEND(KC_LALT));
+	P( LO,								SEND(KC_LSFT));
+
+	// Function Layer
+	P( FUNCT | RF | RR,					SEND(KC_F6));
+	P( FUNCT | RP | RB,					SEND(KC_F7));
+	P( FUNCT | RL | RG,					SEND(KC_F8));
+	P( FUNCT | ST3 | ST4,				SEND(KC_F5));
+  P( FUNCT| ST3,              SEND(KC_F1));
+  P( FUNCT| ST4,              SEND(KC_F9));
+	P( FUNCT | RF,						SEND(KC_F2));
+	P( FUNCT | RP,						SEND(KC_F3));
+	P( FUNCT | RL,						SEND(KC_F4));
+	P( FUNCT | RR,						SEND(KC_F10));
+	P( FUNCT | RG,						SEND(KC_F12));
+	P( FUNCT | RB,						SEND(KC_F11));
+  P( FUNCT | RD,            SEND(KC_RALT); SEND(KC_T); SEND(KC_H); SEND(KC_U); SEND(KC_P));
+  P( FUNCT | RZ,            SEND(KC_RALT); SEND(KC_T); SEND(KC_H); SEND(KC_D); SEND(KC_N));
+  P( FUNCT | RT,            SEND(KC_RALT); SEND(KC_S); SEND(KC_F));
+  P( FUNCT | RS,            SEND(KC_LALT); SEND(KC_SPC));
+  P( FUNCT | RE,            SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_ESC));
+  P( FUNCT | RU,            SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_0));
+
+	// Movement Layer
+	P( MOVE | RF,						 SEND(KC_LGUI); SEND(KC_LSFT); SEND(KC_LEFT));
+	P( MOVE | RP,						SEND(KC_UP));
+	P( MOVE | RL,						SEND(KC_LGUI); SEND(KC_LSFT); SEND(KC_RGHT));
+	P( MOVE | RT,						SEND(KC_LALT); SEND(KC_LCTL); SEND(KC_LGUI); SEND(KC_C));
+	P( MOVE | ST3,						SEND(KC_PGUP));
+	P( MOVE | ST4,						SEND(KC_PGDN));
+  P( MOVE | RD,           SEND(KC_HOME));
+  P( MOVE | RZ,           SEND(KC_END));
+  P( MOVE | RG,            SEND(KC_RIGHT));
+  P( MOVE | RB,            SEND(KC_DOWN));
+  P( MOVE | RR,            SEND(KC_LEFT));
+  P( MOVE | RS,            SEND(KC_LSFT); SEND(KC_LCTL); SEND(KC_LGUI); SEND(KC_T));
+  P( MOVE | RE,            SEND(KC_LSFT); SEND(KC_LALT); SEND(KC_LGUI); SEND(KC_S));
+  P( MOVE | RU,            SEND(KC_LSFT); SEND(KC_LCTL); SEND(KC_1));
+
+
+	// Media Layer
+	P( MEDIA | RF,						SEND(KC_MEDIA_PREV_TRACK));
+	P( MEDIA | RP,						SEND(KC_MPLY));
+	P( MEDIA | RL,						SEND(KC_MPLY));
+	P( MEDIA | RT,						SEND(KC_MEDIA_NEXT_TRACK));
+	P( MEDIA | RD,						SEND(KC_VOLU));
+	P( MEDIA | RZ,						SEND(KC_VOLD));
+	P( MEDIA | RS,						SEND(KC_MUTE));
+  P( MEDIA | ST3,           SEND(KC_LALT); SEND(KC_LCTL); SEND(KC_LGUI); SEND(KC_4));
+  P( MEDIA | ST4,           SEND(KC_LALT); SEND(KC_LCTL); SEND(KC_LGUI); SEND(KC_2));
+  P( MEDIA | RR,            SEND(KC_LALT); SEND(KC_LCTL); SEND(KC_LGUI); SEND(KC_3));
+  P( MEDIA | RB,            SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_GRV));
+  P( MEDIA | RG,            SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_8));
+  P( MEDIA | RE,            SEND(KC_RALT); SEND(KC_F); SEND(KC_I); SEND(KC_R); SEND(KC_E));
+  P( MEDIA | RU,            SEND(KC_RALT); SEND(KC_T); SEND(KC_A); SEND(KC_D));
+
+	// Mouse Keys and Printscreen
+	P( LFT | LH,							CLICK_MOUSE(KC_MS_BTN1));
+	P( LK | LR,							CLICK_MOUSE(KC_MS_BTN2));
+	P( RF | RT,							SEND(KC_PSCR););
+
+	// Number Row Left
+	P( LNO | LSU,						SEND(KC_1));
+	P( LNO | LFT,						SEND(KC_2));
+	P( LNO | LP,						SEND(KC_3));
+	P( LNO | LH,						SEND(KC_4));
+	P( LNO | ST1,						SEND(KC_5));
+	P( LNO | ST3,						SEND(KC_6));
+	P( LNO | RF,						SEND(KC_7));
+	P( LNO | RP,						SEND(KC_8));
+	P( LNO | RL,						SEND(KC_9));
+	P( LNO | RT,						SEND(KC_0));
+	P( LNO | LA,						SEND(KC_5));
+	P( LNO | RT,						SEND(KC_0));
+
+  // Number Row Right
+	P( RNO | LSU,						SEND(KC_1));
+	P( RNO | LFT,						SEND(KC_2));
+	P( RNO | LP,						SEND(KC_3));
+	P( RNO | LH,						SEND(KC_4));
+	P( RNO | ST1,						SEND(KC_5));
+	P( RNO | ST3,						SEND(KC_6));
+	P( RNO | RF,						SEND(KC_7));
+	P( RNO | RP,						SEND(KC_8));
+	P( RNO | RL,						SEND(KC_9));
+	P( RNO | RT,						SEND(KC_0));
+	P( RNO | LA,						SEND(KC_5));
+	P( RNO | RT,						SEND(KC_0));
+
+	// Specials
+	P( LA | LNO,						SEND(KC_ESC));
+	P( RU | RNO,						SEND(KC_TAB));
+	P( RE | RU,							SEND(KC_LSFT); SEND(KC_SLSH));
+	P( RD | RZ,							SEND(KC_ENT));
+	P( RE,								SEND(KC_ENT));
+	//P( RD,								SEND(KC_BSPC));
+	P( LNO,								SEND(KC_BSPC));
+  P( RD,								SEND(KC_DEL));
+	P( LA,								SEND(KC_SPC));
+	P( RU,								SEND(KC_SPC));
+	P( RZ,								SEND(KC_ESC));
+  //P( RNO,               REPEAT());
+
+	// Letters
+	P( LSU | LSD,						SEND(KC_A));
+	P( LFT | LK,						SEND(KC_S));
+	P( LP  | LW,						SEND(KC_E));
+	P( LH  | LR,						SEND(KC_T));
+	P( ST1 | ST2,						SEND(KC_G));
+	P( ST3 | ST4,						SEND(KC_Y));
+	P( RF  | RR,						SEND(KC_N));
+	P( RT  | RS,						SEND(KC_H))
+	P( RG  | RL,						SEND(KC_O));
+	P( RP  | RB,						SEND(KC_I));
+	P( LSU,								SEND(KC_Q));
+	P( LSD,								SEND(KC_Z));
+	P( LFT,								SEND(KC_W));
+	P( LK,								SEND(KC_X));
+	P( LP,								SEND(KC_D));
+	P( LW,								SEND(KC_C));
+	P( LH,								SEND(KC_F));
+	P( LR,								SEND(KC_V));
+	P( ST1,								SEND(KC_K));
+	P( ST2,								SEND(KC_B));
+	P( ST3,								SEND(KC_J));
+	P( ST4,								SEND(KC_P));
+	P( RF,								SEND(KC_U));
+	P( RR,								SEND(KC_M));
+	P( RP,								SEND(KC_R));
+	P( RB,								SEND(KC_COMM));
+	P( RL,								SEND(KC_L));
+	P( RG,								SEND(KC_DOT));
+	P( RT,								SEND(KC_SCLN));
+	P( RS,								SEND(KC_SLSH));
+
+	// Symbols and Numbers
+	P( PWR | RE | RU,					SEND(KC_ENT));
+	P( PWR | LA | LO,					SEND(KC_SPC));
+	P( PWR | LP | LW,					SEND(KC_LSFT); SEND(KC_9));			// (
+	P( PWR | LH | LR,					SEND(KC_LSFT); SEND(KC_0));			// )
+	P( PWR | ST1 | ST2,					SEND(KC_GRV));						// `
+	P( PWR | RD | RZ,					SEND(KC_ESC));
+	P( PWR | LSU | LSD,					SEND(KC_LSFT); SEND(KC_3));			// #
+	P( PWR | LFT | LK,					SEND(KC_LSFT); SEND(KC_4));			// $
+	P( PWR | LSU,						SEND(KC_LSFT); SEND(KC_1));			// !
+	P( PWR | LSD,						SEND(KC_LSFT); SEND(KC_5));			// %
+	P( PWR | LFT,						SEND(KC_LSFT); SEND(KC_2));			// @
+	P( PWR | LK,						SEND(KC_LSFT); SEND(KC_6));			// ^
+	P( PWR | LP,						SEND(KC_LSFT); SEND(KC_LBRC));		// {
+	P( PWR | LW,						SEND(KC_LBRC));
+	P( PWR | LH,						SEND(KC_LSFT); SEND(KC_RBRC));		// }
+	P( PWR | LR,						SEND(KC_RBRC));
+	P( PWR | ST1,						SEND(KC_LSFT); SEND(KC_BSLS));		// |
+	P( PWR | ST2,						SEND(KC_LSFT); SEND(KC_GRV));		// ~
+	P( PWR | ST3,						SEND(KC_QUOT));
+	P( PWR | ST4,						SEND(KC_LSFT); SEND(KC_QUOT));		// "
+	P( PWR | RF,						SEND(KC_KP_PLUS));
+	P( PWR | RR,						SEND(KC_LSFT); SEND(KC_7));			// &
+	P( PWR | RP,						SEND(KC_MINS));
+	P( PWR | RB,						SEND(KC_EQL));
+	P( PWR | RL,						SEND(KC_SLSH));
+	P( PWR | RG,						SEND(KC_LSFT); SEND(KC_MINS));
+	P( PWR | RT,						SEND(KC_PAST));
+	P( PWR | RS,						SEND(KC_DOT));
+	P( PWR | RD,						SEND(KC_TAB));
+	P( PWR | LA,						SEND(KC_LSFT); SEND(KC_SCLN));
+	P( PWR | LO,						SEND(KC_BSLS));
+	P( PWR | RE,						SEND(KC_SCLN));
+	P( PWR | RU,						SEND(KC_BSLS));
+  P( PWR | RZ,						SEND(KC_LSFT));
+
+	return 0;
+}
+
+#define STENO_LAYER		0
+#define GAMING			1
+#define GAMING_2		2
+#define MOVEMENT    3
+
+// "Layers"
+// Steno layer should be first in your map.
+// When PWR | FN | ST3 | ST4 is pressed, the layer is increased to the next map. You must return to STENO_LAYER at the end.
+// If you need more space for chords, remove the two gaming layers.
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+// Main layer, everything goes through here
+[STENO_LAYER] = LAYOUT_georgi(
+STN_FN,  STN_S1, STN_TL, STN_PL, STN_HL, STN_ST1,       STN_ST3, STN_FR, STN_PR, STN_LR, STN_TR, STN_DR,
+STN_PWR, STN_S2, STN_KL, STN_WL, STN_RL, STN_ST2,       STN_ST4, STN_RR, STN_BR, STN_GR, STN_SR, STN_ZR,
+						 STN_N1, STN_A,  STN_O,			STN_E,   STN_U,  STN_N7)
+,
+// Gaming layer with Numpad, Very limited
+[GAMING] = LAYOUT_georgi(
+KC_LSFT, KC_Q, KC_W, KC_E, KC_R, KC_T,       KC_Y,   KC_U, KC_I, KC_O, KC_P,    KC_ENT,
+KC_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G,       KC_H,   KC_J, KC_K, KC_L, KC_SCLN, KC_DQUO,
+KC_LALT, KC_SPC, LT(GAMING_2, KC_ENT),	     KC_DEL, KC_ASTR,  TO(STENO_LAYER)),
+
+[GAMING_2] = LAYOUT_georgi(
+KC_LSFT, KC_1, KC_2, KC_3, KC_4, KC_5,       KC_6, KC_7, KC_8,  KC_9,  KC_0, KC_MINS,
+KC_LCTL, KC_Z, KC_X, KC_C, KC_V, KC_B,       KC_N, KC_M, KC_LT, KC_GT, KC_QUES, KC_RSFT,
+			  KC_LALT, KC_SPC, KC_NO,	             KC_DEL, KC_ASTR,  TO(STENO_LAYER)),
+
+[MOVEMENT] = LAYOUT_georgi(
+KC_TRNS, KC_TRNS, KC_TRNS,  KC_TRNS, KC_TRNS,KC_TRNS,       KC_PGUP, KC_TRNS, KC_UP,   KC_TRNS,  KC_TRNS, KC_HOME,
+KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,       KC_PGDN, KC_LEFT, KC_DOWN, KC_RIGHT, KC_TRNS, KC_END,
+			  KC_TRNS, KC_TRNS, KC_TRNS,	                        KC_TRNS, KC_TRNS, KC_TRNS)
+};
+// Don't fuck with this, thanks.
+size_t keymapsCount  = sizeof(keymaps)/sizeof(keymaps[0]);

keyboards/georgi/keymaps/norman/readme.md

@@ -0,0 +1,11 @@
+# Georgi QWERTY/Steno firmware
+
+This is the default keymap for Georgi, it's based heavily off of the naps62 ErgoDox and the Gergo layout. 
+It is both a ergonomic and programmer friendly keymap.
+
+Ideally you should copy this directory and make your changes there. If you come up with a good layout submit a PR!
+
+## Space issues
+If you find yourself running out of space for dictionary entries, disabling mousekeys in rules.mk will save
+you about 4k for entries!
+Get a free 1k by deleting the Gaming layers from the keymap!

keyboards/georgi/keymaps/norman/rules.mk

@@ -1,18 +1,20 @@
 #----------------------------------------------------------------------------
-# make georgi:extrakey:dfu
+# make georgi:default:dfu
 # Make sure you have dfu-programmer installed!
 #----------------------------------------------------------------------------
 
-#Debug options
+NO_REPEAT				 = yes
 VERBOSE					 = yes
-CONSOLE_ENABLE			 = yes
-DEBUG_MATRIX_SCAN_RATE   = no
-DEBUG_MATRIX			 = no
 KEYBOARD_SHARED_EP       = yes
 CUSTOM_MATRIX			 = yes
-MOUSEKEY_ENABLE			 = no
-SINGLE_LAYER			 = no
+MOUSEKEY_ENABLE			 = yes
 
+#Debug options
+CONSOLE_ENABLE			 = no
+DEBUG_MATRIX_SCAN_RATE   = no
+DEBUG_MATRIX			 = no
+NO_PRINT				 = yes
+ONLY_QWERTY				 = no
 
 # A bunch of stuff that you shouldn't touch unless you
 # know what you're doing.
@@ -22,6 +24,12 @@ SRC += matrix.c i2c_master.c
 ifeq ($(strip $(DEBUG_MATRIX)), yes)
     OPT_DEFS += -DDEBUG_MATRIX
 endif
-ifeq ($(strip $(SINGLE_LAYER)), yes)
-    OPT_DEFS += -DSINGLE_LAYER
+ifeq ($(strip $(NO_REPEAT)), yes)
+    OPT_DEFS += -DNO_REPEAT
+endif
+ifeq ($(strip $(NO_PRINT)), yes)
+    OPT_DEFS += -DNO_PRINT -DNO_DEBUG
+endif
+ifeq ($(strip $(ONLY_QWERTY)), yes)
+    OPT_DEFS += -DONLYQWERTY
 endif

keyboards/georgi/keymaps/template/keymap.c

@@ -1,216 +0,0 @@
-/* 
- * Good on you for modifying your layout, this is the most nonQMK layout you will come across
- * There are three modes, Steno (the default), QWERTY (Toggleable) and a Momentary symbol layer
- *
- * Don't modify the steno layer directly, instead add chords using the keycodes and macros
- * from sten.h to the layout you want to modify.
- *
- * Observe the comment above processQWERTY!
- *
- * http://docs.gboards.ca
- */
-
-#include QMK_KEYBOARD_H
-#include "sten.h"
-#include "keymap_steno.h"
-#define IGNORE_MOD_TAP_INTERRUPT
-
-int getKeymapCount(void);
-
-// Proper Layers
-#define FUNCT   (LSD | LK | LP | LH)
-#define MEDIA   (LSD | LK | LW | LR)
-#define MOVE    (ST1 | ST2)
-
-/* Keyboard Layout
- * ,---------------------------------.    ,------------------------------.
- * | FN  | LSU | LFT | LP | LH | ST1 |    | ST3 | RF | RP | RL | RT | RD |
- * |-----+-----+-----+----+----|-----|    |-----|----+----+----+----+----|
- * | PWR | LSD | LK  | LW | LR | ST2 |    | ST4 | RR | RG | RB | RS | RZ |
- * `---------------------------------'    `------------------------------'
- *                   ,---------------,    .---------------.
- *                   | NUM | LA | LO |    | RE | RU | NUM |
- *                   `---------------'    `---------------'
- */
-
-// YOU MUST ORDER THIS!
-// P   Will return from processing on the first match it finds. Therefore
-// PJ  Will run the requested action, remove the matched chord and continue 
-//
-// First any chords that would conflict with PJs need to be checked, then PJs, lastly Ps.
-// For all chords should be ordered by length in their section!
-//
-// http://docs.gboards.ca
-bool processQwerty(void) {
-	// Place P's that would be trashed by PJ's here
-	P( RT  | RS  | RD  | RZ | NUM,		SEND_STRING(VERSION); SEND_STRING(__DATE__));
-	P( NUM | LA  | LO  | RE | RU,		SEND(KC_MPLY));
-	P( ST1 | ST2 | ST3 | ST4,			SEND(KC_BSPC));
-
-	// Thumb Chords
-	P(  LA  | LO  | RE  | RU,			SEND(KC_CAPS));
-	P(  LA  | RU,						SEND(KC_ESC));
-	PJ( LO  | RE,						SEND(KC_LCTL));
-	PJ( NUM | LA | RU,					SEND(KC_LCTL); SEND(KC_LSFT));
-	PJ( NUM | LA | RE,					SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_LALT));
-	
-	// Mods 
-	PJ( RT | RD | RS | RZ,				SEND(KC_LGUI));
-	PJ( RT | RD,						SEND(KC_LCTL));
-	PJ( RS | RZ,						SEND(KC_LALT));
-	PJ( LA | NUM,						SEND(KC_LCTL));
-	PJ( LA | LO,						SEND(KC_LALT));
-	PJ( LO,								SEND(KC_LSFT));
-
-	// Function Layer 
-	P( FUNCT | RF | RR,					SEND(KC_F5));
-	P( FUNCT | RP | RB,					SEND(KC_F6));
-	P( FUNCT | RL | RG,					SEND(KC_F7));
-	P( FUNCT | RT | RS,					SEND(KC_F8));
-	P( FUNCT | RF,						SEND(KC_F1));
-	P( FUNCT | RP,						SEND(KC_F2));
-	P( FUNCT | RL,						SEND(KC_F3));
-	P( FUNCT | RT,						SEND(KC_F4));
-	P( FUNCT | RR,						SEND(KC_F9));
-	P( FUNCT | RG,						SEND(KC_F10));
-	P( FUNCT | RB,						SEND(KC_F11));
-	P( FUNCT | RS,						SEND(KC_F12));
-
-	// Movement Layer
-	P( MOVE | RF,						SEND(KC_LEFT));
-	P( MOVE | RP,						SEND(KC_DOWN));
-	P( MOVE | RL,						SEND(KC_UP));
-	P( MOVE | RT,						SEND(KC_RIGHT));
-	P( MOVE | ST3,						SEND(KC_PGUP));
-	P( MOVE | ST4,						SEND(KC_PGDN));
-
-	// Media Layer
-	P( MEDIA | RF,						SEND(KC_MPRV));
-	P( MEDIA | RP,						SEND(KC_MPLY));
-	P( MEDIA | RL,						SEND(KC_MPLY));
-	P( MEDIA | RT,						SEND(KC_MNXT));
-	P( MEDIA | RD,						SEND(KC_VOLU));
-	P( MEDIA | RZ,						SEND(KC_VOLD));
-	P( MEDIA | RS,						SEND(KC_MUTE));
-
-	// Mouse Keys
-	P( LP | LH,							clickMouse(KC_MS_BTN1));
-	P( LW | LR,							clickMouse(KC_MS_BTN2));
-	
-	// Number Row
-	P( NUM | LSU,						SEND(KC_1));
-	P( NUM | LFT,						SEND(KC_2));
-	P( NUM | LP,						SEND(KC_3));
-	P( NUM | LH,						SEND(KC_4));
-	P( NUM | ST1,						SEND(KC_5));
-	P( NUM | ST3,						SEND(KC_6));
-	P( NUM | RF,						SEND(KC_7));
-	P( NUM | RP,						SEND(KC_8));
-	P( NUM | RL,						SEND(KC_9));
-	P( NUM | RT,						SEND(KC_0));
-	P( NUM | LA,						SEND(KC_5));
-	P( NUM | RT,						SEND(KC_0));
-	
-	// Specials
-	P( LA | NUM,						SEND(KC_ESC));
-	P( RU | NUM,						SEND(KC_TAB));
-	P( RE | RU,							SEND(KC_BSPC));
-	P( RD | RZ,							SEND(KC_ENT));
-	P( RE,								SEND(KC_ENT));
-	P( RD,								SEND(KC_BSPC));	
-	P( NUM,								SEND(KC_BSPC));
-	P( LA,								SEND(KC_SPC));
-	P( RU,								SEND(KC_SPC));
-	P( RZ,								SEND(KC_ESC));
-
-	// Letters
-	P( LSU | LSD,						SEND(KC_A));
-	P( LFT | LK,						SEND(KC_S));
-	P( LP  | LW,						SEND(KC_D));
-	P( LH  | LR,						SEND(KC_F));
-	P( ST1 | ST2,						SEND(KC_G));
-	P( ST3 | ST4,						SEND(KC_H));
-	P( RF  | RR,						SEND(KC_J));
-	P( RT  | RS,						SEND(KC_SCLN))
-	P( RG  | RL,						SEND(KC_L));
-	P( RP  | RB,						SEND(KC_K));
-	P( LSU,								SEND(KC_Q));
-	P( LSD,								SEND(KC_Z));
-	P( LFT,								SEND(KC_W));
-	P( LK,								SEND(KC_X));
-	P( LP,								SEND(KC_E));
-	P( LW,								SEND(KC_C));
-	P( LH,								SEND(KC_R));
-	P( LR,								SEND(KC_V));
-	P( ST1,								SEND(KC_T));
-	P( ST2,								SEND(KC_B));
-	P( ST3,								SEND(KC_Y));
-	P( ST4,								SEND(KC_N));
-	P( RF,								SEND(KC_U));
-	P( RR,								SEND(KC_M));
-	P( RP,								SEND(KC_I));
-	P( RB,								SEND(KC_COMM));
-	P( RL,								SEND(KC_O));
-	P( RG,								SEND(KC_DOT));
-	P( RT,								SEND(KC_P));
-	P( RS,								SEND(KC_SLSH));
-
-	// Symbols and Numbers
-	P( PWR | RE | RU,					SEND(KC_ENT));
-	P( PWR | LA | LO,					SEND(KC_SPC));
-	P( PWR | LP | LW,					SEND(KC_LSFT); SEND(KC_9));			// (
-	P( PWR | LH | LR,					SEND(KC_LSFT); SEND(KC_0));			// )
-	P( PWR | ST1 | ST2,					SEND(KC_GRV));						// `
-	P( PWR | RD | RZ,					SEND(KC_ESC));							
-	P( PWR | LSU | LSD,					SEND(KC_LSFT); SEND(KC_3));			// #
-	P( PWR | LFT | LK,					SEND(KC_LSFT); SEND(KC_4));			// $
-	P( PWR | LSU,						SEND(KC_LSFT); SEND(KC_1));			// !
-	P( PWR | LSD,						SEND(KC_LSFT); SEND(KC_5));			// %
-	P( PWR | LFT,						SEND(KC_LSFT); SEND(KC_2));			// @
-	P( PWR | LK,						SEND(KC_LSFT); SEND(KC_6));			// ^
-	P( PWR | LP,						SEND(KC_LSFT); SEND(KC_LBRC));		// {
-	P( PWR | LW,						SEND(KC_LBRC));
-	P( PWR | LH,						SEND(KC_LSFT); SEND(KC_RBRC));		// }
-	P( PWR | LR,						SEND(KC_RBRC));
-	P( PWR | ST1,						SEND(KC_LSFT); SEND(KC_BSLS));		// |
-	P( PWR | ST2,						SEND(KC_LSFT); SEND(KC_GRV));		// ~
-	P( PWR | ST3,						SEND(KC_QUOT));
-	P( PWR | ST4,						SEND(KC_LSFT); SEND(KC_QUOT));		// "
-	P( PWR | RF,						SEND(KC_KP_PLUS));
-	P( PWR | RR,						SEND(KC_LSFT); SEND(KC_7));			// &
-	P( PWR | RP,						SEND(KC_MINS));
-	P( PWR | RB,						SEND(KC_EQL));
-	P( PWR | RL,						SEND(KC_SLSH));
-	P( PWR | RG,						SEND(KC_COMM));
-	P( PWR | RT,						SEND(KC_PAST));
-	P( PWR | RS,						SEND(KC_DOT));
-	P( PWR | RD,						SEND(KC_TAB));
-	P( PWR | LA,						SEND(KC_SCLN));
-	P( PWR | LO,						SEND(KC_SLSH));
-	P( PWR | RE,						SEND(KC_SCLN));
-	P( PWR | RU,						SEND(KC_SLSH));
-
-
-	// If we make here, send as a steno chord
-	// If plover is running we can hook that host side
-	return false;
-}
-
-#define STENO_LAYER  	0
-
-// "Layers"
-// Steno layer should be first in your map.
-// When PWR | FN | RR | RG | RB | RS is pressed, the layer is increased to the next map. You must return to STENO_LAYER at the end.
-// If you have only a single layer, you must set SINGLELAYER = yes in your rules.mk, otherwise you may experince undefined behaviour
-
-const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-// Main layer, everything goes through here
-[STENO_LAYER] = LAYOUT_georgi(  
-STN_FN,  STN_S1, STN_TL, STN_PL, STN_HL, STN_ST1,       STN_ST3, STN_FR, STN_PR, STN_LR, STN_TR, STN_DR,
-STN_PWR, STN_S2, STN_KL, STN_WL, STN_RL, STN_ST2,       STN_ST4, STN_RR, STN_BR, STN_GR, STN_SR, STN_ZR,
-						 STN_N1, STN_A,  STN_O,			STN_E,   STN_U,  STN_N1)
-}; 
-
-int getKeymapCount(void) {
-	return sizeof(keymaps)/sizeof(keymaps[0]);
-}

keyboards/georgi/keymaps/template/readme.md

@@ -1,6 +0,0 @@
-# Georgi QWERTY/Steno firmware
-
-This is a blank template configured with 5K of free space for your onboard dictionary!  
-Read the docs over at [gBoards](http://docs.gboards.ca)
-
-Ideally you should copy this directory and make your changes there. If you come up with a good layout submit a PR!

keyboards/georgi/readme.md

@@ -21,8 +21,11 @@ To just test your build with the default keymap
 
 Build options can be enabled/disabled in keyboards/georgi/keymaps/default/rules.mk . Copy the default directory and make any changes to your layout, if you think they're worth sharing submit a PR!
 
+## Documentation
+Is hosted over on [docs.gboards.ca](http://docs.gboards.ca/). Please take a look at the docs for customizing your firmware!
+
 # Space
-The stock firmware uses nearly all of the flash avalible. For custom dictionary modifications, disable mousekeys in your keymaps rules.mk (4K of space) and remove the Gaming layers. I've done this already in the provided keymap 'template'.
+The stock firmware leaves 7K free for custom entries. For extra space disable mousekeys in your keymaps rules.mk (3K of space) and remove the Gaming layers (1k). 
 
 See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).
 

keyboards/georgi/rules.mk

@@ -4,7 +4,7 @@
 # Do not edit this file! Make a copy of keymaps/default and modify that!
 #----------------------------------------------------------------------------
 # Source includes
-SRC += matrix.c i2c_master.c
+SRC += matrix.c i2c_master.c sten.c
 
 # Hardware info
 MCU = atmega32u4
@@ -15,8 +15,9 @@ F_USB = $(F_CPU)
 EXTRAFLAGS += -flto
 
 CUSTOM_MATRIX 		= yes
+MOUSEKEY_ENABLE		= no
 STENO_ENABLE 		= yes
 EXTRAKEY_ENABLE     = yes
-CONSOLE_ENABLE      = no
+CONSOLE_ENABLE      = yes
 COMMAND_ENABLE      = no
 NKRO_ENABLE			= yes

keyboards/georgi/sten.c

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

keyboards/georgi/sten.h

@@ -1,28 +1,43 @@
 // 2019, g Heavy Industries
+// Blessed mother of Christ, please keep this readable
+// and protect us from segfaults. For thine is the clock,
+// the slave and the master. Until we return from main.
+//
+// Amen.
 
 #include QMK_KEYBOARD_H
 #include "mousekey.h"
 #include "keymap.h"
 #include "keymap_steno.h"
+#include "wait.h"
 
-// Bitfield representing the current chord
-uint32_t cChord = 0;
+extern size_t keymapsCount;			// Total keymaps
+extern uint32_t cChord;				// Current Chord
 
-// See if a given chord is pressed. 
-// P will return 
-// PJ will continue processing, removing the found chord 
-#define P(chord, act)  if (cChord == (chord)) { act; return true; }
-#define PJ(chord, act) if ((cChord & (chord)) == (chord)) { cChord ^= chord; act; }
+// Function defs
+void 			processChord(bool useFakeSteno);
+uint32_t		processQwerty(bool lookup);
+uint32_t 		processFakeSteno(bool lookup);
+void 			saveState(uint32_t cChord);
+void 			restoreState(void);
+
+// Macros for use in keymap.c
+void 			SEND(uint8_t kc);
+void 			REPEAT(void);
+void 			SET_STICKY(uint32_t);
+void 			SWITCH_LAYER(int);
+void 			CLICK_MOUSE(uint8_t);
+
+// Keymap helper
+#define P(chord, act) if (cChord == (chord)) { if (!lookup) {act;} return chord;}
 
-// All Steno Codes
 // Shift to internal representation
+// i.e) S(teno)R(ight)F
 #define STN(n) (1L<<n)
-
-//i.e) S(teno)R(ight)F
 enum ORDER { 
-		SFN = 0, SPWR, SST1, SST2, SST3, SST4, SNUM,
+		SFN = 0, SPWR, SST1, SST2, SST3, SST4, SNUML, SNUMR,
 		SLSU, SLSD, SLT, SLK, SLP, SLW, SLH, SLR, SLA, SLO, 
-		SRE, SRU, SRF, SRR, SRP, SRB, SRL, SRG, SRT, SRS, SRD, SRZ
+		SRE, SRU, SRF, SRR, SRP, SRB, SRL, SRG, SRT, SRS, SRD, SRZ, SRES1, SRES2
 };
 
 // Break it all out
@@ -32,11 +47,14 @@ enum ORDER {
 #define ST2 STN(SST2)
 #define ST3 STN(SST3)
 #define ST4 STN(SST4)
-#define NUM STN(SNUM) // No distinction between left and right
+#define LNO STN(SNUML) 	// STN1-6
+#define RNO STN(SNUMR) 	// STN7-C
+#define RES1 STN(SRES1) // Use reserved for sticky state
+#define RES2 STN(SRES2)
 
 #define LSU STN(SLSU)
 #define LSD STN(SLSD)
-#define LFT STN(SLT)  // (L)e(F)t (T), preprocessor conflict
+#define LFT STN(SLT)  	// (L)e(F)t (T), preprocessor conflict
 #define LK  STN(SLK)
 #define LP  STN(SLP)
 #define LW  STN(SLW)
@@ -57,234 +75,3 @@ enum ORDER {
 #define RS  STN(SRS)
 #define RD  STN(SRD)
 #define RZ  STN(SRZ)
-
-bool 		processQwerty(void);
-bool 		processFakeSteno(void);
-void 		clickMouse(uint8_t kc);
-void 		SEND(uint8_t kc);
-extern int 	getKeymapCount(void);
-
-// Mode state
-enum MODE { STENO = 0, QWERTY, COMMAND };
-enum MODE cMode = STENO;
-enum MODE pMode;
-bool QWERSTENO = false;
-
-// Command State
-#define MAX_CMD_BUF 20
-uint8_t CMDBUF[MAX_CMD_BUF];
-uint8_t CMDLEN = 0;
-
-// Key Repeat state
-bool     inChord  = false;
-uint16_t repTimer = 0;
-#define  REP_DELAY 300
-
-// Mousekeys state
-bool	inMouse = false;
-int8_t	mousePress;
-
-// All processing done at chordUp goes through here
-bool send_steno_chord_user(steno_mode_t mode, uint8_t chord[6]) { 
-	// Check for mousekeys, this is release
-#ifdef MOUSEKEY_ENABLE
-	if (inMouse) {
-		inMouse = false;
-		mousekey_off(mousePress);
-		mousekey_send();
-	}
-#endif
-
-	// Toggle Serial/QWERTY steno
-	if (cChord == (PWR | FN | ST1 | ST2)) {
-		uprintf("Fallback Toggle\n");
-		QWERSTENO = !QWERSTENO;
-		
-		goto out;
-	}
-
-	// handle command mode
-	if (cChord == (PWR | FN | RD | RZ)) {
-		uprintf("COMMAND Toggle\n");
-		if (cMode != COMMAND) {   // Entering Command Mode
-			CMDLEN = 0;
-			pMode = cMode;
-			cMode = COMMAND;
-		} else {                  // Exiting Command Mode
-			cMode = pMode;
-
-			// Press all and release all
-			for (int i = 0; i < CMDLEN; i++) {
-				register_code(CMDBUF[i]);
-			}
-			clear_keyboard();
-		}
-
-		goto out;
-	}
-
-	// Handle Gaming Toggle,
-	if (cChord == (PWR | FN | ST2 | ST3) && getKeymapCount() > 1) {
-		uprintf("Switching to QMK\n");
-		layer_on(1);
-		goto out;
-	}
-
-	// Lone FN press, toggle QWERTY
-	if (cChord == FN) {
-		(cMode == STENO) ? (cMode = QWERTY) : (cMode = STENO);
-		goto out;
-	}
-
-	// Check for Plover momentary
-	if (cMode == QWERTY && (cChord & FN)) {
-		cChord ^= FN;
-		goto steno;
-	}
-
-	// Do QWERTY and Momentary QWERTY
-	if (cMode == QWERTY || (cMode == COMMAND) || (cChord & (FN | PWR))) {
-		if (cChord & FN)  cChord ^= FN;
-		processQwerty();
-		goto out;
-	}
-
-	// Fallback NKRO Steno
-	if (cMode == STENO && QWERSTENO) {
-		processFakeSteno();
-		goto out;
-	}
-
-steno:
-	// Hey that's a steno chord!
-	inChord = false;
-	cChord = 0;
-	return true; 
-
-out:
-	inChord = false;
-	clear_keyboard();
-	cChord = 0;
-	return false;
-}
-
-// Update Chord State 
-bool process_steno_user(uint16_t keycode, keyrecord_t *record) { 
-	// Everything happens in here when steno keys come in.
-	// Bail on keyup
-	if (!record->event.pressed) return true;
-
-	// Update key repeat timers
-	repTimer = timer_read();
-	inChord  = true;
-
-	// Switch on the press adding to chord
-	bool pr = record->event.pressed;
-	switch (keycode) {
-			// Mods and stuff
-			case STN_ST1:			pr ? (cChord |= (ST1)): (cChord &= ~(ST1)); break;
-			case STN_ST2:			pr ? (cChord |= (ST2)): (cChord &= ~(ST2)); break;
-			case STN_ST3:			pr ? (cChord |= (ST3)): (cChord &= ~(ST3)); break;
-			case STN_ST4:			pr ? (cChord |= (ST4)): (cChord &= ~(ST4)); break;
-			case STN_FN:			pr ? (cChord |= (FN)) : (cChord &= ~(FN)); break;
-			case STN_PWR:			pr ? (cChord |= (PWR)): (cChord &= ~(PWR)); break;
-			case STN_N1...STN_N6: 
-			case STN_N7...STN_NC:	pr ? (cChord |= (NUM)): (cChord &= ~(NUM)); break;
-
-			// All the letter keys
-			case STN_S1:			pr ? (cChord |= (LSU)) : (cChord &= ~(LSU));  break;
-			case STN_S2:			pr ? (cChord |= (LSD)) : (cChord &= ~(LSD));  break;
-			case STN_TL:			pr ? (cChord |= (LFT)) : (cChord &= ~(LFT)); break;
-			case STN_KL:			pr ? (cChord |= (LK)) : (cChord &= ~(LK)); break;
-			case STN_PL:			pr ? (cChord |= (LP)) : (cChord &= ~(LP)); break;
-			case STN_WL:			pr ? (cChord |= (LW)) : (cChord &= ~(LW)); break;
-			case STN_HL:			pr ? (cChord |= (LH)) : (cChord &= ~(LH)); break;
-			case STN_RL:			pr ? (cChord |= (LR)) : (cChord &= ~(LR)); break;
-			case STN_A:				pr ? (cChord |= (LA)) : (cChord &= ~(LA)); break;
-			case STN_O:				pr ? (cChord |= (LO)) : (cChord &= ~(LO)); break;
-			case STN_E:				pr ? (cChord |= (RE)) : (cChord &= ~(RE)); break;
-			case STN_U:				pr ? (cChord |= (RU)) : (cChord &= ~(RU)); break;
-			case STN_FR:			pr ? (cChord |= (RF)) : (cChord &= ~(RF)); break;
-			case STN_RR:			pr ? (cChord |= (RR)) : (cChord &= ~(RR)); break;
-			case STN_PR:			pr ? (cChord |= (RP)) : (cChord &= ~(RP)); break;
-			case STN_BR:			pr ? (cChord |= (RB)) : (cChord &= ~(RB)); break;
-			case STN_LR:			pr ? (cChord |= (RL)) : (cChord &= ~(RL)); break;
-			case STN_GR:			pr ? (cChord |= (RG)) : (cChord &= ~(RG)); break;
-			case STN_TR:			pr ? (cChord |= (RT)) : (cChord &= ~(RT)); break;
-			case STN_SR:			pr ? (cChord |= (RS)) : (cChord &= ~(RS)); break;
-			case STN_DR:			pr ? (cChord |= (RD)) : (cChord &= ~(RD)); break;
-			case STN_ZR:			pr ? (cChord |= (RZ)) : (cChord &= ~(RZ)); break;
-	}
-
-	// Check for key repeat in QWERTY mode
-	return true; 
-}
-void matrix_scan_user(void) {
-	// We abuse this for early sending of key
-	// Key repeat only on QWER/SYMB layers
-	if (cMode != QWERTY) return;
-
-	// Check timers
-	if (timer_elapsed(repTimer) > REP_DELAY) {
-		// Process Key for report
-		processQwerty();
-
-		// Send report to host
-		send_keyboard_report();
-		repTimer = timer_read();
-	}
-};
-
-// Helpers
-bool processFakeSteno(void) {
-	PJ( LSU,			SEND(KC_Q););
-	PJ( LSD,			SEND(KC_A););
-	PJ( LFT,			SEND(KC_W););
-	PJ( LP,				SEND(KC_E););
-	PJ( LH,				SEND(KC_R););
-	PJ( LK,				SEND(KC_S););
-	PJ( LW,				SEND(KC_D););
-	PJ( LR,				SEND(KC_F););
-	PJ( ST1,			SEND(KC_T););
-	PJ( ST2,			SEND(KC_G););
-	PJ( LA,				SEND(KC_C););
-	PJ( LO,				SEND(KC_V););
-	PJ( RE,				SEND(KC_N););
-	PJ( RU,				SEND(KC_M););
-	PJ( ST3,			SEND(KC_Y););
-	PJ( ST4,			SEND(KC_H););
-	PJ( RF,				SEND(KC_U););
-	PJ( RP,				SEND(KC_I););
-	PJ( RL,				SEND(KC_O););
-	PJ( RT,				SEND(KC_P););
-	PJ( RD,				SEND(KC_LBRC););
-	PJ( RR,				SEND(KC_J););
-	PJ( RB,				SEND(KC_K););
-	PJ( RG,				SEND(KC_L););
-	PJ( RS,				SEND(KC_SCLN););
-	PJ( RZ,				SEND(KC_COMM););
-	PJ( NUM,			SEND(KC_1););
-
-	return false;
-}
-void clickMouse(uint8_t kc) {
-#ifdef MOUSEKEY_ENABLE
-	mousekey_on(kc);
-	mousekey_send();
-
-	// Store state for later use
-	inMouse = true;
-	mousePress = kc;
-#endif
-}
-void SEND(uint8_t kc) {
-	// Send Keycode, Does not work for Quantum Codes
-	if (cMode == COMMAND && CMDLEN < MAX_CMD_BUF) {
-		uprintf("CMD LEN: %d BUF: %d\n", CMDLEN, MAX_CMD_BUF);
-		CMDBUF[CMDLEN] = kc;
-		CMDLEN++;
-	} 
-
-	if (cMode != COMMAND) register_code(kc);
-	return;
-}

keyboards/gergo/info.json

@@ -1,6 +1,6 @@
 {
     "maintainer": "germ",
-    "height": 4.75,
+    "height": 5.75,
     "width": 19.5,
     "keyboard_name": "Gergo",
     "url": "http://gboards.ca",

keyboards/gergo/keymaps/default/rules.mk

@@ -12,7 +12,7 @@ MOUSEKEY_ENABLE = yes  		# Mouse keys(+4700), needed for baller
 VERBOSE 		 = yes
 DEBUG_MATRIX_SCAN_RATE   = no
 DEBUG_BALLER 		 = no
-DEBUG_MATRIX		 = no
+DEBUG_MATRIX		 = yes
 
 # A bunch of stuff that you shouldn't touch unless you
 # know what you're doing.

keyboards/gergo/keymaps/germ/keymap.c

@@ -0,0 +1,151 @@
+/* Good on you for modifying your layout! if you don't have 
+ * time to read the QMK docs, a list of keycodes can be found at
+ *
+ * https://github.com/qmk/qmk_firmware/blob/master/docs/keycodes.md
+ *
+ * There's also a template for adding new layers at the bottom of this file!
+ */
+
+#include QMK_KEYBOARD_H
+
+#define IGNORE_MOD_TAP_INTERRUPT
+#define BASE 0 // default layer
+#define SYMB 1 // symbols
+#define NUMB 2 // numbers/motion
+
+// Blank template at the bottom
+
+enum customKeycodes {
+	URL  = 1
+};
+
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+/* Keymap 0: Basic layer
+ *
+ * ,-------------------------------------------.                         ,-------------------------------------------.
+ * | L1/ESC |   Q  |   W  |   E  |   R  |   T  |                         |   Y  |   U  |   I  |   O  |   P  |  | \   |
+ * |--------+------+------+------+------+------|------.           .------|------+------+------+------+------+--------|
+ * |Ctrl/BS |   A  |   S  |  D   |   F  |   G  | RMB  |           |      |   H  |   J  |   K  |   L  | ;  : |  ' "   |
+ * |--------+------+------+------+------+------|------|           |------|------+------+------+------+------+--------|
+ * | LShift |   Z  |   X  |   C  |   V  |   B  | LMB  |           |      |   N  |   M  | ,  < | . >  | /  ? |  - _   |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ *                    .----------.   .-------.                                 .------.   .-----.
+ *                    | Super/Del|   |Ent/ALT|                                 | Tab  |   |BKSP |
+ *                    '----------'   '-------'                                 `------.   '-----'
+ *                                        ,-------.                      ,-------.
+ *                                        | MMB   |                      | PgDn  |
+ *                                 ,------|-------|                      |-------|------.
+ *                                 | SYMB | NUMB  |                      | SYMB  | NUMB |
+ *                                 | Space| Escape|                      | Mod   |Space |
+ *                                 |      |       |                      |       |      |
+ *                                 `--------------'                      `--------------'
+ */
+[BASE] = LAYOUT_GERGO(  
+LT(NUMB, KC_ESC),       KC_Q,  KC_W,   KC_E,   KC_R, KC_T,                       KC_Y,    KC_U, KC_I, KC_O,   KC_P,    KC_PIPE, 
+MT(MOD_LCTL, KC_BSPC),  KC_A,  KC_S,   KC_D,   KC_F, KC_G, KC_BTN2,       KC_TRNS,  KC_H,    KC_J, KC_K, KC_L,   KC_SCLN, KC_QUOT, 
+KC_RSFT,                KC_Z,  KC_X,   KC_C,   KC_V, KC_B, KC_BTN1,       KC_BSPC,  KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_MINS, 
+                                      
+			              MT(MOD_LGUI, KC_DEL), MT(MOD_LALT, KC_ENT),       KC_TAB, KC_BSPC,
+
+                                                           KC_BTN3,       KC_PGDN,
+                                LT(SYMB, KC_SPC), LT(NUMB, KC_ESC),       LT(SYMB, KC_ENT), LT(NUMB, KC_SPC)),
+/* Keymap 1: Symbols layer
+ *
+ * ,-------------------------------------------.                         ,-------------------------------------------.
+ * |        |  !   |  @   |  {   |  }   |  |   |                         |      |      |      |      |      |  \ |   |
+ * |--------+------+------+------+------+------|------.           .------|------+------+------+------+------+--------|
+ * |        |  #   |  $   |  (   |  )   |  `   |      |           |      |   +  |  -   |  /   |  *   |  %   |  ' "   |
+ * |--------+------+------+------+------+------|------|           |------|------+------+------+------+------+--------|
+ * |        |  %   |  ^   |  [   |  ]   |  ~   |      |           |      |   &  |  =   |  ,   |  .   |  / ? | - _    |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ *                        .------.   .------.                                 .------.   .-----.
+ *                        |      |   |      |                                 |      |   | DEL |
+ *                        '------'   '------'                                 `------.   '-----'
+ *                                        ,-------.                     ,-------.
+ *                                        |       |                     | PgUp  |
+ *                                 ,------|-------|                     |-------|------.
+ *                                 |      |       |                     |       |      |
+ *                                 |   ;  |   =   |                     |   =   |   ;  |
+ *                                 |      |       |                     |       |      |
+ *                                 `--------------'                     `--------------'
+ */
+[SYMB] = LAYOUT_GERGO(  
+KC_TRNS, KC_EXLM, KC_AT,  KC_LCBR,KC_RCBR, KC_PIPE,                          KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_BSLS, 
+KC_TRNS, KC_HASH, KC_DLR, KC_LPRN,KC_RPRN, KC_GRV,  KC_TRNS,       KC_TRNS,  KC_PLUS, KC_MINS, KC_SLSH, KC_ASTR, KC_PERC, KC_QUOT, 
+KC_TRNS, KC_PERC, KC_CIRC,KC_LBRC,KC_RBRC, KC_TILD, KC_TRNS,       KC_TRNS,  KC_AMPR, KC_EQL,  KC_COMM, KC_DOT,  KC_SLSH, KC_MINS, 
+
+                                                  KC_TRNS, KC_TRNS,       KC_PGUP, KC_DEL,
+                                                           KC_TRNS,       KC_TRNS,
+                                             	  KC_SCLN, KC_EQL,        KC_EQL, KC_SCLN),
+/* Keymap 2: Pad/Function layer
+ *
+ * ,-------------------------------------------.                         ,-------------------------------------------.
+ * |        |   1  |  2   |  3   |  4   |  5   |                         |  6   |  7   |  8   |  9   |  0   |        |
+ * |--------+------+------+------+------+------|------.           .------|------+------+------+------+------+--------|
+ * |  F1    |  F2  | F3   | F4   | F5   | F6   | BTN1 |           |      | LEFT | DOWN |  UP  | RIGHT|VolDn | VolUp  |
+ * |--------+------+------+------+------+------|------|           |------|------+------+------+------+------+--------|
+ * |  F7    |  F8  | F9   | F10  | F11  | F12  | BTN2 |           |      | MLFT | MDWN | MUP  | MRGHT|Ply/Pa|  Skip  |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ *                        .------.   .------.                                 .------.   .-----.
+ *                        |      |   |      |                                 |      |   |     |
+ *                        '------'   '------'                                 `------.   '-----'
+ *                                        ,-------.                     ,-------.
+ *                                        |       |                     | PgUp  |
+ *                                 ,------|-------|                     |-------|------.
+ *                                 |      |       |                     |       |      |
+ *                                 |      |       |                     |       |      |
+ *                                 |      |       |                     |       |      |
+ *                                 `--------------'                     `--------------'
+ */
+[NUMB] = LAYOUT_GERGO(  
+KC_TRNS, KC_1, 	  KC_2,    KC_3,    KC_4,    KC_5,                             KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_TRNS, 
+KC_TRNS, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,         KC_TRNS,  KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT, KC_VOLD, KC_VOLU, 
+KC_TRNS, KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,        KC_TRNS,  KC_MS_L, KC_MS_D, KC_MS_U, KC_MS_R, KC_MPLY, KC_MNXT, 
+
+                                                  KC_TRNS, KC_TRNS,       KC_PGUP, KC_TRNS,
+                                                           KC_TRNS,       KC_TRNS,
+                                             	  KC_TRNS, KC_TRNS,       KC_TRNS, KC_TRNS)
+};
+
+/* Keymap template 
+ *
+ * ,-------------------------------------------.                         ,-------------------------------------------.
+ * |        |      |      |      |      |      |                         |      |      |      |      |      |        |
+ * |--------+------+------+------+------+------|------.           .------|------+------+------+------+------+--------|
+ * |        |      |      |      |      |      |      |           |      |      |      |      |      |      |        |
+ * |--------+------+------+------+------+------|------|           |------|------+------+------+------+------+--------|
+ * |        |      |      |      |      |      |      |           |      |      |      |      |      |      |        |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ *                        .------.   .------.                                 .------.   .-----.
+ *                        |      |   |      |                                 |      |   |     |
+ *                        '------'   '------'                                 `------.   '-----'
+ *                                        ,-------.       ,-------.
+ *                                        |       |       |       |
+ *                                 ,------|-------|       |-------|------.
+ *                                 |      |       |       |       |      |
+ *                                 |      |       |       |       |      |
+ *                                 |      |       |       |       |      |
+ *                                 `--------------'       `--------------'
+[SYMB] = LAYOUT_GERGO(  
+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, 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),
+ */
+
+// Runs just one time when the keyboard initializes.
+void matrix_init_user(void) {
+
+};
+
+// Runs constantly in the background, in a loop.
+void matrix_scan_user(void) {
+    //uint8_t layer = biton32(layer_state);
+    biton32(layer_state);
+};
+
+

keyboards/gergo/keymaps/germ/readme.md

@@ -0,0 +1,10 @@
+# [Gergo! By g Heavy Industries](http://gboards.ca)
+
+![Gergo image](https://4.bp.blogspot.com/-889nMXxgSM0/XCNxwnO5kUI/AAAAAAAA6mI/tZbWgZVCBW0dyZOCGJDkjN06DVax7j8XwCLcBGAs/s1600/48422820_967732713413298_485744639215665152_n.jpg)
+
+This is the default keymap for Gergo, it's based heavily off of the naps62 ErgoDox layout and is aimed at a programmer friendly keymap.
+
+## Settings
+To edit various settings, enable the 1u trackball and whatnot please modify /keyboards/gergo/keymaps/default/rules.mk
+
+Ideally you should copy this directory and make your changes there. If you come up with a good layout submit a PR!

keyboards/gergo/keymaps/germ/rules.mk

@@ -0,0 +1,36 @@
+#----------------------------------------------------------------------------
+# make gergo:germ:dfu
+# Make sure you have dfu-programmer installed!
+#----------------------------------------------------------------------------
+# Firmware options
+BALLER = yes 			# Enable to ball out
+BALLSTEP = 20  			# Multiple in px to move, multiplied by layer number
+SCROLLSTEP = 1 			# Lines to scroll with ball
+MOUSEKEY_ENABLE = yes  		# Mouse keys(+4700), needed for baller
+
+#Debug options
+VERBOSE 		 = yes
+DEBUG_MATRIX_SCAN_RATE   = no
+DEBUG_BALLER 		 = no
+DEBUG_MATRIX		 = no
+
+# A bunch of stuff that you shouldn't touch unless you
+# know what you're doing.
+#
+# No touchy, capiche?
+SRC += matrix.c i2c_master.c
+ifneq ($(strip $(BALLSTEP)),)
+    OPT_DEFS += -DTRKSTEP=$(strip $(BALLSTEP))
+endif
+ifneq ($(strip $(SCROLLSTEP)),)
+    OPT_DEFS += -DSCROLLSTEP=$(strip $(SCROLLSTEP))
+endif
+ifeq ($(strip $(BALLER)), yes)
+    OPT_DEFS += -DBALLER
+endif
+ifeq ($(strip $(DEBUG_BALLER)), yes)
+    OPT_DEFS += -DDEBUG_BALLER
+endif
+ifeq ($(strip $(DEBUG_MATRIX)), yes)
+    OPT_DEFS += -DDEBUG_MATRIX
+endif

keyboards/handwired/frenchdev/info.json

@@ -4,7 +4,7 @@
   "maintainer": "qmk",
   "bootloader": "",
   "width": 20,
-  "height": 8,
+  "height": 9.5,
   "layouts": {
     "LAYOUT": {
       "layout": [

keyboards/handwired/not_so_minidox/info.json

@@ -2,7 +2,7 @@
   "keyboard_name": "Not So MiniDox",
   "url": "",
   "maintainer": "qmk",
-  "width": 12,
+  "width": 14,
   "height": 5.75,
   "layouts": {
     "LAYOUT": {

keyboards/handwired/ortho5x13/info.json

@@ -3,7 +3,7 @@
     "url": "",
     "maintainer": "qmk",
     "width": 13,
-    "height": 6,
+    "height": 5,
     "layouts": {
         "LAYOUT": {
             "layout": [

keyboards/handwired/prime_exl/info.json

@@ -2,8 +2,8 @@
   "keyboard_name": "Prime_EXL",
   "url": "https://www.primekb.com",
   "maintainer": "holtenc",
-  "width": 18,
-  "height": 5,
+  "width": 20.75,
+  "height": 6,
   "layouts": {
       "LAYOUT": {
           "layout": [{"x":0,"y":0,"w":1,"h":1}, {"x":1,"y":0,"w":1,"h":1}, {"x":2,"y":0,"w":1,"h":1}, {"x":3,"y":0,"w":1,"h":1}, {"x":4,"y":0,"w":1,"h":1}, {"x":5,"y":0,"w":1,"h":1}, {"x":6.5,"y":0,"w":1,"h":1}, {"x":7.5,"y":0,"w":1,"h":1}, {"x":8.5,"y":0,"w":1,"h":1}, {"x":9.5,"y":0,"w":1,"h":1}, {"x":10.5,"y":0,"w":1,"h":1}, {"x":11.5,"y":0,"w":1,"h":1}, {"x":13.75,"y":0,"w":1,"h":1}, {"x":14.75,"y":0,"w":1,"h":1}, {"x":15.75,"y":0,"w":1,"h":1}, {"x":16.75,"y":0,"w":1,"h":1}, {"x":17.75,"y":0,"w":1,"h":1}, {"x":18.75,"y":0,"w":2,"h":1}, {"x":0,"y":1,"w":1,"h":1}, {"x":1,"y":1,"w":1,"h":1}, {"x":2,"y":1,"w":1,"h":1}, {"x":3,"y":1,"w":1,"h":1}, {"x":4,"y":1,"w":1,"h":1}, {"x":5,"y":1,"w":1,"h":1}, {"x":6.5,"y":1,"w":1.26,"h":1}, {"x":7.75,"y":1,"w":1,"h":1}, {"x":8.75,"y":1,"w":1,"h":1}, {"x":9.75,"y":1,"w":1,"h":1}, {"x":10.75,"y":1,"w":1,"h":1}, {"x":11.75,"y":1,"w":1,"h":1}, {"x":14,"y":1,"w":1,"h":1}, {"x":15,"y":1,"w":1,"h":1}, {"x":16,"y":1,"w":1,"h":1}, {"x":17,"y":1,"w":1,"h":1}, {"x":18,"y":1,"w":1,"h":1}, {"x":19,"y":1,"w":1.75,"h":1}, {"x":0,"y":2,"w":1,"h":1}, {"x":1,"y":2,"w":1,"h":1}, {"x":2,"y":2,"w":1,"h":1}, {"x":3,"y":2,"w":1,"h":1}, {"x":4,"y":2,"w":1,"h":1}, {"x":5,"y":2,"w":1,"h":1}, {"x":6.5,"y":2,"w":1.75,"h":1}, {"x":8.25,"y":2,"w":1,"h":1}, {"x":9.25,"y":2,"w":1,"h":1}, {"x":10.25,"y":2,"w":1,"h":1}, {"x":11.25,"y":2,"w":1,"h":1}, {"x":12.25,"y":2,"w":1,"h":1}, {"x":13.5,"y":2,"w":1,"h":1}, {"x":14.5,"y":2,"w":1,"h":1}, {"x":15.5,"y":2,"w":1,"h":1}, {"x":16.5,"y":2,"w":1,"h":1}, {"x":17.5,"y":2,"w":1,"h":1}, {"x":18.5,"y":2,"w":1,"h":1}, {"x":19.5,"y":2,"w":1.25,"h":1}, {"x":0,"y":3,"w":1,"h":1}, {"x":1,"y":3,"w":1,"h":1}, {"x":2,"y":3,"w":1,"h":1}, {"x":3,"y":3,"w":1,"h":1}, {"x":4,"y":3,"w":1,"h":1}, {"x":5,"y":3,"w":1,"h":1}, {"x":6.5,"y":3,"w":1.25,"h":1}, {"x":7.75,"y":3,"w":1.25,"h":1}, {"x":9,"y":3,"w":1,"h":1}, {"x":10,"y":3,"w":1,"h":1}, {"x":11,"y":3,"w":2,"h":1}, {"x":13.5,"y":3,"w":2,"h":1}, {"x":15.5,"y":3,"w":1,"h":1}, {"x":16.5,"y":3,"w":1,"h":1}, {"x":17.5,"y":3,"w":1.5,"h":1}, {"x":19,"y":3,"w":1.5,"h":1}, {"x":0,"y":4,"w":1,"h":1}, {"x":1,"y":4,"w":1,"h":1}, {"x":2,"y":4,"w":1,"h":1}, {"x":3,"y":4,"w":1,"h":1}, {"x":4,"y":4,"w":1,"h":1}, {"x":5,"y":4,"w":1,"h":1}]

keyboards/handwired/promethium/info.json

@@ -3,7 +3,7 @@
   "url": "",
   "maintainer": "qmk",
   "width": 16,
-  "height": 5,
+  "height": 4.5,
   "layouts": {
     "LAYOUT": {
       "layout": [

keyboards/handwired/tradestation/info.json

@@ -3,7 +3,7 @@
     "url": "",
     "maintainer": "Flehrad",
     "width": 4.375,
-    "height": 4.375,
+    "height": 4.5,
     "layouts": {
         "LAYOUT_tradestation": {
             "layout": [{"x":0, "y":0},{"x":1.125, "y":0},{"x":2.25, "y":0},{"x":3.375, "y":0},{"x":0, "y":1.1},{"x":1.125, "y":1.1},{"x":2.25, "y":1.1},{"x":3.375, "y":1.1},{"x":0, "y":2.25, "w":2},{"x":2.25, "y":2.25, "w":2},{"x":0, "y":3.5, "w":2},{"x":2.25, "y":3.5, "w":2}]

keyboards/kbdfans/kbd4x/info.json

@@ -2,7 +2,7 @@
     "keyboard_name": "kbd4x",
     "url": "",
     "maintainer": "qmk",
-    "width": 14,
+    "width": 12,
     "height": 4,
     "layouts": {
         "LAYOUT_planck_mit": {

keyboards/keebio/iris/info.json

@@ -2,8 +2,8 @@
     "keyboard_name": "Iris",
     "url": "https://keeb.io",
     "maintainer": "Keebio",
-    "width": 14.5,
-    "height": 5,
+    "width": 15,
+    "height": 5.75,
     "layouts": {
         "LAYOUT": {
             "layout": [

keyboards/orthodox/rev1/info.json

@@ -1,8 +1,8 @@
 {
   "keyboard_name": "Monkeebs Orthodox Rev.1",
   "maintainer": "drashna",
-  "width": 17,
-  "height": 17.24,
+  "width": 19,
+  "height": 5,
   "layouts": {
     "LAYOUT": {
       "layout": [

keyboards/orthodox/rev3/info.json

@@ -1,8 +1,8 @@
 {
   "keyboard_name": "Monkeebs Orthodox Rev.3",
   "maintainer": "drashna",
-  "width": 17,
-  "height": 17.24,
+  "width": 19,
+  "height": 5,
   "layouts": {
     "LAYOUT": {
       "layout": [

keyboards/orthodox/rev3_teensy/info.json

@@ -1,8 +1,8 @@
 {
   "keyboard_name": "Monkeebs Orthodox Rev.3 (Teensy)",
   "maintainer": "drashna",
-  "width": 17,
-  "height": 17.24,
+  "width": 19,
+  "height": 5,
   "layouts": {
     "LAYOUT": {
       "layout": [

keyboards/planck/keymaps/roguepullrequest/config.h

@@ -0,0 +1,8 @@
+#pragma once
+
+
+
+
+#ifdef AUDIO_ENABLE
+	#define STARTUP_SONG SONG(RICK_ROLL)
+#endif

keyboards/planck/keymaps/roguepullrequest/keymap.c

@@ -0,0 +1,183 @@
+#include QMK_KEYBOARD_H
+
+#ifdef AUDIO_ENABLE
+	float mushroom[][2] = SONG(MARIO_MUSHROOM);
+#endif
+
+extern keymap_config_t keymap_config;
+
+// Complex Tapdance hoopla
+typedef struct {
+	bool is_press_action;
+	int state;
+} tap;
+
+enum {
+	SINGLE_TAP = 1,
+	SINGLE_HOLD = 2,
+	DOUBLE_TAP = 3,
+	DOUBLE_HOLD = 4,
+	TRIPLE_TAP = 5,
+	TRIPLE_HOLD = 6,
+};
+
+// Tap dance enums
+enum {
+	X_AT_FUN = 0,
+	SH_M_LPAREN,
+	SH_M_RPAREN
+};
+
+int cur_dance (qk_tap_dance_state_t *state);
+
+void x_finished (qk_tap_dance_state_t *state, void *user_data);
+void x_reset (qk_tap_dance_state_t *state, void *user_data);
+
+bool is_alt_tab_active = false;
+uint16_t alt_tab_timer = 0;
+
+// Modified Programmer Dvorak enums
+
+enum planck_layers {
+	_PDVORAK,
+	_UPPER,
+	_LOWER,
+	_FUNCTION,
+};
+
+enum custom_keycodes {
+	PDVK = SAFE_RANGE,
+	KC_LAST,
+	ALT_TAB
+};
+
+// For getting the last arg in shell line (SUPER THANKS to Drashna over on Discord)
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  static uint16_t macro_timer;
+
+  switch (keycode) {
+    case ALT_TAB:
+      if (record->event.pressed) {
+        if (!is_alt_tab_active) {
+          is_alt_tab_active = true;
+          register_code(KC_LALT);
+        }
+        alt_tab_timer = timer_read();
+        register_code(KC_TAB);
+      } else {
+        unregister_code(KC_TAB);
+      }
+      break;
+  }
+
+  switch (keycode){
+    case KC_LAST:
+      if(record->event.pressed){
+        macro_timer = timer_read();
+        register_mods(MOD_BIT(KC_LCTRL));
+      } else {
+        unregister_mods(MOD_BIT(KC_LCTRL));
+        if (timer_elapsed(macro_timer) < 150) {
+          SEND_STRING("!$");
+        }
+      }
+    return false;
+  }
+  return true;
+}
+
+void matrix_scan_user(void) {
+  if (is_alt_tab_active) {
+    if (timer_elapsed(alt_tab_timer) > 1000) {
+      unregister_code16(KC_LALT);
+      is_alt_tab_active = false;
+    }
+  }
+}
+
+#define PDVORAK MO(_PDVORAK)
+#define LOWER MO(_LOWER)
+#define UPPER MO(_UPPER)
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+/* Programmer Dvorak */
+	[_PDVORAK] = LAYOUT_planck_grid(
+		KC_GESC, KC_SCOLON, KC_COMMA, KC_DOT, KC_P, KC_Y, KC_F, KC_G, KC_C, KC_R, KC_L, KC_BSPC,
+   		KC_LAST, KC_A, KC_O, KC_E, KC_U, KC_I, KC_D, KC_H, KC_T, KC_N, KC_S, KC_SLASH,
+   		KC_LSPO, KC_QUOT, KC_Q, KC_J, KC_K, KC_X, KC_B, KC_M, KC_W, KC_V, KC_Z, KC_RSPC,
+    		TD(X_AT_FUN), KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT, ALT_TAB, KC_SPACE, KC_ENTER, MT(MOD_LCTL | MOD_LSFT, KC_LGUI), KC_PGUP, KC_PGDN, LT(_LOWER, KC_PLUS)
+   	),
+	
+	[_UPPER] = LAYOUT_planck_grid(
+		KC_GRAVE, KC_AMPR, KC_PERC, KC_LBRC, KC_LCBR, KC_EQL, KC_ASTR, KC_RCBR, KC_RBRC, KC_EXLM, KC_HASH, KC_TRNS,
+		KC_PLUS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_MINUS, KC_BSLASH, 
+		KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
+		KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_TRNS
+	),
+
+	[_LOWER] = LAYOUT_planck_grid(
+		KC_DLR, KC_7, KC_5, KC_3, KC_1, KC_9, KC_0, KC_2, KC_4, KC_6, KC_8, KC_TRNS,
+		KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
+		KC_NO, CK_DOWN, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
+		KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_TRNS
+	),
+
+	[_FUNCTION] = LAYOUT_planck_grid(
+		KC_F11, KC_F7, KC_F5, KC_F3, KC_F1, KC_F9, KC_F12, KC_F2, KC_F4, KC_F6, KC_F8, RESET,
+		KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
+		KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
+		KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_TRNS
+	),
+};
+
+
+// Super crazy tap dancing stuff - see quad dance in feature_tap_dance.md
+
+int cur_dance (qk_tap_dance_state_t *state) {
+	if (state->count == 1) {
+		if (state->interrupted || !state->pressed) return SINGLE_TAP;
+		// key not interrupted, but still held sends 'HOLD'
+		else return SINGLE_HOLD;
+	}
+	else if (state->count == 2) {
+		if (state->interrupted || !state->pressed) return DOUBLE_TAP;
+		else return DOUBLE_HOLD;
+	}
+	else return 8; // magic number that i dont believe works. 
+}
+
+// instance of tap for the 'X' dance.
+static tap xtap_state = {
+	.is_press_action = true,
+	.state = 0
+};
+
+// registering keypresses
+void x_finished (qk_tap_dance_state_t *state, void *user_data) {
+	xtap_state.state = cur_dance(state);
+	switch (xtap_state.state) {
+		case SINGLE_TAP: register_code16(KC_AT); break;
+		case SINGLE_HOLD: set_oneshot_layer(_UPPER, ONESHOT_START); break;
+		case DOUBLE_TAP: set_oneshot_layer(_FUNCTION, ONESHOT_START); break;
+		case DOUBLE_HOLD: reset_keyboard(); break;
+	}
+}
+// forgetting keypresses
+
+void x_reset (qk_tap_dance_state_t *state, void *user_data) {
+	switch (xtap_state.state) {
+		case SINGLE_TAP: unregister_code16(KC_AT); break;
+		case SINGLE_HOLD: clear_oneshot_layer_state(ONESHOT_PRESSED); break;
+		case DOUBLE_TAP: clear_oneshot_layer_state(ONESHOT_PRESSED); break;
+		case DOUBLE_HOLD: reset_keyboard(); break;
+	}
+	xtap_state.state = 0;
+}
+
+qk_tap_dance_action_t tap_dance_actions[] = {
+	[X_AT_FUN] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, x_finished, x_reset)
+};
+
+void shutdown_user(void) { clear_keyboard(); }

keyboards/planck/keymaps/roguepullrequest/readme.md

@@ -0,0 +1,15 @@
+# Programmer Dvorak for the Planck (Light)
+
+
+| Magic    |         | UPPER |
+|----------|---------|-------|
+|          | DEFAULT |       |
+| FUNCTION |         | LOWER |
+
+# Layout notes
+-  ALT_TAB = cycle through windows as long as you keep tapping it keeps alt tabbing
+-  LAST = "!$" = is useful for using the last parm in bash/zsh 
+-  More to come
+
+
+# Dvorak base Layer

keyboards/planck/keymaps/roguepullrequest/rules.mk

@@ -0,0 +1,4 @@
+AUDIO_ENABLE = yes
+COMMAND_ENABLE = no
+TERMINAL_ENABLE = no
+TAP_DANCE_ENABLE = yes

keyboards/qwertyydox/info.json

@@ -5,8 +5,8 @@
   "url": "",
   "maintainer": "qmk",
   "processor": "atmega32u4",
-  "width": 14,
-  "height": 4,
+  "width": 16,
+  "height": 5,
   "layouts": {
     "LAYOUT": {
       "key_count": 53,

keyboards/sol/keymaps/kageurufu/rules.mk

@@ -4,14 +4,15 @@
 #
 BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration(+1000)
 MOUSEKEY_ENABLE = no        # Mouse keys(+4700)
+
 EXTRAKEY_ENABLE = yes       # Audio control and System control(+450)
 CONSOLE_ENABLE = yes        # Console for debug(+400)
 COMMAND_ENABLE = yes        # 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
-RGBLIGHT_ENABLE = yes       # Enable global lighting effects. Do not enable with RGB Matrix
-LED_ANIMATIONS = yes        # LED animations
+RGBLIGHT_ENABLE = no        # Enable global lighting effects. Do not enable with RGB Matrix
+RGBLIGHT_ANIMATIONS = no    # LED animations
 LED_MIRRORED = no           # Mirror LEDs across halves (enable DIP 1 on slave, and DIP 2 and 3 on master)
-RGB_MATRIX_ENABLE = no      # Enable per-key coordinate based RGB effects. Do not enable with RGBlight (+8500)
+RGB_MATRIX_ENABLE = WS2812  # Enable per-key coordinate based RGB effects. Do not enable with RGBlight (+8500)
 RGB_MATRIX_KEYPRESSES = no  # Enable reactive per-key effects. Can be very laggy (+1500)
 RGBLIGHT_FULL_POWER = no    # Allow maximum RGB brightness. Otherwise, limited to a safe level for a normal USB-A port
 UNICODE_ENABLE = no         # Unicode

keyboards/sol/rev1/config.h

@@ -81,8 +81,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define ws2812_PORTREG  PORTD
 #define ws2812_DDRREG   DDRD
 
-#define DRIVER_COUNT      2
-#define DRIVER_LED_TOTAL  70
+#define DRIVER_COUNT      1
 // #define RGB_MATRIX_KEYPRESSES
 #define BACKLIGHT_PIN B7
 #define BACKLIGHT_LEVELS 5
@@ -92,6 +91,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #else
   #define RGBLED_NUM 70
 #endif
+#define DRIVER_LED_TOTAL  RGBLED_NUM
 
 #define RGBLIGHT_RAINBOW_SWIRL_RANGE 1950
 
@@ -112,6 +112,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #define RGBLIGHT_ANIMATIONS
 
+#define LED_HITS_TO_REMEMBER 5
+
 #if defined(RGBLIGHT_ENABLE) && !defined(IOS_DEVICE_ENABLE)
 // USB_MAX_POWER_CONSUMPTION value for Helix keyboard
 //  120  RGBoff, OLEDoff

keyboards/sol/rev1/rev1.c

@@ -1,6 +1,5 @@
 #include "sol.h"
 
-
 #ifdef SSD1306OLED
 void led_set_kb(uint8_t usb_led) {
     // put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
@@ -8,8 +7,88 @@ void led_set_kb(uint8_t usb_led) {
 }
 #endif
 
-void matrix_init_kb(void) {
+#ifdef RGB_MATRIX_ENABLE
+  const rgb_led g_rgb_leds[DRIVER_LED_TOTAL] = {
+	// Left Hand Mapped Left to Right
+    { {  0 | (0 << 4) }, {   0,  0 }, 1},
+    { {  0 | (1 << 4) }, {  22,  0 }, 0},
+    { {  0 | (2 << 4) }, {  37,  0 }, 0},
+    { {  0 | (3 << 4) }, {  37,  0 }, 0},
+    { {  0 | (4 << 4) }, {  67,  0 }, 0},
+    { {  0 | (5 << 4) }, {  82,  0 }, 0},
+    { {  0 | (6 << 4) }, { 104,  0 }, 1},
+    { {  1 | (0 << 4) }, {   0, 16 }, 1},
+    { {  1 | (1 << 4) }, {  22, 16 }, 0},
+    { {  1 | (2 << 4) }, {  37, 16 }, 0},
+    { {  1 | (3 << 4) }, {  37, 16 }, 0},
+    { {  1 | (4 << 4) }, {  67, 16 }, 0},
+    { {  1 | (5 << 4) }, {  82, 16 }, 0},
+    { {  1 | (6 << 4) }, { 104, 16 }, 1},
+    { {  2 | (0 << 4) }, {   0, 32 }, 1},
+    { {  2 | (1 << 4) }, {  22, 32 }, 0},
+    { {  2 | (2 << 4) }, {  37, 32 }, 0},
+    { {  2 | (3 << 4) }, {  37, 32 }, 0},
+    { {  2 | (4 << 4) }, {  67, 32 }, 0},
+    { {  2 | (5 << 4) }, {  82, 32 }, 0},
+    { {  2 | (6 << 4) }, { 104, 32 }, 1},
+    { {  3 | (0 << 4) }, {   0, 48 }, 1},
+    { {  3 | (1 << 4) }, {  22, 48 }, 0},
+    { {  3 | (2 << 4) }, {  37, 48 }, 0},
+    { {  3 | (3 << 4) }, {  37, 48 }, 0},
+    { {  3 | (4 << 4) }, {  67, 48 }, 0},
+    { {  3 | (5 << 4) }, {  82, 48 }, 0},
+    { {  3 | (6 << 4) }, { 104, 48 }, 1},
+    { {  4 | (0 << 4) }, {   0, 64 }, 1},
+    { {  4 | (1 << 4) }, {  22, 64 }, 1},
+    { {  4 | (2 << 4) }, {  37, 64 }, 1},
+    { {  4 | (3 << 4) }, {  37, 64 }, 1},
+    { {  4 | (4 << 4) }, {  67, 64 }, 1},
+	// These two control the 4 LEDs in the thumb cluster
+	// Top keys are {  4 | (5 << 4) & {  4 | (6 << 4)
+    { {  5 | (5 << 4) }, {  89, 45 }, 1},
+    { {  5 | (6 << 4) }, {  97, 55 }, 1},
+	// Left Hand Mapped Right to Left
+    { {  6 | (0 << 4) }, { 224,  0 }, 1},
+    { {  6 | (1 << 4) }, { 202,  0 }, 0},
+    { {  6 | (2 << 4) }, { 187,  0 }, 0},
+    { {  6 | (3 << 4) }, { 172,  0 }, 0},
+    { {  6 | (4 << 4) }, { 157,  0 }, 0},
+    { {  6 | (5 << 4) }, { 142,  0 }, 0},
+    { {  6 | (6 << 4) }, { 120,  0 }, 1},
+    { {  7 | (0 << 4) }, { 224, 16 }, 1},
+    { {  7 | (1 << 4) }, { 202, 16 }, 0},
+    { {  7 | (2 << 4) }, { 187, 16 }, 0},
+    { {  7 | (3 << 4) }, { 172, 16 }, 0},
+    { {  7 | (4 << 4) }, { 157, 16 }, 0},
+    { {  7 | (5 << 4) }, { 142, 16 }, 0},
+    { {  7 | (6 << 4) }, { 120, 16 }, 1},
+    { {  8 | (0 << 4) }, { 224, 32 }, 1},
+    { {  8 | (1 << 4) }, { 202, 32 }, 0},
+    { {  8 | (2 << 4) }, { 187, 32 }, 0},
+    { {  8 | (3 << 4) }, { 172, 32 }, 0},
+    { {  8 | (4 << 4) }, { 157, 32 }, 0},
+    { {  8 | (5 << 4) }, { 142, 32 }, 0},
+    { {  8 | (6 << 4) }, { 120, 32 }, 1},
+    { {  9 | (0 << 4) }, { 224, 48 }, 1},
+    { {  9 | (1 << 4) }, { 202, 48 }, 0},
+    { {  9 | (2 << 4) }, { 187, 48 }, 0},
+    { {  9 | (3 << 4) }, { 172, 48 }, 0},
+    { {  9 | (4 << 4) }, { 157, 48 }, 0},
+    { {  9 | (5 << 4) }, { 142, 48 }, 0},
+    { {  9 | (6 << 4) }, { 120, 48 }, 1},
+    { { 10 | (0 << 4) }, { 224, 64 }, 1},
+    { { 10 | (1 << 4) }, { 202, 64 }, 1},
+    { { 10 | (2 << 4) }, { 187, 64 }, 1},
+    { { 10 | (3 << 4) }, { 172, 64 }, 1},
+    { { 10 | (4 << 4) }, { 157, 64 }, 1},
+	// These two control the 4 LEDs in the thumb cluster
+	// Top keys are { 10 | (5 << 4) & { 10 | (6 << 4)
+    { { 11 | (5 << 4) }, { 135, 45 }, 1},
+    { { 11 | (6 << 4) }, { 127, 55 }, 1}
+  };
+#endif
 
+void matrix_init_kb(void) {
 	matrix_init_user();
 };
 

keyboards/speedo/info.json

@@ -4,7 +4,7 @@
   "maintainer": "qmk",
   "bootloader": "",
   "width": 15,
-  "height": 6,
+  "height": 6.5,
   "layouts": {
     "LAYOUT": {
       "layout": [{"label":"k00", "x":0, "y":0.375}, {"label":"k01", "x":1, "y":0.375}, {"label":"k02", "x":2, "y":0.25}, {"label":"k03", "x":3, "y":0}, {"label":"k04", "x":4, "y":0.25}, {"label":"k05", "x":5, "y":0.5}, {"label":"k06", "x":9, "y":0.5}, {"label":"k07", "x":10, "y":0.25}, {"label":"k08", "x":11, "y":0}, {"label":"k09", "x":12, "y":0.25}, {"label":"k10", "x":13, "y":0.375}, {"label":"k11", "x":14, "y":0.375}, {"label":"k12", "x":0, "y":1.375}, {"label":"k13", "x":1, "y":1.375}, {"label":"k14", "x":2, "y":1.25}, {"label":"k15", "x":3, "y":1}, {"label":"k16", "x":4, "y":1.25}, {"label":"k17", "x":5, "y":1.5}, {"label":"k18", "x":7, "y":2}, {"label":"k19", "x":9, "y":1.5}, {"label":"k20", "x":10, "y":1.25}, {"label":"k21", "x":11, "y":1}, {"label":"k22", "x":12, "y":1.25}, {"label":"k23", "x":13, "y":1.375}, {"label":"k24", "x":14, "y":1.375}, {"label":"k25", "x":0, "y":2.375}, {"label":"k26", "x":1, "y":2.375}, {"label":"k27", "x":2, "y":2.25}, {"label":"k28", "x":3, "y":2}, {"label":"k29", "x":4, "y":2.25}, {"label":"k30", "x":5, "y":2.5}, {"label":"k31", "x":7, "y":3}, {"label":"k32", "x":9, "y":2.5}, {"label":"k33", "x":10, "y":2.25}, {"label":"k34", "x":11, "y":2}, {"label":"k35", "x":12, "y":2.25}, {"label":"k36", "x":13, "y":2.375}, {"label":"k37", "x":14, "y":2.375}, {"label":"k38", "x":0, "y":3.375}, {"label":"k39", "x":1, "y":3.375}, {"label":"k40", "x":2, "y":3.25}, {"label":"k41", "x":3, "y":3}, {"label":"k42", "x":4, "y":3.25}, {"label":"k43", "x":5, "y":3.5}, {"label":"k44", "x":6.5, "y":4}, {"label":"k45", "x":7.5, "y":4}, {"label":"k46", "x":9, "y":3.5}, {"label":"k47", "x":10, "y":3.25}, {"label":"k48", "x":11, "y":3}, {"label":"k49", "x":12, "y":3.25}, {"label":"k50", "x":13, "y":3.375}, {"label":"k51", "x":14, "y":3.375}, {"label":"k52", "x":0, "y":4.375}, {"label":"k53", "x":1, "y":4.375}, {"label":"k54", "x":2, "y":4.25}, {"label":"k55", "x":3, "y":4}, {"label":"k56", "x":4, "y":4.25}, {"label":"k57", "x":5.5, "y":5}, {"label":"k58", "x":6.5, "y":5.5}, {"label":"k59", "x":7.5, "y":5.5}, {"label":"k60", "x":8.5, "y":5}, {"label":"k61", "x":10, "y":4.25}, {"label":"k62", "x":11, "y":4}, {"label":"k63", "x":12, "y":4.25}, {"label":"k64", "x":13, "y":4.375}, {"label":"k65", "x":14, "y":4.375}]

keyboards/xd87/info.json

@@ -3,7 +3,7 @@
   "url": "",
   "maintainer": "qmk",
   "width": 18.25,
-  "height": 7.25,
+  "height": 6.25,
   "layouts": {
     "LAYOUT_all": {
       "layout": [

quantum/process_keycode/process_combo.c

@@ -126,13 +126,13 @@ static bool process_single_combo(combo_t *combo, uint16_t keycode,
 bool process_combo(uint16_t keycode, keyrecord_t *record) {
   bool is_combo_key = false;
   drop_buffer = false;
-  bool no_combo_keys_pressed = false;
+  bool no_combo_keys_pressed = true;
 
   for (current_combo_index = 0; current_combo_index < COMBO_COUNT;
        ++current_combo_index) {
     combo_t *combo = &key_combos[current_combo_index];
     is_combo_key |= process_single_combo(combo, keycode, record);
-    no_combo_keys_pressed |= NO_COMBO_KEYS_ARE_DOWN;
+    no_combo_keys_pressed = no_combo_keys_pressed && NO_COMBO_KEYS_ARE_DOWN;
   }
 
   if (drop_buffer) {

quantum/quantum.c

@@ -850,6 +850,26 @@ const bool ascii_to_shift_lut[0x80] PROGMEM = {
     0, 0, 0, 1, 1, 1, 1, 0
 };
 
+__attribute__ ((weak))
+const bool ascii_to_altgr_lut[0x80] PROGMEM = {
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0
+};
+
 __attribute__ ((weak))
 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
     0, 0, 0, 0, 0, 0, 0, 0,
@@ -931,16 +951,22 @@ void send_string_with_delay_P(const char *str, uint8_t interval) {
 }
 
 void send_char(char ascii_code) {
-  uint8_t keycode;
-  keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
-  if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
-      register_code(KC_LSFT);
-      register_code(keycode);
-      unregister_code(keycode);
-      unregister_code(KC_LSFT);
-  } else {
-      register_code(keycode);
-      unregister_code(keycode);
+  uint8_t keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
+  bool is_shifted = pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code]);
+  bool is_altgred = pgm_read_byte(&ascii_to_altgr_lut[(uint8_t)ascii_code]);
+
+  if (is_shifted) {
+    register_code(KC_LSFT);
+  }
+  if (is_altgred) {
+    register_code(KC_RALT);
+  }
+  tap_code(keycode);
+  if (is_altgred) {
+    unregister_code(KC_RALT);
+  }
+  if (is_shifted) {
+    unregister_code(KC_LSFT);
   }
 }
 

quantum/quantum.h

@@ -206,6 +206,7 @@ extern uint32_t default_layer_state;
 
 #define SEND_STRING(str) send_string_P(PSTR(str))
 extern const bool ascii_to_shift_lut[0x80];
+extern const bool ascii_to_altgr_lut[0x80];
 extern const uint8_t ascii_to_keycode_lut[0x80];
 void send_string(const char *str);
 void send_string_with_delay(const char *str, uint8_t interval);

quantum/rgb_matrix.h

@@ -28,9 +28,11 @@
 #ifdef IS31FL3731
   #include "is31fl3731.h"
 #elif defined (IS31FL3733)
-    #include "is31fl3733.h"
+  #include "is31fl3733.h"
 #elif defined (IS31FL3737)
-    #include "is31fl3737.h"
+  #include "is31fl3737.h"
+#elif defined (WS2812)
+  #include "ws2812.h"
 #endif
 
 #ifndef RGB_MATRIX_LED_FLUSH_LIMIT

quantum/rgb_matrix_drivers.c

@@ -97,4 +97,25 @@ const rgb_matrix_driver_t rgb_matrix_driver = {
 };
 #endif
 
+#elif defined(WS2812)
+
+extern LED_TYPE led[RGBLED_NUM];
+
+  static void flush( void )
+  {
+    // Assumes use of RGB_DI_PIN
+    ws2812_setleds(led, RGBLED_NUM);
+  }
+
+  static void init( void )
+  {
+
+  }
+
+  const rgb_matrix_driver_t rgb_matrix_driver = {
+      .init = init,
+      .flush = flush,
+      .set_color = ws2812_setled,
+      .set_color_all = ws2812_setled_all,
+  };
 #endif

quantum/rgblight.c

@@ -63,7 +63,11 @@ const uint16_t RGBLED_GRADIENT_RANGES[] PROGMEM = {360, 240, 180, 120, 90};
 rgblight_config_t rgblight_config;
 bool is_rgblight_initialized = false;
 
+#ifndef LED_ARRAY
 LED_TYPE led[RGBLED_NUM];
+  #define LED_ARRAY led
+#endif
+
 bool rgblight_timer_enabled = false;
 
 static uint8_t clipping_start_pos = 0;

tmk_core/protocol/arm_atsam/usb/udi_hid_kbd.c

@@ -109,9 +109,9 @@ UDC_DESC_STORAGE udi_hid_kbd_report_desc_t udi_hid_kbd_report_desc = {
         0x81, 0x02,     //   Input (Data, Variable, Absolute)
         0x81, 0x01,     //   Input (Constant)
         0x19, 0x00,     //   Usage Minimum (0)
-        0x29, 0x65,     //   Usage Maximum (101)
+        0x29, 0xFF,     //   Usage Maximum (255)
         0x15, 0x00,     //   Logical Minimum (0)
-        0x25, 0x65,     //   Logical Maximum (101)
+        0x25, 0xFF,     //   Logical Maximum (255)
         0x75, 0x08,     //   Report Size (8)
         0x95, 0x06,     //   Report Count (6)
         0x81, 0x00,     //   Input (Data, Array)

users/kageurufu/rules.mk

@@ -11,5 +11,5 @@ MOUSEKEY_ENABLE = no
 EXTRAKEY_ENABLE = yes
 COMMAND_ENABLE = yes
 CONSOLE_ENABLE = yes
-RGBLIGHT_ENABLE = yes
+RGBLIGHT_ENABLE = no
 RGBLIGHT_ANIMATIONS = yes

util/atmega32a_program.py

@@ -19,18 +19,19 @@ from __future__ import print_function
 import os
 import sys
 import time
+import argparse
 import usb
 
 
-def checkForKeyboardInNormalMode():
+def check_keyboard_normal_mode(vendor, product):
     """Returns a device if a ps2avrGB device in normal made (that is in keyboard mode) or None if it is not found."""
-    return usb.core.find(idVendor=0x20A0, idProduct=0x422D)
+    return usb.core.find(idVendor=vendor, idProduct=product)
 
-def checkForKeyboardInBootloaderMode():
+def check_keyboard_bootloader_mode():
     """Returns True if a ps2avrGB device in bootloader (flashable) mode is found and False otherwise."""
     return (usb.core.find(idVendor=0x16c0, idProduct=0x05df) is not None)
 
-def flashKeyboard(firmware_file):
+def flash_keyboard(firmware_file):
     """Calls bootloadHID to flash the given file to the device."""
     print('Flashing firmware to device ...')
     if os.system('bootloadHID -r "%s"' % firmware_file) == 0:
@@ -38,7 +39,7 @@ def flashKeyboard(firmware_file):
     else:
         print('\nbootloadHID returned an error.')
 
-def printDeviceInfo(dev):
+def print_device_info(dev):
     """Prints all infos for a given USB device"""
     print('Device Information:')
     print('  idVendor: %d (0x%04x)' % (dev.idVendor, dev.idVendor))
@@ -47,15 +48,15 @@ def printDeviceInfo(dev):
     print('Serial: %s' % (dev.iSerialNumber))
     print('Product: %s' % (dev.iProduct), end='\n\n')
 
-def sendDeviceToBootloaderMode(dev):
+def send_device_to_bootloader_mode(dev):
     """Tries to send a given ps2avrGB keyboard to bootloader mode to allow flashing."""
     try:
         dev.set_configuration()
 
         request_type = usb.util.build_request_type(
-                usb.util.CTRL_OUT,
-                usb.util.CTRL_TYPE_CLASS,
-                usb.util.CTRL_RECIPIENT_DEVICE)
+            usb.util.CTRL_OUT,
+            usb.util.CTRL_TYPE_CLASS,
+            usb.util.CTRL_RECIPIENT_DEVICE)
 
         USBRQ_HID_SET_REPORT = 0x09
         HID_REPORT_OPTION = 0x0301
@@ -65,16 +66,21 @@ def sendDeviceToBootloaderMode(dev):
         # for some reason I keep getting USBError, but it works!
         pass
 
+def auto_int(value):
+    """Helper for argparse to enable auto base detection"""
+    return int(value, 0)
 
-if len(sys.argv) < 2:
-    print('Usage: %s <firmware.hex>' % sys.argv[0])
-    sys.exit(1)
+parser = argparse.ArgumentParser(description='Flash bootloadHID device')
+parser.add_argument('--vendor', type=auto_int, default=0x20A0, help='Non bootloader idVendor to search for (default: 0x%(default)04x)')
+parser.add_argument('--product', type=auto_int, default=0x422D, help='Non bootloader idProduct to search for (default: 0x%(default)04x)')
+parser.add_argument('firmware_hex', type=argparse.FileType('r'), help='Firmware hex file to flash')
+args = parser.parse_args()
 
-kb = checkForKeyboardInNormalMode()
+kb = check_keyboard_normal_mode(args.vendor, args.product)
 
 if kb is not None:
     print('Found a keyboard in normal mode. Attempting to send it to bootloader mode ...', end='')
-    sendDeviceToBootloaderMode(kb)
+    send_device_to_bootloader_mode(kb)
     print(' done.')
     print("Hint: If your keyboard can't be set to bootloader mode automatically, plug it in while pressing the bootloader key to do so manually.")
     print("      You can find more infos about this here: https://github.com/qmk/qmk_firmware/tree/master/keyboards/ps2avrGB#setting-the-board-to-bootloader-mode")
@@ -84,9 +90,9 @@ found = False
 for attempt in range(1, attempts + 1):
     print("Searching for keyboard in bootloader mode (%i/%i) ... " % (attempt, attempts), end='')
 
-    if checkForKeyboardInBootloaderMode():
+    if check_keyboard_bootloader_mode():
         print('Found', end='\n\n')
-        flashKeyboard(sys.argv[1])
+        flash_keyboard(args.firmware_hex.name)
         found = True
         break
     else:
@@ -102,4 +108,3 @@ for attempt in range(1, attempts + 1):
 if not found:
     print("Couldn't find a flashable keyboard. Aborting.")
     sys.exit(2)
-

util/travis_build.sh

@@ -17,16 +17,18 @@ if [[ "$TRAVIS_COMMIT_MESSAGE" != *"[skip build]"* ]] ; then
 	else
 		NEFM=$(git diff --name-only -n 1 ${TRAVIS_COMMIT_RANGE} | grep -Ev '^(keyboards/)'  | grep -Ev '^(docs/)' | wc -l)
 		BRANCH=$(git rev-parse --abbrev-ref HEAD)
+		# is this branch master or a "non docs, non keyboards" change 
 		if [ $NEFM -gt 0 -o "$BRANCH" = "master" ]; then
 			echo "Making default keymaps for all keyboards"
 			eval $MAKE_ALL
 			: $((exit_code = $exit_code + $?))
 		else
-			MKB=$(git diff --name-only -n 1 ${TRAVIS_COMMIT_RANGE} | grep -oP '(?<=keyboards\/)([a-zA-Z0-9_\/]+)(?=\/)' | sort -u)
+		    # keyboards project format
+			#  /keyboards/board1/rev/keymaps/
+			#  /keyboards/board2/keymaps/
+			# ensure we strip everything off after and including the keymaps folder to get board and/or revision
+			MKB=$(git diff --name-only -n 1 ${TRAVIS_COMMIT_RANGE} | grep -oP '(?<=keyboards\/)([a-zA-Z0-9_\/]+)(?=\/)' | sed 's^/keymaps/.*^^' | sort -u)
 			for KB in $MKB ; do
-				if [[ $KB == *keymaps* ]]; then
-					continue
-				fi
 				KEYMAP_ONLY=$(git diff --name-only -n 1 ${TRAVIS_COMMIT_RANGE} | grep -Ev '^(keyboards/'${KB}'/keymaps/)' | wc -l)
 				if [[ $KEYMAP_ONLY -gt 0 ]]; then
 					echo "Making all keymaps for $KB"